Recurrent Neural Network (RNN)

text = "The quick brown fox jumps over the lazy dog. This is a sample text for the RNN model. The purpose is to generate text based on the learned patterns."

# 라이브러리 임포트 import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, Dataset # 데이터셋 클래스 정의 class TextDataset(Dataset): def __init__(self, text, sequence_length): self.text = text self.sequence_length = sequence_length self.char_to_idx = {ch: i for i, ch in enumerate(sorted(set(text)))} self.idx_to_char = {i: ch for ch, i in self.char_to_idx.items()} self.data = [self.char_to_idx[ch] for ch in text] def __len__(self): return len(self.data) - self.sequence_length def __getitem__(self, idx): return ( torch.tensor(self.data[idx:idx+self.sequence_length], dtype=torch.long), torch.tensor(self.data[idx+1:idx+self.sequence_length+1], dtype=torch.long) ) # 데이터 준비 text = "The quick brown fox jumps over the lazy dog. This is a sample text for the RNN model. The purpose is to generate text based on the learned patterns." sequence_length = 10 dataset = TextDataset(text, sequence_length) dataloader = DataLoader(dataset, batch_size=2, shuffle=True) # RNN 모델 정의 class SimpleRNN(nn.Module): def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim): super(SimpleRNN, self).__init__() self.embedding = nn.Embedding(vocab_size, embed_dim) self.rnn = nn.RNN(embed_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): x = self.embedding(x) out, _ = self.rnn(x) out = self.fc(out) return out vocab_size = len(dataset.char_to_idx) embed_dim = 10 hidden_dim = 20 output_dim = vocab_size model = SimpleRNN(vocab_size, embed_dim, hidden_dim, output_dim) # 손실 함수 및 옵티마이저 정의 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 모델 훈련 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = model.to(device) num_epochs = 20 for epoch in range(num_epochs): model.train() running_loss = 0.0 for inputs, targets in dataloader: inputs, targets = inputs.to(device), targets.to(device) outputs = model(inputs) outputs = outputs.view(-1, outputs.size(-1)) targets = targets.view(-1) loss = criterion(outputs, targets) optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) epoch_loss = running_loss / len(dataset) print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}') # 텍스트 생성 함수 def generate_text(model, start_text, length): model.eval() chars = [dataset.char_to_idx[ch] for ch in start_text] input_seq = torch.tensor(chars, dtype=torch.long).unsqueeze(0).to(device) generated_text = start_text with torch.no_grad(): for _ in range(length): output = model(input_seq) _, predicted = torch.max(output[:, -1, :], 1) next_char = dataset.idx_to_char[predicted.item()] generated_text += next_char input_seq = torch.cat([input_seq[:, 1:], predicted.unsqueeze(0)], dim=1) return generated_text # 텍스트 생성 start_text = "The quick" generated_text = generate_text(model, start_text, 20) print(f'Generated Text: {generated_text}')

time_series = [i for i in range(100)]

# 라이브러리 임포트 import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, Dataset # 데이터셋 클래스 정의 class TimeSeriesDataset(Dataset): def __init__(self, series, sequence_length): self.series = series self.sequence_length = sequence_length def __len__(self): return len(self.series) - self.sequence_length def __getitem__(self, idx): return ( torch.tensor(self.series[idx:idx+self.sequence_length], dtype=torch.float), torch.tensor(self.series[idx+self.sequence_length], dtype=torch.float) ) # 데이터 준비 time_series = [i for i in range(100)] sequence_length = 10 dataset = TimeSeriesDataset(time_series, sequence_length) dataloader = DataLoader(dataset, batch_size=2, shuffle=True) # RNN 모델 정의 class SimpleRNN(nn.Module): def __init__(self, input_dim, hidden_dim, output_dim): super(SimpleRNN, self).__init__() self.rnn = nn.RNN(input_dim, hidden_dim, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): out, _ = self.rnn(x) out = self.fc(out[:, -1, :]) return out input_dim = 1 hidden_dim = 20 output_dim = 1 model = SimpleRNN(input_dim, hidden_dim, output_dim) # 손실 함수 및 옵티마이저 정의 criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 모델 훈련 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = model.to(device) num_epochs = 20 for epoch in range(num_epochs): model.train() running_loss = 0.0 for inputs, targets in dataloader: inputs = inputs.unsqueeze(-1).to(device) targets = targets.to(device) outputs = model(inputs) loss = criterion(outputs, targets.unsqueeze(-1)) optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() * inputs.size(0) epoch_loss = running_loss / len(dataset) print(f'Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}') # 시계열 예측 함수 def predict(model, start_sequence, length): model.eval() input_seq = torch.tensor(start_sequence, dtype=torch.float).unsqueeze(0).unsqueeze(-1).to(device) predictions = start_sequence with torch.no_grad(): for _ in range(length): output = model(input_seq) next_value = output.item() predictions.append(next_value) new_input = torch.tensor([next_value], dtype=torch.float).unsqueeze(0).unsqueeze(-1).to(device) input_seq = torch.cat([input_seq[:, 1:], new_input], dim=1) return predictions # 시계열 예측 start_sequence = [i for i in range(10)] predicted_series = predict(model, start_sequence, 10) print(f'Predicted Series: {predicted_series}')

Predicted Series: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 15.772008895874023, 16.848833084106445, 16.890918731689453, 16.892337799072266, 16.892383575439453, 16.89238739013672, 16.89238739013672, 16.89238739013672, 16.89238739013672, 16.89238739013672]