seq-to-seq

• Seq2Seq(Sequence to Sequence) 는 시퀀스를 입력받아 다음 시퀀스를 예측하는 모델로, NLP 분야에서 많이 사용됨
• 시퀀스가 문장이라면 각각의 아이템은 단어를 나타내고, 동영상이라면 프레임 별 이미지이며, 입력과 출력이 길이가 같을 필요는 없음
• Seq2Seq 모델은 크게 인코더(Encoder)와 디코더(Decoder)가 연결된 구조이며, 인코더는 입력한 시퀀스의 정보 압축해서 Context vector를 만들고, 디코더는 이 정보를 받아서 출력하는 역할임.

Seq-to-Seq 모델 구조

 

import torch
import torch.nn as nn
import torch.optim as optim
import random

# 하이퍼파라미터 설정
input_size = 10
output_size = 10
hidden_size = 128
num_layers = 2
learning_rate = 0.001
num_epochs = 1000

# 간단한 예제 데이터 생성
def generate_data():
    input_seq = [random.randint(1, 9) for _ in range(input_size)]
    target_seq = input_seq.copy()
    return input_seq, target_seq

# Seq2Seq 모델 정의
class Seq2Seq(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(Seq2Seq, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.encoder = nn.Embedding(input_size, hidden_size)
        self.decoder = nn.LSTM(hidden_size, hidden_size, num_layers)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, input_seq):
        encoder_inputs = self.encoder(input_seq).unsqueeze(1)
        encoder_outputs, hidden = self.decoder(encoder_inputs)
        output_seq = self.fc(encoder_outputs.squeeze(1))
        return output_seq

# 모델 초기화
model = Seq2Seq(input_size, hidden_size, output_size, num_layers)

# 손실 함수 및 옵티마이저 정의
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# 훈련 루프
for epoch in range(num_epochs):
    input_seq, target_seq = generate_data()
    input_tensor = torch.tensor(input_seq, dtype=torch.long)
    target_tensor = torch.tensor(target_seq, dtype=torch.long)

    optimizer.zero_grad()
    output = model(input_tensor)

    loss = criterion(output, target_tensor)
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 100 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item()}')

# 예제 시퀀스에 대한 예측
test_input_seq = [random.randint(1, 9) for _ in range(input_size)]
test_input_tensor = torch.tensor(test_input_seq, dtype=torch.long)
predicted_tensor = model(test_input_tensor)
predicted_seq = predicted_tensor.argmax(dim=1).tolist()
print(f'Input Sequence: {test_input_seq}')
print(f'Predicted Sequence: {predicted_seq}')

 

 

 

 

Machine translation