Приведенные выше ответы на вопрос почему очень хорошо.Я просто хочу добавить пример для лучшего понимания использования pack_padded_sequence.
Давайте рассмотрим пример
Примечание: pack_padded_sequence требует отсортированных последовательностей в пакете (вв порядке убывания длин последовательностей).В приведенном ниже примере партия последовательности уже отсортирована для уменьшения помех.Посетите эту ссылку для полной реализации.
Сначала мы создадим пакет из 2 последовательностей с разной длиной последовательности, как показано ниже.Всего в пакете 7 элементов.
- Каждая последовательность имеет размер вложения 2.
- Первая последовательность имеет длину: 5
- Вторая последовательность имеетдлина: 2
import torch
seq_batch = [torch.tensor([[1, 1],
[2, 2],
[3, 3],
[4, 4],
[5, 5]]),
torch.tensor([[10, 10],
[20, 20]])]
seq_lens = [5, 2]
Мы дополняем seq_batch, чтобы получить пакет последовательностей с равной длиной 5 (максимальная длина в пакете).Теперь в новой партии всего 10 элементов.
# pad the seq_batch
padded_seq_batch = torch.nn.utils.rnn.pad_sequence(seq_batch, batch_first=True)
"""
>>>padded_seq_batch
tensor([[[ 1, 1],
[ 2, 2],
[ 3, 3],
[ 4, 4],
[ 5, 5]],
[[10, 10],
[20, 20],
[ 0, 0],
[ 0, 0],
[ 0, 0]]])
"""
Затем мы упаковываем padded_seq_batch.Он возвращает кортеж из двух тензоров:
- Первый - это данные, включающие все элементы в пакете последовательности.
- Второй -
batch_sizes, который расскажет, как элементысвязаны друг с другом по шагам.
# pack the padded_seq_batch
packed_seq_batch = torch.nn.utils.rnn.pack_padded_sequence(padded_seq_batch, lengths=seq_lens, batch_first=True)
"""
>>> packed_seq_batch
PackedSequence(
data=tensor([[ 1, 1],
[10, 10],
[ 2, 2],
[20, 20],
[ 3, 3],
[ 4, 4],
[ 5, 5]]),
batch_sizes=tensor([2, 2, 1, 1, 1]))
"""
Теперь мы передаем кортеж packed_seq_batch рекуррентным модулям в Pytorch, таким как RNN, LSTM.Это требует только 5 + 2=7 вычислений в рекуррентном модуле.
lstm = nn.LSTM(input_size=2, hidden_size=3, batch_first=True)
output, (hn, cn) = lstm(packed_seq_batch.float()) # pass float tensor instead long tensor.
"""
>>> output # PackedSequence
PackedSequence(data=tensor(
[[-3.6256e-02, 1.5403e-01, 1.6556e-02],
[-6.3486e-05, 4.0227e-03, 1.2513e-01],
[-5.3134e-02, 1.6058e-01, 2.0192e-01],
[-4.3123e-05, 2.3017e-05, 1.4112e-01],
[-5.9372e-02, 1.0934e-01, 4.1991e-01],
[-6.0768e-02, 7.0689e-02, 5.9374e-01],
[-6.0125e-02, 4.6476e-02, 7.1243e-01]], grad_fn=<CatBackward>), batch_sizes=tensor([2, 2, 1, 1, 1]))
>>>hn
tensor([[[-6.0125e-02, 4.6476e-02, 7.1243e-01],
[-4.3123e-05, 2.3017e-05, 1.4112e-01]]], grad_fn=<StackBackward>),
>>>cn
tensor([[[-1.8826e-01, 5.8109e-02, 1.2209e+00],
[-2.2475e-04, 2.3041e-05, 1.4254e-01]]], grad_fn=<StackBackward>)))
"""
Нам нужно преобразовать output обратно в дополняемый пакет вывода:
padded_output, output_lens = torch.nn.utils.rnn.pad_packed_sequence(output, batch_first=True, total_length=5)
"""
>>> padded_output
tensor([[[-3.6256e-02, 1.5403e-01, 1.6556e-02],
[-5.3134e-02, 1.6058e-01, 2.0192e-01],
[-5.9372e-02, 1.0934e-01, 4.1991e-01],
[-6.0768e-02, 7.0689e-02, 5.9374e-01],
[-6.0125e-02, 4.6476e-02, 7.1243e-01]],
[[-6.3486e-05, 4.0227e-03, 1.2513e-01],
[-4.3123e-05, 2.3017e-05, 1.4112e-01],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00],
[ 0.0000e+00, 0.0000e+00, 0.0000e+00]]],
grad_fn=<TransposeBackward0>)
>>> output_lens
tensor([5, 2])
"""
Сравните это усилие со стандартным способом
Стандартным способом нам нужно только передать модуль padded_seq_batch в lstm.Однако для этого требуется 10 вычислений.Он включает в себя несколько вычислений для дополнительных элементов, которые будут вычислительно неэффективными.
Обратите внимание, что это не приводит к неточным представлениям, но требует гораздо больше логики для извлечения правильных представлений.
- Для LSTM (или любые рекуррентные модули) только с прямым направлением, если мы хотим извлечь скрытый вектор последнего шага в качестве представления последовательности, нам нужно будет выбрать скрытые векторы с шага T (th), где T - длинаввода.Подобрать последнее представление будет некорректно.Обратите внимание, что T будет отличаться для разных входов в партии.
- Для двунаправленного LSTM (или любых рекуррентных модулей) это еще более обременительно, поскольку необходимо поддерживать два модуля RNN, один из которых работает с заполнением в начале ввода, а другой - с заполнением вконец ввода и, наконец, извлечение и объединение скрытых векторов, как описано выше.
Давайте посмотрим на разницу:
# The standard approach: using padding batch for recurrent modules
output, (hn, cn) = lstm(padded_seq_batch.float())
"""
>>> output
tensor([[[-3.6256e-02, 1.5403e-01, 1.6556e-02],
[-5.3134e-02, 1.6058e-01, 2.0192e-01],
[-5.9372e-02, 1.0934e-01, 4.1991e-01],
[-6.0768e-02, 7.0689e-02, 5.9374e-01],
[-6.0125e-02, 4.6476e-02, 7.1243e-01]],
[[-6.3486e-05, 4.0227e-03, 1.2513e-01],
[-4.3123e-05, 2.3017e-05, 1.4112e-01],
[-4.1217e-02, 1.0726e-01, -1.2697e-01],
[-7.7770e-02, 1.5477e-01, -2.2911e-01],
[-9.9957e-02, 1.7440e-01, -2.7972e-01]]],
grad_fn= < TransposeBackward0 >)
>>> hn
tensor([[[-0.0601, 0.0465, 0.7124],
[-0.1000, 0.1744, -0.2797]]], grad_fn= < StackBackward >),
>>> cn
tensor([[[-0.1883, 0.0581, 1.2209],
[-0.2531, 0.3600, -0.4141]]], grad_fn= < StackBackward >))
"""
Приведенные выше результаты показываютчто hn, cn отличаются двумя способами, а output двумя способами приводят к различным значениям для элементов заполнения.