NLP中各框架对变长序列的处理全解

今天药忘吃喽~ 2023-03-01 12:52 67阅读 0赞

在NLP中，文本数据大都是变长的，为了能够做batch的训练，需要padding到相同的长度，并在实际训练中忽略padding部分的影响。

在不同的深度学习框架中，对变长序列的处理，本质思想都是一致的，但具体的实现方式有较大差异，下面针对Pytorch、Keras和TensorFlow三大框架，以LSTM模型为例，说明各框架对NLP中变长序列的处理方式和注意事项。

### Pytorch ###

在pytorch中，是用的torch.nn.utils.rnn中的 pack\_padded\_sequence 和 pad\_packed\_sequence 来处理变长序列，前者可以理解为对 padded 后的 sequence 做pack（打包/压紧），也就是去掉 padding 位，但会记录每个样本的有效长度信息；后者是逆操作，对 packed 后的 sequence 做 pad，恢复到相同的长度。

不过在使用过程中，要格外注意 pack\_padded\_sequence 的 enforce\_sorted 参数和 pad\_packed\_sequence 的total\_length 参数。

#### pack\_padded\_sequence ####

下面是pack\_padded\_sequence函数的部分 Pytorch 源码，input就是输入的一个batch的tensor，lengths是这个batch中每个样本的有效长度。

def pack_padded_sequence(input, lengths, batch_first=False, enforce_sorted=True):
    	...
        if enforce_sorted:
            sorted_indices = None
        else:
            lengths, sorted_indices = torch.sort(lengths, descending=True)
            sorted_indices = sorted_indices.to(input.device)
            batch_dim = 0 if batch_first else 1
            input = input.index_select(batch_dim, sorted_indices)
        ...

在pack\_padded\_sequence处理之后，会得到一个 PackedSequence 的数据，其除了记录Tensor data之外，还会记录 batch\_sizes, sorted\_indices 和 unsorted\_indices，其中 batch\_sizes 是将输入按照有效长度排序之后，每个时间步对应的batch大小，后面会有例子；sorted\_indices就是对输入lengths排序后的索引，unsorted\_indices 是用来将排序数据恢复到原始顺序的索引。

在pack\_padded\_sequence中，enforce\_sorted默认设置为True，也就是说输入的batch数据要事先按照长度排序，才能输入，实际上，更简单的方式是，将其设置为False，从上面的代码中也可以看出，Pytorch会自动给我们做排序。

注：torch1.1及之后才有 enforce\_sorted 参数，因此 torch1.1 之后才有自动排序功能。

一个简单的例子：

# input_tensor shape：batch_size=2,time_step=3,dim=1
    input_tensor = torch.FloatTensor([[4, 0, 0], [5, 6, 0]]).resize_(2, 3, 1)
    seq_lens = torch.IntTensor([1, 2])
    x_packed = nn_utils.rnn.pack_padded_sequence(input_tensor, seq_lens, batch_first=True, enforce_sorted=False)

输出的 x\_packed 为：

PackedSequence(data=tensor([[5.],
            [4.],
            [6.]]), batch_sizes=tensor([2, 1]), sorted_indices=tensor([1, 0]), unsorted_indices=tensor([1, 0]))

在上面的例子中，首先，经过pack\_padded\_sequence 内部按有效长度逆序排列之后，输入数据会变成：

[[5, 6, 0],
    [4, 0, 0]]

PackedSequence中的data是按照 time\_step 这个维度，也就是按列来记录数据的，但是不包括padding位

![在这里插入图片描述][20200726112740190.png]

该图仅作为理解参考，图片来自：https://www.cnblogs.com/lindaxin/p/8052043.html

batch\_sizes 记录的每列有几个数据是有效的，也就是每列有效的 batch\_size 长度，但是不包括为0的长度，因此上面例子中，x\_packed 的 batch\_sizes=tensor(\[2, 1\])，因此，每个time\_step 只需要传入对应batch\_size个数据即可，可以减少计算量。

要注意的是，batch\_sizes这个tensor的长度是2，而input\_tensor的time\_step是3，因为 batch\_sizes 不包含都是padding的时间步，也就是上面的第三列，因此后面的pad\_packed\_sequence 要注意设置total\_length参数。

#### pad\_packed\_sequence ####

下面是pad\_packed\_sequence函数的部分 Pytorch 源码，输入sequence是 PackedSequence 型数据。pad\_packed\_sequence 实际上就是做一个padding 操作和根据索引恢复数据顺序操作。

def pad_packed_sequence(sequence, batch_first=False, padding_value=0.0, total_length=None):
    	max_seq_length = sequence.batch_sizes.size(0)
        if total_length is not None:
            max_seq_length = total_length
        ...

这里要注意的一个参数是total\_length，它是 sequence 需要去被padding的长度，我们期望的一般都是padding到和输入序列一样的 time\_step 长度 ，但是PackedSequence 型数据并没有记录这个数据，因此它用的是sequence.batch\_sizes.size(0)，也就是 batch\_sizes 这个tensor的长度。

上面已经提到，batch\_sizes 不包含都是padding的时间步，这样，如果整个batch中的每条记录有都做padding，那batch\_sizes 这个tensor的长度就会小于time\_step ，就像上面代码中的例子。

这时如果没有设置total\_length，pad\_packed\_sequence就不会padding到我们想要的长度。

可能你在实际使用时，不设置 total\_length 参数也没有出现问题，那大概率是因为你的每个batch中，都有至少一条记录没有padding位，也就是它的每一步都是有效位，那sequence.batch\_sizes.size(0)就等于time\_step。

#### 使用方式 ####

为了方便使用，这里将pack\_padded\_sequence，LSTM和 pad\_packed\_sequence 做了一个封装，参数和原始LSTM一样，唯一的区别是使用中要输入 seq\_lens 数据。

class MaskedLSTM(Module):
        def __init__(self, input_size, hidden_size, num_layers=1, bias=True, batch_first=False, dropout=0., bidirectional=False):
            super(MaskedLSTM, self).__init__()
            self.batch_first = batch_first
            self.lstm = LSTM(input_size, hidden_size, num_layers=num_layers, bias=bias,
                 batch_first=batch_first, dropout=dropout, bidirectional=bidirectional)
    
        def forward(self, input_tensor, seq_lens):
            # input_tensor shape: batch_size*time_step*dim , seq_lens: (batch_size,)  when batch_first = True
            total_length = input_tensor.size(1) if self.batch_first else input_tensor.size(0)
            x_packed = pack_padded_sequence(input_tensor, seq_lens, batch_first=self.batch_first, enforce_sorted=False)
            y_lstm, hidden = self.lstm(x_packed)
            y_padded, length = pad_packed_sequence(y_lstm, batch_first=self.batch_first, total_length=total_length)
            return y_padded, hidden

小总结：

使用pack\_padded\_sequence和pad\_packed\_sequence之后，LSTM输出对应的padding位是全0的，隐藏层输出 (h\_n,c\_n) 都是不受padding影响的，都是padding前最后一个有效位的输出，而且对单向/双向LSTM都是没有影响的，因为padding位不参与运算，即减少了不必要的计算，又避免了padding位对输出的影响。

### Keras ###

在keras中，自带有Masking层，简单方便，使用了一个mask操作则可以贯穿后面的整个模型，实际的过程是把一个布尔型的mask矩阵一直往下游传递下去，当然这个矩阵的维度会根据当前层的维度情况重新调整，以使其能在下游层中被使用。

确实方便，但也因此丢失了灵活性，如果使用了mask，则后面层都要支持mask，否则会报异常，这对于一些不支持mask的层，例如Flatten、AveragePooling1D等等，并不是很友好。

keras中对于变长序列的处理，一般使用Masking层，如果需要用到Embedding层，那可以直接在Embedding中设置mask\_zero=True，就不需要再加Masking层了，但本质上都是建了布尔型的mask矩阵并往下游传递下去。

下面是Masking和Embedding层的定义

Masking(mask_value=0.,input_shape=(time_step,feature_size))
    Embedding(input_dim, output_dim, mask_zero=False, input_length=None)

下面是 Embedding 层中的mask计算函数，如果 mask\_zero 设置为True，那这里会计算mask矩阵并往后传递，如果要继续深入其传递的机制，建议看keras源码，也可以参考一下这个：[keras源码分析之Layer][keras_Layer]

# Embedding 层中的mask计算函数
    def compute_mask(self, inputs, mask=None):
        if not self.mask_zero:
            return None
        output_mask = K.not_equal(inputs, 0)
        return output_mask

不过要注意的一点是，mask\_zero 设置为True，输入通过Embedding后，padding位所对应的向量并不是全0，仍然是一个随机的向量，和mask\_zero 的值没有关系，mask\_zero 只是影响是否计算mask矩阵。但是有了mask矩阵之后，padding位都不会被计算，因此，其对应向量的值并不重要。

#### 使用方式 ####

input = keras.layers.Input((time_step,feature_size))
    mask = keras.layers.Masking(mask_value=0, input_shape=(time_step,feature_size))(input)
    lstm_output = keras.layers.LSTM(hidden_size, return_sequences=True)(mask)
    model = Model(input, lstm_output)

或

input = keras.layers.Input((time_step,))
    embed = keras.layers.Embedding(vocab_size, embedding_size, mask_zero=True)(input)
    lstm_output = keras.layers.LSTM(hidden_size, return_sequences=True)(emd)
    model = Model(input, lstm_output)

keras模型中，Masking之后的层，只要支持mask，都不用再手动创建mask了，当然，如果是自己定义的层，要支持mask，需要设置supports\_masking=True，并实现自己的 compute\_mask 函数。

要注意的是，和pytorch、TF有些不一样的地方，对于有了Masking层之后的LSTM，padding位的输出不会是全0，而是最后一位有效位的输出，也就是padding位输出都复制了最后有效位的输出。

Embedding层和Masking层都有mask功能，但与Masking层不同的是，Embedding它只能过滤0，不能指定其他字符。

### TensorFlow ###

在 TF (tf 1.x) 中是通过 dynamic\_rnn 来实现变长序列的处理，它和pytorch的pack\_padded\_sequence一样，也有 sequence\_length 参数，但它相对比pytorch更方便，不用手动去pack和pad，只要传递sequence\_length 参数，其他都由 dynamic\_rnn 来完成。

但是TF中 dynamic\_rnn 计算的循环次数仍然是time\_steps 次，并没有带来计算效率上的提升。sequence length 的作用只是在每个序列达到它的实际长度后，把后面时间步的输出全部置成零、状态全部置成实际长度那个时刻的状态。

这一点可以参考：https://www.zhihu.com/question/52200883

#### 使用方式 ####

# 静态图定义部分
    basic_cell = tf.nn.rnn_cell.LSTMCell(hidden_size)
    X = tf.placeholder(tf.float32, shape=[None, time_step, dim])
    seq_length = tf.placeholder(tf.int32, [None])
    outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32, sequence_length=seq_length)

不过，在 TF 2.x 中废弃了tf.nn.dynamic\_rnn函数，官方建议使用 tf.keras 来处理变长序列，也就是和上面的 Keras 框架的处理方式是一样的。

以上是从应用和代码的角度，介绍了Pytorch、Keras和TensorFlow三大框架对变长数据的处理和使用方式，但这不仅仅适用于NLP领域，只是在NLP中变长数据更为常见，希望能帮助你在工程实践中更好地去处理变长的数据。

[20200726112740190.png]: /images/20230208/d63a5f32a87041adac3114b7d7d82017.png
[keras_Layer]: https://blog.csdn.net/u012526436/article/details/98206560