과거의 것들/AI Tech boostcamp

AITech 학습정리-[DAY 18] seq2seq with attention, Beam search and BLEU score

용나리 2021. 11. 27. 00:03

===================================

학습내용

(5강) Sequence to Sequence with Attention

seq2seq model

문장받는 encoder, 문장 생성하는 decoder

서로 간섭없이 생성하는. LSTM을 채용한 걸 알 수 있음.

encoder의 마지막 hidden state가 decoder의 처음 시작 hidden state로 쓰임.

decoder 시작 <SoS> start of sequence. 마지막 <EoS>.

이 모델에 Attention 추가 활용 가능. 얘는 encoder dimension 에 맞춰 모든 정보들을 압축하여 넣어야 하는 문제점. 첫 단어가 잘못되서 전체적으로 잘못된다.. 그래서 아얘 거꾸로 해보는 방법도 고안되긴 했었음.. 또 훨씬 이전에 나타난 정보는 변질이나 소실가능.

attention은 encoder 과정에만 의지하는게 아니다. 입력 될 때 입력된 단어의 hidden state는 거기에 주로 집중됨. 이 각각의 time step 별 hidden state들을 저장해서 decoder에 다 넣는다. 알아서 선별함. 적절히 선택해서 예측한다.

decoder 선별은 현재 가지고 있는 hidden state와 encoder hidden state 각각들과의 내적을 통해 결정하고 어디에 가중치를 둘지를 봐서 정보를 사용. 그래서 자기 다음 time step에 넣는것과 선별하는 것 두개를 한다.

가중 평균된 걸 context vector라고도 부름. 그래서 attention model을 정의하자면 input으로 decoder의 hidden state와 encoder에서 사용한 각각의 hidden state들 로 볼 수 있고 output 으로는 각각 가중치 평균 합으로 구한 context vector 라고 정의 가능.

attention output은 결과와 concat 되서 함께 사용됨.

backpropagation도 attention distribution을 거치며 진행됨.

실제 훈련할 때는 실전처럼 decoder의 output을 다음 input으로 넣고 하는게 아니라 output에 상관없이 다음 입력에 ground truth를 넣어준다. 그래야 output이 엉터리로 나와도 제대로 학습 할 수 있기 때문. 이거를 Teacher forcing 이라고 함. 실제 테스트 할 때는 안이러니까 괴리감이 느껴지긴 한다..

근데 현재 decoder hidden state와 encoder의 hidden state 들과의 내적을 통해 점수를 계산했잖아? 여기에서도 다양하게 확장, 변형을 했다.

general은 확장해서 가중치를 부여. 근데 중간에 matrix를 넣어 가중치를 부여하는데 이렇게 하면 hidden cell 간의 서로간의 영향도 고려 가능하다.

concat은 작은 neural networks.

이렇게 하면 기존에 score에서 내적으로만 구해서 score를 구하는건 학습이 안됬는데 이것 조차 backpropagation 과정에서 학습 가능.

이렇게 attention을 사용하면 그냥 잘 되고, 긴 문장일 때 encoder의 초기문장이 사라지는 등의 문제 해결, backpropagation에서 gradient 학습할 때도 원래 마지막부터 encoder의 처음 hidden state 까지 거쳐가며 학습해서 사라지는 문제도 해결, 적절하게 학습되고 언제 어느 단어를 주요해서 봐야할 지(alignment)를 스스로 배운다. 즉 어순 및 주변 단어와의 관계도 배운다..

(6강) Beam Search and BLEU

현재 time step 에서 가장 좋아보이는 걸 그때그때 선택하는게 Greedy decoding. 중간에 만약 잘못 해석했다면? 못돌아가네.. 어케 해결하지?

그래서 모든 확률 경우의 수를 고려하는 무식하지만 원초적이고 확실한 방법이 있다. 사실 이게 이상적인 방식임. 그러나 V^t의 복잡도를 가지기 때문에 전에 RNN 에서 했던 2^n 을 앞뒤만 dependency 하다고 고려해서 파라미터 수를 줄였던 것처럼 여기서도 비슷한 방법을 이용한다. 그때그때만 고려하는 greedy 와 이상적인 Exhaustive search 사이의 적절한 방법을 사용한게 Beam search.

각각의 step 마다 번역 가능한 후보개 k를 정한다. 또 exhaustive search 에서도 그렇고 확률을 곱해서 결정하지만 이 확률을 log를 써도 제일 높은건 제일 높다는 것을 이용해서 곱셈을 덧셈으로 바꿔줌. 그래서 이상적인 정답이라고 장담할 순 없지만 전체 다 하는 것보다는 빠르다. 그래서 k가 어쨋단건데? 는 밑의 예제를 보자.

이런식으로 수치적으로 가능성이 제일 높은거를 k개를 선정하고 그것을 누적시켜가며 찾는다.

<END> 토큰을 만날때까지 수행하고 만나면 몌모리에 임시저장하고..를 계속한다.

이걸 언제까지 하는가? 우리가 T만큼만 최대로 중단해서 완료된 hyipotheses가 정해둔 n개만큼만 있다면.

그래서 선정한 candidate들 중 가장 높은걸 사용한다. 근데 계속 -를 더해서 누적하는거라 가장 짧은게 점수가 제일 높을것이기 때문에 단어의 수 t로 나눠서 정규화한다.

BLEU score

생성모델의 품질, 결과를 평가하는 BLEU score

이렇게 단순히 위치로 하다보면 맞는데도 불구하고 0% 정답이라고 나올 수가 있다. 그래서 단순하게 이렇게 할 수 없으니까 필요한거.

단어의 맞춘 개수, 길이로 정밀도 precision, 재현율 recall을 고려해 얼마나 맞았는지 체점함.

조화평균을 쓸 수록 조금 더 내분점에 가까워짐. 그래서 내분점에 가까워지는 평균으로 쓰고싶다 해서 쓰는듯.

근데 엥? 문법 어순 다 틀려도 단어만 있으면 정답되니까 안된다.

그래서 BLEU score. 단어가 얼마나 겹치는지 뿐만 아니라 N-gram이라는, 1개, 2개, n개를 연속해서 봤을 때 얼마나 매칭되느냐로 평가하는 것이 특징. recall은 무시하고 precision만 사용. precision 특성 때문. 빠짐없이 번역했냐 보단 의미를 얼마나 잘 번역했는지.

조화평균은 너무 내분점으로 지나치게 가는것 같다.. 그래서 기하평균을 쓰는 숨은의도. 또 너무 짧은 문장엔 패널티 줘서 짧지 않도록.

실습

seq2seq

##5. Seq2seq 1. Encoder를 구현합니다. 2. Decoder를 구현합니다. 3. Seq2seq 모델을 구축하고 사용합니다.

필요 패키지 import

[-]

from tqdm import tqdm

from torch import nn

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

import torch

import random

데이터 전처리

src_data를 trg_data로 바꾸는 task를 수행하기 위한 sample data입니다.
전체 단어 수는 100100개이고 다음과 같이 pad token, start token, end token의 id도 정의합니다.

[-]

vocab_size = 100

pad_id = 0

sos_id = 1

eos_id = 2

src_data = [

[3, 77, 56, 26, 3, 55, 12, 36, 31],

[58, 20, 65, 46, 26, 10, 76, 44],

[58, 17, 8],

[59],

[29, 3, 52, 74, 73, 51, 39, 75, 19],

[41, 55, 77, 21, 52, 92, 97, 69, 54, 14, 93],

[39, 47, 96, 68, 55, 16, 90, 45, 89, 84, 19, 22, 32, 99, 5],

[75, 34, 17, 3, 86, 88],

[63, 39, 5, 35, 67, 56, 68, 89, 55, 66],

[12, 40, 69, 39, 49]

]

trg_data = [

[75, 13, 22, 77, 89, 21, 13, 86, 95],

[79, 14, 91, 41, 32, 79, 88, 34, 8, 68, 32, 77, 58, 7, 9, 87],

[85, 8, 50, 30],

[47, 30],

[8, 85, 87, 77, 47, 21, 23, 98, 83, 4, 47, 97, 40, 43, 70, 8, 65, 71, 69, 88],

[32, 37, 31, 77, 38, 93, 45, 74, 47, 54, 31, 18],

[37, 14, 49, 24, 93, 37, 54, 51, 39, 84],

[16, 98, 68, 57, 55, 46, 66, 85, 18],

[20, 70, 14, 6, 58, 90, 30, 17, 91, 18, 90],

[37, 93, 98, 13, 45, 28, 89, 72, 70]

]

각각의 데이터를 전처리합니다.

[-]

trg_data = [[sos_id]+seq+[eos_id] for seq in tqdm(trg_data)]

100%|██████████| 10/10 [00:00<00:00, 30526.23it/s]

[-]

def padding(data, is_src=True):

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

print(f"Maximum sequence length: {max_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))

return data, valid_lens, max_len

[-]

src_data, src_lens, src_max_len = padding(src_data)

trg_data, trg_lens, trg_max_len = padding(trg_data)

100%|██████████| 10/10 [00:00<00:00, 5367.68it/s] 100%|██████████| 10/10 [00:00<00:00, 4147.85it/s]

Maximum sequence length: 15 Maximum sequence length: 22

[-]

# B: batch size, S_L: source maximum sequence length, T_L: target maximum sequence length

src_batch = torch.LongTensor(src_data) # (B, S_L)

src_batch_lens = torch.LongTensor(src_lens) # (B)

trg_batch = torch.LongTensor(trg_data) # (B, T_L)

trg_batch_lens = torch.LongTensor(trg_lens) # (B)

print(src_batch.shape)

print(src_batch_lens.shape)

print(trg_batch.shape)

print(trg_batch_lens.shape)

torch.Size([10, 15]) torch.Size([10]) torch.Size([10, 22]) torch.Size([10])

PackedSquence를 사용을 위해 source data를 기준으로 정렬합니다.

[-]

src_batch_lens, sorted_idx = src_batch_lens.sort(descending=True)

src_batch = src_batch[sorted_idx]

trg_batch = trg_batch[sorted_idx]

trg_batch_lens = trg_batch_lens[sorted_idx]

print(src_batch)

print(src_batch_lens)

print(trg_batch)

print(trg_batch_lens)

tensor([[39, 47, 96, 68, 55, 16, 90, 45, 89, 84, 19, 22, 32, 99, 5], [41, 55, 77, 21, 52, 92, 97, 69, 54, 14, 93, 0, 0, 0, 0], [63, 39, 5, 35, 67, 56, 68, 89, 55, 66, 0, 0, 0, 0, 0], [ 3, 77, 56, 26, 3, 55, 12, 36, 31, 0, 0, 0, 0, 0, 0], [29, 3, 52, 74, 73, 51, 39, 75, 19, 0, 0, 0, 0, 0, 0], [58, 20, 65, 46, 26, 10, 76, 44, 0, 0, 0, 0, 0, 0, 0], [75, 34, 17, 3, 86, 88, 0, 0, 0, 0, 0, 0, 0, 0, 0], [12, 40, 69, 39, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [58, 17, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [59, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) tensor([15, 11, 10, 9, 9, 8, 6, 5, 3, 1]) tensor([[ 1, 37, 14, 49, 24, 93, 37, 54, 51, 39, 84, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 32, 37, 31, 77, 38, 93, 45, 74, 47, 54, 31, 18, 2, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 20, 70, 14, 6, 58, 90, 30, 17, 91, 18, 90, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 75, 13, 22, 77, 89, 21, 13, 86, 95, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 8, 85, 87, 77, 47, 21, 23, 98, 83, 4, 47, 97, 40, 43, 70, 8, 65, 71, 69, 88, 2], [ 1, 79, 14, 91, 41, 32, 79, 88, 34, 8, 68, 32, 77, 58, 7, 9, 87, 2, 0, 0, 0, 0], [ 1, 16, 98, 68, 57, 55, 46, 66, 85, 18, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 37, 93, 98, 13, 45, 28, 89, 72, 70, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 85, 8, 50, 30, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [ 1, 47, 30, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]) tensor([12, 14, 13, 11, 22, 18, 11, 11, 6, 4])

Encoder 구현

[-]

embedding_size = 256

hidden_size = 512

num_layers = 2

num_dirs = 2

dropout = 0.1

Bidirectional GRU를 이용한 Encoder입니다.

self.embedding: word embedding layer.
self.gru: encoder 역할을 하는 Bi-GRU.
self.linear: 양/단방향 concat된 hidden state를 decoder의 hidden size에 맞게 linear transformation.

[-]

class Encoder(nn.Module):

def __init__(self):

super(Encoder, self).__init__()

self.embedding = nn.Embedding(vocab_size, embedding_size)

self.gru = nn.GRU(

input_size=embedding_size,

hidden_size=hidden_size,

num_layers=num_layers,

bidirectional=True if num_dirs > 1 else False,

dropout=dropout

)

self.linear = nn.Linear(num_dirs * hidden_size, hidden_size)

def forward(self, batch, batch_lens): # batch: (B, S_L), batch_lens: (B)

# d_w: word embedding size

batch_emb = self.embedding(batch) # (B, S_L, d_w)

batch_emb = batch_emb.transpose(0, 1) # (S_L, B, d_w)

packed_input = pack_padded_sequence(batch_emb, batch_lens)

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_outputs, h_n = self.gru(packed_input, h_0) # h_n: (4, B, d_h)

outputs = pad_packed_sequence(packed_outputs)[0] # outputs: (S_L, B, 2d_h)

forward_hidden = h_n[-2, :, :]

backward_hidden = h_n[-1, :, :]

hidden = self.linear(torch.cat((forward_hidden, backward_hidden), dim=-1)).unsqueeze(0) # (1, B, d_h)

return outputs, hidden

[-]

encoder = Encoder()

Decoder 구현

동일한 설정의 Bi-GRU로 만든 Decoder입니다.

self.embedding: word embedding layer.
self.gru: decoder 역할을 하는 Bi-GRU.
self.output_layer: decoder에서 나온 hidden state를 vocab_size로 linear transformation하는 layer.

[-]

class Decoder(nn.Module):

def __init__(self):

super(Decoder, self).__init__()

self.embedding = nn.Embedding(vocab_size, embedding_size)

self.gru = nn.GRU(

input_size=embedding_size,

hidden_size=hidden_size,

)

self.output_layer = nn.Linear(hidden_size, vocab_size)

def forward(self, batch, hidden): # batch: (B), hidden: (1, B, d_h)

batch_emb = self.embedding(batch) # (B, d_w)

batch_emb = batch_emb.unsqueeze(0) # (1, B, d_w)

outputs, hidden = self.gru(batch_emb, hidden) # outputs: (1, B, 2d_h), hidden: (1, B, d_h)

# V: vocab size

outputs = self.output_layer(outputs) # (1, B, V)

return outputs.squeeze(0), hidden

[-]

decoder = Decoder()

Seq2seq 모델 구축

생성한 encoder와 decoder를 합쳐 Seq2seq 모델을 구축합니다.

self.encoder: encoder.
self.decoder: decoder.

[-]

class Seq2seq(nn.Module):

def __init__(self, encoder, decoder):

super(Seq2seq, self).__init__()

self.encoder = encoder

self.decoder = decoder

def forward(self, src_batch, src_batch_lens, trg_batch, teacher_forcing_prob=0.5):

# src_batch: (B, S_L), src_batch_lens: (B), trg_batch: (B, T_L)

_, hidden = self.encoder(src_batch, src_batch_lens) # hidden: (1, B, d_h)

input_ids = trg_batch[:, 0] # (B)

batch_size = src_batch.shape[0]

outputs = torch.zeros(trg_max_len, batch_size, vocab_size) # (T_L, B, V)

for t in range(1, trg_max_len):

decoder_outputs, hidden = self.decoder(input_ids, hidden) # decoder_outputs: (B, V), hidden: (1, B,

d_h)

outputs[t] = decoder_outputs

_, top_ids = torch.max(decoder_outputs, dim=-1) # top_ids: (B)

input_ids = trg_batch[:, t] if random.random() > teacher_forcing_prob else top_ids

return outputs

[-]

seq2seq = Seq2seq(encoder, decoder)

모델 사용해보기

학습 과정이라고 가정하고 모델에 input을 넣어봅니다.

[-]

outputs = seq2seq(src_batch, src_batch_lens, trg_batch)

print(outputs)

print(outputs.shape)

tensor([[[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], ..., [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000]], [[ 0.0810, 0.1353, -0.0228, ..., 0.0005, 0.1104, -0.0978], [ 0.0957, 0.1139, 0.0373, ..., 0.0106, 0.1108, -0.1112], [ 0.1221, 0.1363, 0.0007, ..., 0.0247, 0.1063, -0.1181], ..., [ 0.0640, 0.1576, 0.0073, ..., -0.0044, 0.1308, -0.1275], [ 0.0783, 0.1162, -0.0318, ..., -0.0072, 0.0916, -0.1013], [ 0.1127, 0.1163, -0.0190, ..., 0.0381, 0.1196, -0.1232]], [[ 0.0515, 0.1813, -0.1099, ..., -0.1550, 0.0528, -0.0289], [ 0.0606, 0.1668, -0.0765, ..., -0.1467, 0.0514, -0.0342], [ 0.1851, 0.0556, -0.0568, ..., 0.1143, -0.1236, -0.0575], ..., [ 0.0398, 0.1945, -0.0892, ..., -0.1607, 0.0564, -0.0481], [ 0.0540, 0.1753, -0.1100, ..., -0.1607, 0.0394, -0.0346], [ 0.0667, 0.1774, -0.1053, ..., -0.1388, 0.0598, -0.0454]], ..., [[ 0.0040, 0.0602, 0.2212, ..., 0.0919, 0.3016, 0.0441], [-0.0232, 0.0314, 0.2188, ..., 0.1508, 0.3125, 0.0393], [-0.0011, 0.0589, 0.2218, ..., 0.1013, 0.3053, 0.0359], ..., [-0.0069, -0.0208, 0.3169, ..., 0.1072, 0.3452, 0.0605], [-0.0370, -0.0656, 0.2434, ..., 0.0947, 0.2971, 0.0491], [-0.0370, -0.0656, 0.2434, ..., 0.0947, 0.2971, 0.0492]], [[ 0.1383, -0.0064, 0.1376, ..., -0.2379, 0.3716, 0.0092], [ 0.0529, -0.0343, 0.2087, ..., -0.0154, 0.2301, 0.0778], [ 0.1355, -0.0058, 0.1373, ..., -0.2331, 0.3730, 0.0062], ..., [ 0.1296, -0.0387, 0.2001, ..., -0.2290, 0.3840, 0.0146], [ 0.0397, -0.0901, 0.2147, ..., -0.0549, 0.2305, 0.0808], [ 0.0396, -0.0901, 0.2147, ..., -0.0549, 0.2305, 0.0808]], [[ 0.1513, -0.0600, -0.0451, ..., -0.2005, 0.2013, 0.1272], [ 0.1586, 0.1685, 0.2581, ..., 0.0257, 0.1666, 0.1330], [ 0.1498, -0.0602, -0.0452, ..., -0.1972, 0.2003, 0.1257], ..., [ 0.1482, -0.0795, -0.0059, ..., -0.1847, 0.2082, 0.1249], [ 0.1590, 0.1368, 0.2473, ..., 0.0018, 0.1704, 0.1348], [ 0.1590, 0.1368, 0.2473, ..., 0.0019, 0.1704, 0.1348]]], grad_fn=<CopySlices>) torch.Size([22, 10, 100])

Language Modeling에 대한 loss 계산을 위해 shift한 target과 비교합니다.

[-]

loss_function = nn.CrossEntropyLoss()

preds = outputs[:1, :, :].transpose(0, 1) # (B, T_L-1, V)

loss = loss_function(preds.contiguous().view(-1, vocab_size), trg_batch[:,1:].contiguous().view(-1, 1)

.squeeze(1))

print(loss)

tensor(4.5866, grad_fn=<NllLossBackward>)

실제 inference에선 teacher forcing 없이 이전 결과만을 가지고 생성합니다.

[-]

src_sent = [4, 10, 88, 46, 72, 34, 14, 51]

src_len = len(src_sent)

src_batch = torch.LongTensor(src_sent).unsqueeze(0) # (1, L)

src_batch_lens = torch.LongTensor([src_len]) # (1)

_, hidden = seq2seq.encoder(src_batch, src_batch_lens) # hidden: (1, 1, d_h)

[-]

input_id = torch.LongTensor([sos_id]) # (1)

output = []

for t in range(1, trg_max_len):

decoder_output, hidden = seq2seq.decoder(input_id, hidden) # decoder_output: (1, V), hidden: (1, 1, d_h)

_, top_id = torch.max(decoder_output, dim=-1) # top_ids: (1)

if top_id == eos_id:

break

else:

output += top_id.tolist()

input_id = top_id

[-]

output

[82,
 63,
 72,
 98,
 3,
 53,
 59,
 8,
 24,
 24,
 82,
 57,
 12,
 12,
 12,
 12,
 12,
 12,
 12,
 12,
 12]

seq2seq_attention

##6. Seq2seq + Attention 1. 여러 Attention 모듈을 구현합니다. 2. 기존 Seq2seq 모델과의 차이를 이해합니다.

필요 패키지 import

[1]

from tqdm import tqdm

from torch import nn

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

from torch.nn import functional as F

import torch

import random

데이터 전처리

데이터 처리는 이전과 동일합니다.

[2]

vocab_size = 100

pad_id = 0

sos_id = 1

eos_id = 2

src_data = [

[3, 77, 56, 26, 3, 55, 12, 36, 31],

[58, 20, 65, 46, 26, 10, 76, 44],

[58, 17, 8],

[59],

[29, 3, 52, 74, 73, 51, 39, 75, 19],

[41, 55, 77, 21, 52, 92, 97, 69, 54, 14, 93],

[39, 47, 96, 68, 55, 16, 90, 45, 89, 84, 19, 22, 32, 99, 5],

[75, 34, 17, 3, 86, 88],

[63, 39, 5, 35, 67, 56, 68, 89, 55, 66],

[12, 40, 69, 39, 49]

]

trg_data = [

[75, 13, 22, 77, 89, 21, 13, 86, 95],

[79, 14, 91, 41, 32, 79, 88, 34, 8, 68, 32, 77, 58, 7, 9, 87],

[85, 8, 50, 30],

[47, 30],

[8, 85, 87, 77, 47, 21, 23, 98, 83, 4, 47, 97, 40, 43, 70, 8, 65, 71, 69, 88],

[32, 37, 31, 77, 38, 93, 45, 74, 47, 54, 31, 18],

[37, 14, 49, 24, 93, 37, 54, 51, 39, 84],

[16, 98, 68, 57, 55, 46, 66, 85, 18],

[20, 70, 14, 6, 58, 90, 30, 17, 91, 18, 90],

[37, 93, 98, 13, 45, 28, 89, 72, 70]

]

[3]

trg_data = [[sos_id]+seq+[eos_id] for seq in tqdm(trg_data)]

100%|██████████| 10/10 [00:00<00:00, 32363.46it/s]

[4]

def padding(data, is_src=True):

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

print(f"Maximum sequence length: {max_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))

return data, valid_lens, max_len

[5]

src_data, src_lens, src_max_len = padding(src_data)

trg_data, trg_lens, trg_max_len = padding(trg_data)

100%|██████████| 10/10 [00:00<00:00, 56073.58it/s] 100%|██████████| 10/10 [00:00<00:00, 19239.93it/s]

Maximum sequence length: 15 Maximum sequence length: 22

[6]

# B: batch size, S_L: source maximum sequence length, T_L: target maximum sequence length

src_batch = torch.LongTensor(src_data) # (B, S_L)

src_batch_lens = torch.LongTensor(src_lens) # (B)

trg_batch = torch.LongTensor(trg_data) # (B, T_L)

trg_batch_lens = torch.LongTensor(trg_lens) # (B)

print(src_batch.shape)

print(src_batch_lens.shape)

print(trg_batch.shape)

print(trg_batch_lens.shape)

torch.Size([10, 15]) torch.Size([10]) torch.Size([10, 22]) torch.Size([10])

[7]

src_batch_lens, sorted_idx = src_batch_lens.sort(descending=True)

src_batch = src_batch[sorted_idx]

trg_batch = trg_batch[sorted_idx]

trg_batch_lens = trg_batch_lens[sorted_idx]

print(src_batch)

print(src_batch_lens)

print(trg_batch)

print(trg_batch_lens)

Encoder 구현

Encoder 역시 기존 Seq2seq 모델과 동일합니다.

[8]

embedding_size = 256

hidden_size = 512

num_layers = 2

num_dirs = 2

dropout = 0.1

[9]

class Encoder(nn.Module):

def __init__(self):

super(Encoder, self).__init__()

self.embedding = nn.Embedding(vocab_size, embedding_size)

self.gru = nn.GRU(

input_size=embedding_size,

hidden_size=hidden_size,

num_layers=num_layers,

bidirectional=True if num_dirs > 1 else False,

dropout=dropout

)

self.linear = nn.Linear(num_dirs * hidden_size, hidden_size)

def forward(self, batch, batch_lens): # batch: (B, S_L), batch_lens: (B)

# d_w: word embedding size

batch_emb = self.embedding(batch) # (B, S_L, d_w)

batch_emb = batch_emb.transpose(0, 1) # (S_L, B, d_w)

packed_input = pack_padded_sequence(batch_emb, batch_lens)

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_outputs, h_n = self.gru(packed_input, h_0) # h_n: (4, B, d_h)

outputs = pad_packed_sequence(packed_outputs)[0] # outputs: (S_L, B, 2d_h)

outputs = torch.tanh(self.linear(outputs)) # (S_L, B, d_h)

forward_hidden = h_n[-2, :, :]

backward_hidden = h_n[-1, :, :]

hidden = torch.tanh(self.linear(torch.cat((forward_hidden, backward_hidden), dim=-1))).unsqueeze(0) #

(1, B, d_h)

return outputs, hidden

[10]

encoder = Encoder()

Dot-product Attention 구현

우선 대표적인 attention 형태 중 하나인 Dot-product Attention은 다음과 같이 구현할 수 있습니다.

[11]

class DotAttention(nn.Module):

def __init__(self):

super().__init__()

def forward(self, decoder_hidden, encoder_outputs): # (1, B, d_h), (S_L, B, d_h)

query = decoder_hidden.squeeze(0) # (B, d_h)

key = encoder_outputs.transpose(0, 1) # (B, S_L, d_h)

energy = torch.sum(torch.mul(key, query.unsqueeze(1)), dim=-1) # (B, S_L)

attn_scores = F.softmax(energy, dim=-1) # (B, S_L)

attn_values = torch.sum(torch.mul(encoder_outputs.transpose(0, 1), attn_scores.unsqueeze(2)), dim=1)

# (B, d_h)

return attn_values, attn_scores

[12]

dot_attn = DotAttention()

이제 이 attention 모듈을 가지는 Decoder 클래스를 구현하겠습니다.

[13]

class Decoder(nn.Module):

def __init__(self, attention):

super().__init__()

self.embedding = nn.Embedding(vocab_size, embedding_size)

self.attention = attention

self.rnn = nn.GRU(

embedding_size,

hidden_size

)

self.output_linear = nn.Linear(2*hidden_size, vocab_size)

def forward(self, batch, encoder_outputs, hidden): # batch: (B), encoder_outputs: (L, B, d_h), hidden:

(1, B, d_h)

batch_emb = self.embedding(batch) # (B, d_w)

batch_emb = batch_emb.unsqueeze(0) # (1, B, d_w)

outputs, hidden = self.rnn(batch_emb, hidden) # (1, B, d_h), (1, B, d_h)

attn_values, attn_scores = self.attention(hidden, encoder_outputs) # (B, d_h), (B, S_L)

concat_outputs = torch.cat((outputs, attn_values.unsqueeze(0)), dim=-1) # (1, B, 2d_h)

return self.output_linear(concat_outputs).squeeze(0), hidden # (B, V), (1, B, d_h)

[14]

decoder = Decoder(dot_attn)

Seq2seq 모델 구축

최종적으로 seq2seq 모델을 다음과 같이 구성할 수 있습니다.

[15]

class Seq2seq(nn.Module):

def __init__(self, encoder, decoder):

super(Seq2seq, self).__init__()

self.encoder = encoder

self.decoder = decoder

def forward(self, src_batch, src_batch_lens, trg_batch, teacher_forcing_prob=0.5):

# src_batch: (B, S_L), src_batch_lens: (B), trg_batch: (B, T_L)

encoder_outputs, hidden = self.encoder(src_batch, src_batch_lens) # encoder_outputs: (S_L, B, d_h),

hidden: (1, B, d_h)

input_ids = trg_batch[:, 0] # (B)

batch_size = src_batch.shape[0]

outputs = torch.zeros(trg_max_len, batch_size, vocab_size) # (T_L, B, V)

for t in range(1, trg_max_len):

decoder_outputs, hidden = self.decoder(input_ids, encoder_outputs, hidden) # decoder_outputs: (B, V)

, hidden: (1, B, d_h)

outputs[t] = decoder_outputs

_, top_ids = torch.max(decoder_outputs, dim=-1) # top_ids: (B)

input_ids = trg_batch[:, t] if random.random() > teacher_forcing_prob else top_ids

return outputs

[16]

seq2seq = Seq2seq(encoder, decoder)

모델 사용해보기

만든 모델로 결과를 확인해보겠습니다.

[17]

# V: vocab size

outputs = seq2seq(src_batch, src_batch_lens, trg_batch) # (T_L, B, V)

print(outputs)

print(outputs.shape)

tensor([[[ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], ..., [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, ..., 0.0000, 0.0000, 0.0000]], [[-0.1122, -0.0092, -0.0648, ..., -0.0345, -0.0832, -0.0689], [-0.0757, 0.0086, -0.0888, ..., -0.0592, -0.0960, -0.0179], [-0.0967, -0.0226, -0.0254, ..., -0.0765, -0.0771, -0.0471], ..., [-0.0838, 0.0144, -0.0914, ..., -0.1012, -0.1210, -0.0776], [-0.0906, -0.0108, -0.0538, ..., -0.0370, -0.1393, -0.0715], [-0.0824, -0.0158, -0.0765, ..., -0.0184, -0.1245, -0.0547]], [[ 0.0211, -0.0594, -0.1355, ..., 0.0251, -0.0609, -0.0272], [ 0.0507, -0.0497, -0.1516, ..., 0.0109, -0.0699, 0.0190], [ 0.0310, -0.0696, -0.1005, ..., 0.0150, -0.0716, 0.0061], ..., [ 0.0432, -0.0451, -0.1568, ..., -0.0081, -0.0975, -0.0216], [ 0.0129, 0.1018, 0.0375, ..., 0.1010, -0.0219, -0.0297], [ 0.0497, -0.0640, -0.1439, ..., 0.0382, -0.0969, -0.0070]], ..., [[-0.0927, -0.0191, 0.0138, ..., 0.0778, 0.0180, 0.0553], [-0.1406, -0.0336, 0.0207, ..., 0.1153, 0.0188, 0.1176], [-0.1581, -0.0734, 0.0374, ..., 0.1072, 0.0352, 0.0379], ..., [-0.1397, -0.0631, -0.0140, ..., 0.0880, 0.0254, 0.0264], [-0.0733, -0.0206, 0.0069, ..., 0.0781, -0.0005, 0.0731], [-0.0695, -0.0161, 0.0112, ..., 0.0812, -0.0018, 0.0740]], [[-0.0384, -0.0204, 0.0408, ..., -0.0145, 0.0219, -0.0709], [ 0.0532, 0.0522, 0.0613, ..., -0.1042, 0.0072, 0.0791], [ 0.0399, 0.0326, 0.0834, ..., -0.0829, 0.0177, 0.0383], ..., [ 0.0536, 0.0406, 0.0297, ..., -0.1045, 0.0128, 0.0266], [-0.1323, -0.1137, 0.0306, ..., 0.0393, 0.0995, 0.1443], [-0.1279, 0.0364, 0.0362, ..., 0.1231, 0.0059, 0.1326]], [[-0.1285, -0.0466, 0.0209, ..., 0.1087, -0.0012, -0.0105], [-0.0798, 0.0020, 0.0269, ..., 0.0662, -0.0142, 0.1103], [-0.0919, -0.0166, 0.0535, ..., 0.0763, -0.0119, 0.0887], ..., [-0.0782, -0.0073, 0.0021, ..., 0.0530, -0.0152, 0.0765], [-0.1612, -0.0637, 0.0138, ..., 0.1228, 0.0072, 0.1163], [-0.1887, -0.0174, 0.0221, ..., 0.1369, -0.0020, 0.1154]]], grad_fn=<CopySlices>) torch.Size([22, 10, 100])

[18]

sample_sent = [4, 10, 88, 46, 72, 34, 14, 51]

sample_len = len(sample_sent)

sample_batch = torch.LongTensor(sample_sent).unsqueeze(0) # (1, L)

sample_batch_len = torch.LongTensor([sample_len]) # (1)

encoder_output, hidden = seq2seq.encoder(sample_batch, sample_batch_len) # hidden: (4, 1, d_h)

[19]

input_id = torch.LongTensor([sos_id]) # (1)

output = []

for t in range(1, trg_max_len):

decoder_output, hidden = seq2seq.decoder(input_id, encoder_output, hidden) # decoder_output: (1, V),

hidden: (4, 1, d_h)

_, top_id = torch.max(decoder_output, dim=-1) # top_ids: (1)

if top_id == eos_id:

break

else:

output += top_id.tolist()

input_id = top_id

[20]

output

[73,
 73,
 49,
 37,
 69,
 44,
 65,
 66,
 81,
 61,
 36,
 35,
 50,
 50,
 50,
 50,
 50,
 50,
 50,
 50,
 50]

Concat Attention 구현

Bahdanau Attention이라고도 불리는 Concat Attention을 구현해보도록 하겠습니다.

self.w: Concat한 query와 key 벡터를 1차적으로 linear transformation.
self.v: Attention logit 값을 계산.

[21]

class ConcatAttention(nn.Module):

def __init__(self):

super().__init__()

self.w = nn.Linear(2*hidden_size, hidden_size, bias=False)

self.v = nn.Linear(hidden_size, 1, bias=False)

def forward(self, decoder_hidden, encoder_outputs): # (1, B, d_h), (S_L, B, d_h)

src_max_len = encoder_outputs.shape[0]

decoder_hidden = decoder_hidden.transpose(0, 1).repeat(1, src_max_len, 1) # (B, S_L, d_h)

encoder_outputs = encoder_outputs.transpose(0, 1) # (B, S_L, d_h)

concat_hiddens = torch.cat((decoder_hidden, encoder_outputs), dim=2) # (B, S_L, 2d_h)

energy = torch.tanh(self.w(concat_hiddens)) # (B, S_L, d_h)

attn_scores = F.softmax(self.v(energy), dim=1) # (B, S_L, 1)

attn_values = torch.sum(torch.mul(encoder_outputs, attn_scores), dim=1) # (B, d_h)

return attn_values, attn_scores

[22]

concat_attn = ConcatAttention()

마찬가지로 decoder를 마저 구현하겠습니다.

[23]

class Decoder(nn.Module):

def __init__(self, attention):

super().__init__()

self.embedding = nn.Embedding(vocab_size, embedding_size)

self.attention = attention

self.rnn = nn.GRU(

embedding_size + hidden_size,

hidden_size

)

self.output_linear = nn.Linear(hidden_size, vocab_size)

def forward(self, batch, encoder_outputs, hidden): # batch: (B), encoder_outputs: (S_L, B, d_h),

hidden: (1, B, d_h)

batch_emb = self.embedding(batch) # (B, d_w)

batch_emb = batch_emb.unsqueeze(0) # (1, B, d_w)

attn_values, attn_scores = self.attention(hidden, encoder_outputs) # (B, d_h), (B, S_L)

concat_emb = torch.cat((batch_emb, attn_values.unsqueeze(0)), dim=-1) # (1, B, d_w+d_h)

outputs, hidden = self.rnn(concat_emb, hidden) # (1, B, d_h), (1, B, d_h)

return self.output_linear(outputs).squeeze(0), hidden # (B, V), (1, B, d_h)

[24]

decoder = Decoder(concat_attn)

[25]

seq2seq = Seq2seq(encoder, decoder)

[26]

outputs = seq2seq(src_batch, src_batch_lens, trg_batch)

print(outputs)

print(outputs.shape)

tensor([[[ 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, ..., 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], ..., [ 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, ..., 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]], [[-2.2498e-02, -1.0772e-01, 1.5383e-01, ..., -5.1496e-02, 1.0130e-01, 1.3383e-01], [-1.5165e-02, -1.2098e-01, 1.3994e-01, ..., -6.7260e-02, 5.6078e-02, 1.3426e-01], [-7.3644e-03, -1.0645e-01, 1.4258e-01, ..., -7.3612e-02, 8.9238e-02, 1.1511e-01], ..., [-1.2610e-02, -1.0516e-01, 1.5143e-01, ..., -9.2113e-02, 6.7646e-02, 8.8741e-02], [-5.4296e-03, -1.1747e-01, 1.3980e-01, ..., -1.2148e-01, 8.8805e-02, 1.2122e-01], [ 2.8986e-02, -7.9437e-02, 1.3617e-01, ..., -8.7739e-02, 7.2623e-02, 1.1872e-01]], [[ 1.1018e-02, -1.1723e-01, 1.6663e-01, ..., -9.5271e-02, 2.4528e-02, 1.0182e-01], [-3.8691e-02, -1.1353e-01, 5.4055e-02, ..., -5.5286e-02, 1.3899e-01, 1.8535e-01], [ 1.7360e-02, -2.9213e-01, 2.0041e-01, ..., 6.2140e-02, -1.1588e-02, -7.4221e-02], ..., [ 2.2116e-02, -2.9696e-01, 2.0072e-01, ..., 6.1819e-02, -2.4314e-02, -8.8981e-02], [-2.9222e-02, -9.5696e-02, 7.5207e-02, ..., -9.4679e-02, 1.7103e-01, 1.8074e-01], [ 4.3550e-02, -2.7282e-01, 1.8859e-01, ..., 5.7557e-02, -2.0107e-02, -7.8441e-02]], ..., [[ 6.4847e-02, -1.2857e-02, -2.2132e-01, ..., 2.6756e-01, -1.2926e-01, -6.8434e-03], [-2.3060e-02, -4.9108e-03, -2.1352e-01, ..., -2.4609e-01, -2.5036e-01, 1.6811e-02], [ 7.3514e-02, 3.1628e-02, 2.0770e-01, ..., -1.7476e-02, -1.3649e-01, 1.0314e-01], ..., [-1.6838e-02, -8.3599e-02, -1.4116e-01, ..., -2.2631e-01, -2.4897e-01, 3.3460e-04], [ 6.1860e-02, 7.1879e-02, 1.4126e-01, ..., -3.8600e-02, -1.1677e-01, 9.8223e-02], [ 2.1253e-01, -1.2545e-01, 3.8774e-02, ..., -1.2438e-01, -9.2774e-02, 6.3294e-02]], [[ 4.5225e-02, 6.5383e-02, -8.4764e-03, ..., 3.6275e-02, -2.1544e-01, -1.3038e-01], [-2.4740e-02, 5.2692e-02, -7.2114e-02, ..., -2.7810e-01, -2.7421e-01, -1.1342e-01], [ 5.4585e-02, 8.8448e-02, 1.8936e-01, ..., -1.6225e-01, -2.4770e-01, -4.3981e-02], ..., [-1.0798e-02, 4.3789e-03, -2.6819e-02, ..., -2.8247e-01, -2.7659e-01, -1.2194e-01], [ 4.3641e-02, 1.1506e-01, 1.4502e-01, ..., -1.6432e-01, -2.3142e-01, -4.5535e-02], [ 9.5950e-02, 1.1300e-02, 1.0203e-01, ..., -2.1711e-01, -2.1592e-01, -8.8748e-02]], [[ 2.8442e-02, -1.1999e-03, -2.3673e-01, ..., -1.2795e-01, -2.1303e-01, 5.5467e-03], [-2.9316e-02, -7.7121e-03, -3.0058e-01, ..., -2.9470e-01, -2.4205e-01, 6.7239e-03], [-2.3889e-01, 3.3993e-02, 1.6139e-04, ..., -1.6009e-01, 1.9789e-04, 1.8603e-02], ..., [-1.2960e-02, -3.6066e-02, -2.5458e-01, ..., -3.0728e-01, -2.4804e-01, 4.6051e-03], [ 1.4508e-02, 1.8267e-02, -1.6516e-01, ..., -2.4256e-01, -2.1428e-01, 3.2406e-02], [ 4.6852e-02, -4.7045e-02, -2.8920e-04, ..., -1.4875e-01, -1.0565e-01, 9.9737e-02]]], grad_fn=<CopySlices>) torch.Size([22, 10, 100])

====================================

과제 / 퀴즈

본 과제의 목적은 대표적인 pytorch library 중 하나인 fairseq을 이용해 번역 모델을 학습하는 방법을 배우는 것입니다.

# 필요 패키지 설치 (참고: 느낌표를 앞에 붙이면 해당 코드가 terminal에서 실행됩니다.)

!pip install fastBPE sacremoses subword_nmt hydra-core omegaconf fairseq

# clone fairseq git

!git clone https://github.com/pytorch/fairseq.git

# iwslt14 데이터 준비 (https://github.com/pytorch/fairseq/blob/master/examples/translation/prepare-iwslt14.sh)

!bash fairseq/examples/translation/prepare-iwslt14.sh

# 예시 코드를 이용해 직접 전처리부터 평가까지 진행해보겠습니다.

# source-lang: source language

# target-lang: target language

# trainpref: train file prefix

# validpref: valid file prefix

# testpref: test file prefix

# destdir: destination dir

!fairseq-preprocess --source-lang de --target-lang en --trainpref ./iwslt14.tokenized.de-en/train --validpref ./iwslt14.tokenized.de-en/valid --testpref ./iwslt14.tokenized.de-en/test --destdir ./iwslt14.tokenized.de-en/

# 모델 학습

# (참고: 모델을 동시에 여러개 학습 시키고 싶으신 분들은 노트북 파일을 드라이브에 여러개 복사해서 각 파일마다 실행하면 여러 모델을 동시에 학습시킬 수 있습니다.)

# --arch: architecture

# --optimizer: optimizer {adadelta, adam, adafactor, adagrad, lamb, composite, nag, adamax, sgd}

# --clip-norm: clip threshold of gradients

# --lr: learning rate

# --lr-scheduler: learning rate scheduler {pass_through, cosine, reduce_lr_on_plateau, fixed, triangular, polynomial_decay, tri_stage, manual, inverse_sqrt}

# --criterion loss function {sentence_prediction, ctc, adaptive_loss, label_smoothed_cross_entropy, composite_loss, nat_loss, masked_lm, sentence_ranking, legacy_masked_lm_loss, cross_entropy, model, wav2vec, label_smoothed_cross_entropy_with_alignment, vocab_parallel_cross_entropy}

# --max-tokens: maximum number of tokens in a batch

# --max-epoch: maximum number of training epoch

!fairseq-train ./iwslt14.tokenized.de-en/ --arch transformer_iwslt_de_en --optimizer adam --clip-norm 0.0 --lr 5e-4 --lr-scheduler inverse_sqrt --criterion label_smoothed_cross_entropy --max-tokens 4096 --max-epoch 5

# 예측 문장 생성 및 평가

# checkpoints 폴더에 epoch마다 모델이 저장되고 best checkpoint는 checkpoint_best.pt라는 이름으로 저장됩니다

!fairseq-generate ./iwslt14.tokenized.de-en --path ./checkpoints/checkpoint_best.pt --beam 10 --remove-bpe

====================================

피어세션

수업한거 분석. dacon 하는거 어떰?

내가 과거껄 굳이 시간들여가며 꼼꼼하게 볼 필요가 있나? 라고 질문했는데 틀린 생각이었다. 일단 실습코드 내용 하나도 이해 안되니까 이것들부터 이해하자..

===========================

후기

실습 코드랑 이론이랑 연결시켜서 꼼꼼히 확인하는 작업을 언제 하지? 주말에 할까..