pytorch对可变长度序列的处理方法详解_Python

pytorch对可变长度序列的处理方法详解

2021-04-26 00:50深度学习1 Python

今天小编就为大家分享一篇pytorch对可变长度序列的处理方法详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

主要是用函数torch.nn.utils.rnn.packedsequence()和torch.nn.utils.rnn.pack_padded_sequence()以及torch.nn.utils.rnn.pad_packed_sequence()来进行的,分别来看看这三个函数的用法。

1、torch.nn.utils.rnn.packedsequence()

note：这个类的实例不能手动创建。它们只能被 pack_padded_sequence() 实例化。

packedsequence对象包括：

一个data对象：一个torch.variable（令牌的总数，每个令牌的维度），在这个简单的例子中有五个令牌序列（用整数表示）：（18，1）

一个batch_sizes对象：每个时间步长的令牌数列表，在这个例子中为：[6，5，2，4，1]

用pack_padded_sequence函数来构造这个对象非常的简单：

pytorch对可变长度序列的处理方法详解

如何构造一个packedsequence对象（batch_first = true）

packedsequence对象有一个很不错的特性，就是我们无需对序列解包（这一步操作非常慢）即可直接在packedsequence数据变量上执行许多操作。特别是我们可以对令牌执行任何操作（即对令牌的顺序/上下文不敏感）。当然，我们也可以使用接受packedsequence作为输入的任何一个pytorch模块（pytorch 0.2）。

2、torch.nn.utils.rnn.pack_padded_sequence()

这里的pack，理解成压紧比较好。将一个填充过的变长序列压紧。（填充时候，会有冗余，所以压紧一下）

输入的形状可以是(t×b×* )。t是最长序列长度，b是batch size，*代表任意维度(可以是0)。如果batch_first=true的话，那么相应的 input size 就是 (b×t×*)。

variable中保存的序列，应该按序列长度的长短排序，长的在前，短的在后。即input[:,0]代表的是最长的序列，input[:, b-1]保存的是最短的序列。

note：只要是维度大于等于2的input都可以作为这个函数的参数。你可以用它来打包labels，然后用rnn的输出和打包后的labels来计算loss。通过packedsequence对象的.data属性可以获取 variable。

参数说明:

input (variable) – 变长序列被填充后的 batch

lengths (list[int]) – variable 中每个序列的长度。

batch_first (bool, optional) – 如果是true，input的形状应该是b*t*size。

返回值:

一个packedsequence 对象。

3、torch.nn.utils.rnn.pad_packed_sequence()

填充packed_sequence。

上面提到的函数的功能是将一个填充后的变长序列压紧。这个操作和pack_padded_sequence()是相反的。把压紧的序列再填充回来。

返回的varaible的值的size是 t×b×*, t 是最长序列的长度，b 是 batch_size,如果 batch_first=true,那么返回值是b×t×*。

batch中的元素将会以它们长度的逆序排列。

参数说明:

sequence (packedsequence) – 将要被填充的 batch

batch_first (bool, optional) – 如果为true，返回的数据的格式为 b×t×*。

返回值: 一个tuple，包含被填充后的序列，和batch中序列的长度列表。

例子：

									import torch

									import torch.nn as nn

									from torch.autograd import variable

									from torch.nn import utils as nn_utils

									batch_size = 2

									max_length = 3

									hidden_size = 2

									n_layers =1

									tensor_in = torch.floattensor([[1, 2, 3], [1, 0, 0]]).resize_(2,3,1)

									tensor_in = variable( tensor_in ) #[batch, seq, feature], [2, 3, 1]

									seq_lengths = [3,1] # list of integers holding information about the batch size at each sequence step

									# pack it

									pack = nn_utils.rnn.pack_padded_sequence(tensor_in, seq_lengths, batch_first=true)

									# initialize

									rnn = nn.rnn(1, hidden_size, n_layers, batch_first=true)

									h0 = variable(torch.randn(n_layers, batch_size, hidden_size))

									#forward

									out, _ = rnn(pack, h0)

									# unpack

									unpacked = nn_utils.rnn.pad_packed_sequence(out)

									print('111',unpacked)

输出：

									111 (variable containing:

									(0 ,.,.) =

									 0.5406 0.3584

									 -0.1403 0.0308

									(1 ,.,.) =

									 -0.6855 -0.9307

									 0.0000 0.0000

									[torch.floattensor of size 2x2x2]

									, [2, 1])