logo
위키

순환신경망(RNN) 코드 예시

RNN 구현

이제 간단한 RNN 네트워크를 PyTorch로 구현하는 방법을 알아보겠습니다.

import torch
import torch.nn as nn

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        self.i2h = nn.Linear(input_size + hidden_size, hidden_size)  # 입력과 은닉 상태를 결합하여 은닉 상태를 계산
        self.i2o = nn.Linear(input_size + hidden_size, output_size)  # 입력과 은닉 상태를 결합하여 출력을 계산
        self.softmax = nn.LogSoftmax(dim=1)

    def forward(self, input, hidden):
        combined = torch.cat((input, hidden), 1)
        hidden = self.i2h(combined)
        output = self.i2o(combined)
        output = self.softmax(output)
        return output, hidden

    def initHidden(self):
        return torch.zeros(1, self.hidden_size)

# RNN 네트워크의 인스턴스 생성
n_input = 10  # 입력 크기 예시
n_hidden = 20  # 은닉층 크기
n_output = 10  # 출력 크기

rnn = SimpleRNN(n_input, n_hidden, n_output)

이 코드는 가장 기본적인 형태의 RNN을 구현한 것으로, 실제로 사용될 때는 학습 데이터, 손실 함수, 최적화 알고리즘과 함께 사용되어야 합니다. 또한, 실제 응용 프로그램에서는 기울기 소실 문제를 해결하기 위해 LSTM이나 GRU와 같은 보다 발전된 RNN 변형을 사용하는 것이 일반적입니다.

LSTM 구현

LSTM을 PyTorch로 구현하는 기본 예시는 다음과 같습니다:

import torch
import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)

    def forward(self, x):
        # 초기 숨겨진 상태와 셀 상태
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        
        # 전방 전파 LSTM
        out, _ = self.lstm(x, (h0, c0))
        
        return out

# 모델 파라미터 정의
input_size = 10  # 입력 크기
hidden_size = 20  # 숨겨진 상태의 크기
num_layers = 2  # LSTM 층의 개수

# 입력 데이터 (batch_size, sequence_length, input_size)
x = torch.randn(5, 3, input_size)

# 모델 생성 및 출력
model = LSTMModel(input_size, hidden_size, num_layers)
output = model(x)

print(output.shape)  # 출력 형태: (batch_size, sequence_length, hidden_size)

이 코드는 기본 LSTM 모델을 구현하고 임의의 입력에 대해 모델을 실행하는 예시를 보여줍니다. RNN과 비교하여 LSTM은 더 복잡한 구조를 가지고 있지만, PyTorch와 같은 딥러닝 프레임워크를 사용하면 쉽게 구현할 수 있습니다.

간단한 LSTM 구현

아래는 PyTorch를 사용하여 간단한 LSTM 모델을 구현하는 예시 코드입니다. 이 코드는 LSTM을 사용하여 시퀀스 데이터를 처리하는 기본적인 구조를 보여줍니다.

import torch
import torch.nn as nn

class SimpleLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleLSTM, self).__init__()
        self.hidden_size = hidden_size
        
        # LSTM Layer
        self.lstm = nn.LSTM(input_size, hidden_size)
        
        # Output layer
        self.linear = nn.Linear(hidden_size, output_size)
    
    def forward(self, input_seq):
        # LSTM의 출력과 마지막 상태를 얻습니다.
        lstm_out, _ = self.lstm(input_seq.view(len(input_seq), 1, -1))
        
        # 최종 출력을 생성합니다.
        output = self.linear(lstm_out.view(len(input_seq), -1))
        return output

# 예시 파라미터
INPUT_SIZE = 10  # 입력 크기
HIDDEN_SIZE = 20  # 숨겨진 상태의 크기
OUTPUT_SIZE = 1  # 출력 크기

# 모델 생성
model = SimpleLSTM(INPUT_SIZE, HIDDEN_SIZE, OUTPUT_SIZE)
print(model)

# 임의의 입력 데이터 생성
input_seq = torch.rand(5, INPUT_SIZE)  # (시퀀스 길이, 입력 크기)

# 모델을 통해 입력 데이터 처리
out = model(input_seq)
print(out)

이 코드는 LSTM을 이용하여 입력된 시퀀스 데이터를 처리하고, 최종적으로 각 시간 단계에 대한 출력을 생성합니다. 간단한 시퀀스 처리 작업에서 LSTM의 기본 구조와 사용 방법을 이해하는 데 도움이 됩니다.

출력층을 갖춘 LSTM 모델

import torch
import torch.nn as nn

# LSTM 모델 정의
class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, num_layers, output_size):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # 초기 은닉 상태와 셀 상태
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)

        # LSTM을 통과한 후의 출력, (은닉 상태, 셀 상태) 받기
        out, _ = self.lstm(x, (h0, c0))
        
        # 마지막 시간 단계의 출력을 선형 계층에 통과시킴
        out = self.fc(out[:, -1, :])
        return out

# LSTM 모델 인스턴스 생성
input_size = 10  # 입력 크기
hidden_size = 128  # 은닉 상태의 크기
num_layers = 2  # LSTM층의 개수
output_size = 1  # 출력 크기

model = LSTMModel(input_size, hidden_size, num_layers, output_size)

# 예제 입력
x = torch.randn(32, 100, input_size)  # (배치 크기, 시퀀스 길이, 입력 크기)

# 모델을 통해 예제 입력 전달
output = model(x)

print(output.shape)  # 예상 출력 크기: [32, 1]

위 예제 코드는 PyTorch를 사용하여 간단한 LSTM 모델을 구현한 것입니다. 이 모델은 입력 크기, 은닉 상태의 크기, LSTM 층의 개수, 그리고 출력 크기를 인자로 받습니다. LSTM 층을 통해 시퀀스 데이터를 처리한 후, 마지막 시간 단계의 출력을 기반으로 최종 출력을 생성합니다.

감성 분석 모델

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

class RNNModel(nn.Module):
    def __init__(self, vocab_size, embed_size, hidden_size, output_size):
        super(RNNModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = nn.LSTM(embed_size, hidden_size, num_layers=1, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        embedded = self.embedding(x)
        output, (hidden, cell) = self.rnn(embedded)
        hidden = hidden.squeeze(0)
        out = self.fc(hidden)
        return out

# 가정: vocab_size=10000, embed_size=300, hidden_size=256, output_size=2 (긍정/부정)
model = RNNModel(10000, 300, 256, 2)
print(model)

# 예시 데이터에 대한 모델의 동작을 보여주는 부분은 여기에서 생략됨.

이 코드는 LSTM을 기반으로 하는 간단한 감성 분석 모델을 정의합니다. 이 모델은 임베딩 레이어로 문장을 벡터화하고, LSTM 레이어로 시퀀스 데이터를 처리한 후, 최종적으로 선형 레이어를 통해 긍정 혹은 부정의 감성 점수를 출력합니다.

Previous
순환신경망(RNN)
Next
시퀀스-투-시퀀스 모델