CHAPTER7 순차적인 데이터를 처리하는 RNN 2

# 필수 라이브러리 import
import torch
import torch.nn as nn
import random
import matplotlib.pyplot as plt

# 데이터셋 속 토큰 종류 수
vocab_size = 256 # 총 아스키 코드 개수

# 번역할 원문과 번역문을 아스키 코드 배열로 정의 -> 파이토치 텐서로 변경
x_ = list(map(ord, "hello"))
y_ = list(map(ord, "hola"))
x = torch.LongTensor(x_)
y = torch.LongTensor(y_)

# 모델 클래스 정의
class Seq2Seq(nn.Module):
    def __init__(self, vocab_size, hidden_size):
        super(Seq2Seq, self).__init__()
        self.n_layers= 1 # 은닉 벡터 층
        self.hidden_size = hidden_size # 생성되는 은닉 벡터 차원값

        # 임베딩 함수 정의
        # 임베딩 차원 값 따로 안 정하고 hidden_size를 임베딩된 토큰의 차원값으로 정의
        # 실전에서는 원문과 번역문의 문자 체계가 완전 다른 경우를 대비해,
        # 원문용 임베딩과 번역문용 임베딩 따로 만들어야함.
        # 지금은 그냥 둘다 아스키 코드로 나타내기 때문에 하나만 만들어줘도 무방.
        self.embedding = nn.Embedding(vocab_size, hidden_size)
        self.encoder = nn.GRU(hidden_size, hidden_size)
        self.decoder = nn.GRU(hidden_size, hidden_size)

        # 디코더가 번역문의 다음 토큰 예상해내는 작은 신경망 하나 더 생성
        self.project = nn.Linear(hidden_size, vocab_size)


    def forward(self, inputs, targets):
        initial_state = self._init_state() # 첫 번째 은닉 벡터
        embedding = self.embedding(inputs).unsqueeze(1) # hello를 구성하는 모든 문자 임베딩

        # encoder_state = 문맥 벡터 / decoder_state = 디코더의 첫 번째 은닉 벡터
        encoder_output, encoder_state = self.encoder(embedding, initial_state)
        decoder_state = encoder_state
        decoder_input = torch.LongTensor([0])

        # 디코더는 문장 시작 토큰인 아스키 코드 0번을 이용하여 "hola"의 "h" 토큰을 예측.
        # 다음 반복에서는 'h'를 이용해 'o'를 예측해야함. -> for문으로 구현
        outputs = []
        for i in range(targets.size()[0]):
            # 첫 번째 토큰과 인코더 문맥 벡터 동시에 입력 받음.
            decoder_input = self.embedding(decoder_input).unsqueeze(1)
            decoder_output, decoder_state = self.decoder(decoder_input, decoder_state)

            # 결과값 다시 입력하고, 출력값이 마지막 마지막 층인 Softmax 층 거치면
            # 번역문 다음 예상 글자가 나온다.
            # 예상 결과 outputs 텐서에 저장해 오차 계산할 때 사용.
            projection = self.project(decoder_output)
            outputs.append(projection)

            # 티처 포싱을 이용한 디코더 입력 갱신
            decoder_input = torch.LongTensor([targets[i]])

        # outputs = 모든 토큰에 대한 결과값들의 배열
        outputs = torch.stack(outputs).squeeze()
        return outputs


    # 첫 번째 은닉 벡터 정의하는 함수
    def _init_state(self, batch_size = 1):
        # parameters() : 신경망 모듈의 가중치 정보를 반복자 형태로 반환
        # 얘가 생성하는 원소들은 실제 신경망의 가중치 텐서를 지닌 객체.
        weight = next(self.parameters()).data # 첫 번째 가중치 텐서 추출

        # new() 함수 사용해 텐서로 변환 후, zero_()로 텐서 내 모든 값 0으로 초기화
        # 첫 번째 은닉벡터는 모든 특성값이 0인 벡터로 설정됨.
        return weight.new(self.n_layers, batch_size, self.hidden_size).zero_()

# 오차 함수와 최적화 알고리즘 정의
seq2seq = Seq2Seq(vocab_size, 16)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(seq2seq.parameters(), lr = 1e-3)

# 모델 학습 Epoch = 1000
log = []
for i in range(1000):
    prediction = seq2seq(x, y)
    loss = criterion(prediction, y)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    loss_val = loss.data
    log.append(loss_val)

    if i % 100 == 0:
        print(f"\n 반복:{i} 오차:{loss_val.item()}")
        _, top1 = prediction.data.topk(1, 1)
        print([chr(c) for c in top1.squeeze().numpy().tolist()])

# 오차 시각화
plt.plot(log)
plt.ylabel("cross entropy loss")
plt.show()