Powyższe odpowiedzi odpowiadały na pytanie, dlaczego bardzo dobrze. Chcę tylko dodać przykład, aby lepiej zrozumieć użycie pack_padded_sequence
.
Weźmy przykład
Uwaga: pack_padded_sequence
wymaga posortowanych sekwencji w partii (w kolejności malejącej długości sekwencji). W poniższym przykładzie partia sekwencji została już posortowana pod kątem mniejszego bałaganu. Odwiedź ten link z treścią, aby uzyskać pełną implementację.
Najpierw tworzymy partię 2 sekwencji o różnych długościach sekwencji, jak poniżej. Mamy w zestawie łącznie 7 elementów.
- Każda sekwencja ma rozmiar osadzania 2.
- Pierwsza sekwencja ma długość: 5
- Druga sekwencja ma długość: 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]
Podkładamy, seq_batch
aby uzyskać partię sekwencji o równej długości 5 (maksymalna długość w partii). Teraz nowa partia ma w sumie 10 elementów.
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]]])
"""
Następnie pakujemy padded_seq_batch
. Zwraca krotkę dwóch tensorów:
- Pierwsza to dane zawierające wszystkie elementy w partii sekwencji.
- Drugi to,
batch_sizes
który powie, w jaki sposób elementy są ze sobą powiązane za pomocą kroków.
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]))
"""
Teraz przekazujemy krotkę packed_seq_batch
do powtarzających się modułów w Pytorch, takich jak RNN, LSTM. Wymaga to jedynie 5 + 2=7
obliczeń w module rekurencyjnym.
lstm = nn.LSTM(input_size=2, hidden_size=3, batch_first=True)
output, (hn, cn) = lstm(packed_seq_batch.float())
"""
>>> 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>)))
"""
Musimy przekonwertować z output
powrotem na wypełnioną partię danych wyjściowych:
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])
"""
Porównaj ten wysiłek ze standardowym sposobem
W standardowy sposób musimy tylko przekazać moduł padded_seq_batch
do lstm
. Wymaga jednak 10 obliczeń. Obejmuje kilka obliczeń więcej na elementach wypełniających, co byłoby nieefektywne obliczeniowo .
Należy zauważyć, że nie prowadzi to do niedokładnych reprezentacji, ale wymaga znacznie więcej logiki, aby wyodrębnić prawidłowe reprezentacje.
- Dla LSTM (lub dowolnych powtarzających się modułów) z tylko kierunkiem do przodu, jeśli chcielibyśmy wyodrębnić ukryty wektor ostatniego kroku jako reprezentację dla sekwencji, musielibyśmy pobrać ukryte wektory z T (tego) kroku, gdzie T jest długością wejścia. Podjęcie ostatniej reprezentacji będzie nieprawidłowe. Zauważ, że T będzie różne dla różnych wejść w partii.
- W przypadku dwukierunkowego LSTM (lub dowolnych powtarzających się modułów) jest to jeszcze bardziej kłopotliwe, ponieważ należałoby utrzymywać dwa moduły RNN, jeden działający z dopełnieniem na początku wejścia, a drugi z wypełnieniem na końcu wejścia, ostatecznie wyodrębnianie i konkatenacja ukrytych wektorów, jak wyjaśniono powyżej.
Zobaczmy różnicę:
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 >))
"""
Powyższe wyniki wskazują, że hn
, cn
są różne w obu sposobów, podczas gdy output
z dwóch sposobów prowadzić do różnych wartości elementów wypełniających.