(04강) LSTM and GRU

210907

4. Long Short-Term Memory (LSTM) | Gated Recurrent Unit (GRU)

Long Short-Term Memory (LSTM)

Vanila Model의 Gradient Exploding/Vanishing 문제를 해결하고 Long Term Dependency 문제를 개선한 문제이다.

기존의 RNN 식은 다음과 같다.

$h_t = f_w(x_t,\ h_{t-1})$

LSTM에는 Cell state라는 값이 추가되며 식은 다음과 같다.

$\{C_t,\ h_t\} = LSTM(x_t,\ C_{t-1},\ h_{t-1})$

Cell state가 hidden state보다 좀 더 완성된, 필요로 하는 정보를 가지고 있는 벡터이며 이 cell state 벡터를 한번 더 가공해서 해당 time step에서 노출할 필요가 있는 정보를 필터링 할 수 있는 벡터로도 생각할 수 있다.

cell state를 한번 더 가공한 hidden state 벡터는 현재 timestep 에서 예측값을 계산하는 output layer의 입력벡터로 사용한다.

여기서 x는 x_t 이고 h는 h_(t-1) 이다.

Forget gate

이전 타임스텝에서 얻은 정보 중 일부만을 반영하겠다.

= 이전 타임스텝에서 얻은 정보 일부를 까먹겠다 = forget

Input gate

이번 셀에서 얻은 C tilda 값을 input gate와 곱해주는 이유는 다음과 같다.

한번의 선형변환만으로 $C_{t-1}$ 에 더해주는 정보를 만들기가 어렵다. 따라서 이 더해주는 정보를 일단 크게 만든 후에 각 차원별로 특정 비율만큼 덜어내서 더해주는 정보를 만들겠다 라는 목적이다.
이 때, 더해주는 정보보다 크게 만든 정보가 C tilda 이며 특정 비율만큼 덜어내는 작업이 input gate와 곱해주는 작업이다.

Output gate

"He said, 'I love you.' " 라는 문장이 있다고 하자. 현재 sequence가 love y 까지 들어왔고 y다음에 o를 출력으로 줘야 할 차례이다. 이 때 y의 입장에서는 당장의 작은 따옴표가 열린 사실은 중요하지 않지만, 계속 전달해줘야하는 정보이다. 그래서 Ct의 activate function을 거친값을 o_t에 곱해주는 것으로 해석할 수 있다.

Gated Recurrent Unit (GRU)

LSTM의 모델 구조를 경량화해서 적은 메모리 요구량과 빠른 계산이 가능하도록 만든 모델이다. 가장 큰 특징은 LSTM은 Cell과 Hidden이 있는 반면에 GRU에서는 Hidden만 존재한다는 것이다. 그러나 GRU의 동작원리는 LSTM과 굉장히 동일하다.

LSTM의 Cell의 역할을 GRU에서는 Hidden이 해주고 있다고 보면된다.
GRU 에서는 Input Gate만을 사용하며 Forget Gate 자리에는 1 - Input Gate 값을 사용한다.

실습

필요 패키지 import

from tqdm import tqdm
from torch import nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence

import torch

데이터 전처리

vocab_size = 100
pad_id = 0

data = [
  [85,14,80,34,99,20,31,65,53,86,3,58,30,4,11,6,50,71,74,13],
  [62,76,79,66,32],
  [93,77,16,67,46,74,24,70],
  [19,83,88,22,57,40,75,82,4,46],
  [70,28,30,24,76,84,92,76,77,51,7,20,82,94,57],
  [58,13,40,61,88,18,92,89,8,14,61,67,49,59,45,12,47,5],
  [22,5,21,84,39,6,9,84,36,59,32,30,69,70,82,56,1],
  [94,21,79,24,3,86],
  [80,80,33,63,34,63],
  [87,32,79,65,2,96,43,80,85,20,41,52,95,50,35,96,24,80]
]

max_len = len(max(data, key=len))

valid_lens = []
for i, seq in enumerate(tqdm(data)):
  valid_lens.append(len(seq))
  if len(seq) < max_len:
    data[i] = seq + [pad_id] * (max_len - len(seq))
    
# B: batch size, L: maximum sequence length
batch = torch.LongTensor(data)  # (B, L)
batch_lens = torch.LongTensor(valid_lens)  # (B)

batch_lens, sorted_idx = batch_lens.sort(descending=True)
batch = batch[sorted_idx]

이전 실습과 동일하다.

LSTM 사용

LSTM은 Cell state가 추가된다. shape는 hidden state와 동일하다.

embedding_size = 256
hidden_size = 512
num_layers = 1
num_dirs = 1

embedding = nn.Embedding(vocab_size, embedding_size)
lstm = nn.LSTM(
    input_size=embedding_size,
    hidden_size=hidden_size,
    num_layers=num_layers,
    bidirectional=True if num_dirs > 1 else False
)

h_0 = torch.zeros((num_layers * num_dirs, batch.shape[0], hidden_size))  # (num_layers * num_dirs, B, d_h)
c_0 = torch.zeros((num_layers * num_dirs, batch.shape[0], hidden_size))  # (num_layers * num_dirs, B, d_h)

hidden state와 cell state는 0으로 초기화한다.

# d_w: word embedding size
batch_emb = embedding(batch)  # (B, L, d_w)

packed_batch = pack_padded_sequence(batch_emb.transpose(0, 1), batch_lens)

packed_outputs, (h_n, c_n) = lstm(packed_batch, (h_0, c_0))
print(packed_outputs)
print(packed_outputs[0].shape)
print(h_n.shape)
print(c_n.shape)

PackedSequence(data=tensor([[-0.0690,  0.1176, -0.0184,  ..., -0.0339, -0.0347,  0.1103],
        [-0.1626,  0.0038,  0.0090,  ..., -0.1385, -0.0806,  0.0635],
        [-0.0977,  0.1470, -0.0678,  ...,  0.0203,  0.0201,  0.0175],
        ...,
        [-0.1911, -0.1925, -0.0827,  ...,  0.0491,  0.0302, -0.0149],
        [ 0.0803, -0.0229, -0.0772,  ..., -0.0706, -0.1711, -0.2128],
        [ 0.1861, -0.1572, -0.1024,  ..., -0.0090, -0.2621, -0.2803]],
       grad_fn=<CatBackward>), batch_sizes=tensor([10, 10, 10, 10, 10,  9,  7,  7,  6,  6,  5,  5,  5,  5,  5,  4,  4,  3,
         1,  1]), sorted_indices=None, unsorted_indices=None)
torch.Size([123, 512])
torch.Size([1, 10, 512])
torch.Size([1, 10, 512])

hidden state와 cell state의 크기가 같은것을 볼 수 있다.
packed_outputs 의 사이즈가 123인 이유를 아는가? 사실은 200이어야 한다. 여기서 0의 개수를 빼면 123이된다!

outputs, output_lens = pad_packed_sequence(packed_outputs)
print(outputs.shape)
print(output_lens)

torch.Size([20, 10, 512])
tensor([20, 18, 18, 17, 15, 10,  8,  6,  6,  5])

GPU 사용

GPU는 Cell state가 없다. 그 외에는 동일하다.

gru = nn.GRU(
    input_size=embedding_size,
    hidden_size=hidden_size,
    num_layers=num_layers,
    bidirectional=True if num_dirs > 1 else False
)

output_layer = nn.Linear(hidden_size, vocab_size)

input_id = batch.transpose(0, 1)[0, :]  # (B)
hidden = torch.zeros((num_layers * num_dirs, batch.shape[0], hidden_size))  # (1, B, d_h)

Teacher forcing 없이 이전에 얻은 결과를 다음 input으로 이용한다.

Teacher forcing이란, Seq2seq(Encoder-Decoder)를 기반으로 한 모델들에서 많이 사용되는 기법이다. 아래 설명과 이미지는 여기를 참고했다.

t-1번째의 디코더 셀이 예측한 값을 t번째 디코더의 입력으로 넣어준다. t-1번째에서 정확한 예측이 이루어진다면 엄청난 장점을 가지는 구조지만, 잘못된 예측 앞에서는 엄청난 단점이 되어버린다.
다음은 단점이 되어버린 RNN의 잘못된 예측이 선행된 경우

이러한 단점은 학습 초기에 학습 속도 저하의 요인이 되며 이를 해결하기 위해 나온 기법이 티쳐포싱이다.

위와 같이 입력을 Ground Truth로 넣어주게 되면, 학습시 더 정확한 예측이 가능하게 되어 초기 학습 속도를 빠르게 올릴 수 있다.
그러나 단점으로는 노출 편향 문제가 있다. 추론 과정에서는 Ground Truth를 제공할 수 없기 때문에 학습과 추론 단계에서의 차이가 존재하게 되고 이는 모델의 성능과 안정성을 떨어뜨릴 수 있다.
다만 노출 편향 문제가 생각만큼 큰 영향을 미치지 않는다는 연구결과가 있다.

(T. He, J. Zhang, Z. Zhou, and J. Glass. Quantifying Exposure Bias for Neural Language Generation (2019), arXiv.)

for t in range(max_len):
  input_emb = embedding(input_id).unsqueeze(0)  # (1, B, d_w)
  output, hidden = gru(input_emb, hidden)  # output: (1, B, d_h), hidden: (1, B, d_h)

  # V: vocab size
  output = output_layer(output)  # (1, B, V)
  probs, top_id = torch.max(output, dim=-1)  # probs: (1, B), top_id: (1, B)

  print("*" * 50)
  print(f"Time step: {t}")
  print(output.shape)
  print(probs.shape)
  print(top_id.shape)

  input_id = top_id.squeeze(0)  # (B)

양방향 및 여러 layer 사용

num_layers = 2
num_dirs = 2
dropout=0.1

gru = nn.GRU(
    input_size=embedding_size,
    hidden_size=hidden_size,
    num_layers=num_layers,
    dropout=dropout,
    bidirectional=True if num_dirs > 1 else False
)

여기서는 2개의 레이어 및 양방향을 사용한다. 그래서 hidden state의 크기도 (4, Batchsize, hidden dimension) 이 된다.

# d_w: word embedding size, num_layers: layer의 개수, num_dirs: 방향의 개수
batch_emb = embedding(batch)  # (B, L, d_w)
h_0 = torch.zeros((num_layers * num_dirs, batch.shape[0], hidden_size))  # (num_layers * num_dirs, B, d_h) = (4, B, d_h)

packed_batch = pack_padded_sequence(batch_emb.transpose(0, 1), batch_lens)

packed_outputs, h_n = gru(packed_batch, h_0)
print(packed_outputs)
print(packed_outputs[0].shape)
print(h_n.shape)

PackedSequence(data=tensor([[-0.0214, -0.0892,  0.0404,  ..., -0.2017,  0.0148,  0.1133],
        [-0.1170,  0.0341,  0.0420,  ..., -0.1387,  0.1696,  0.2475],
        [-0.1272, -0.1075,  0.0054,  ..., -0.0152, -0.0856, -0.0097],
        ...,
        [ 0.2953,  0.1022, -0.0146,  ...,  0.0467, -0.0049, -0.1354],
        [ 0.1570, -0.1757, -0.1698,  ...,  0.0369, -0.0073,  0.0044],
        [ 0.0541,  0.1023, -0.1941,  ...,  0.0117,  0.0276,  0.0636]],
       grad_fn=<CatBackward>), batch_sizes=tensor([10, 10, 10, 10, 10,  9,  7,  7,  6,  6,  5,  5,  5,  5,  5,  4,  4,  3,
         1,  1]), sorted_indices=None, unsorted_indices=None)
torch.Size([123, 1024])
torch.Size([4, 10, 512])

실제로 히든 스테이트의 크기가 4로 시작하는 것을 알 수 있다. 또한, packed_outputs 역시 256개가 아니라 1024개의 차원으로 이루어진 것을 알 수 있다.

outputs, output_lens = pad_packed_sequence(packed_outputs)

print(outputs.shape)  # (L, B, num_dirs*d_h)
print(output_lens)

torch.Size([20, 10, 1024])
tensor([20, 18, 18, 17, 15, 10,  8,  6,  6,  5])

Previous(05강) Sequence to Sequence with Attention Next(03강) Recurrent Neural Network and Language Modeling

Last updated 3 years ago

Was this helpful?