Implementamos uma RNN básica para demonstrar como a rede processa dados sequenciais e faz previsões. Um pequeno conjunto de dados fictício é utilizado para mostrar como a RNN aprende com os dados e ajusta seus pesos.

• Criação de dados fictícios: primeiro, geramos um pequeno conjunto de dados composto por sequências numéricas simples. Essas sequências serão usadas para treinar nossa RNN a aprender padrões nos dados;

sequences = np.random.rand(self.num_samples, self.seq_length, input_size).astype(np.float32)
labels = np.zeros(self.num_samples, dtype=np.int64)

• Construção do modelo RNN: criamos uma arquitetura RNN simples com uma camada oculta. A camada de entrada recebe os dados, enquanto a camada oculta os processa e passa a saída para o próximo passo. A camada final fornece a previsão;

self.hidden_size = hidden_size
self.num_layers = num_layers
self.rnn = nn.RNN(input_size, hidden_size, num_layers, batch_first=True)
self.fc = nn.Linear(hidden_size, output_size)

• Treinamento da RNN: durante o treinamento, a RNN ajusta seus pesos internos por meio da retropropagação para minimizar os erros de previsão. Utilizaremos uma função de perda (como erro quadrático médio) para medir o desempenho do modelo;

for i, (sequences, labels) in enumerate(dataloader):
    # --- Forward pass ---
    outputs = model(sequences) # Get model predictions (logits)
    loss = criterion(outputs, labels) # Calculate the loss

    # --- Backward pass and optimization ---
    optimizer.zero_grad()   # Clear gradients from the previous iteration
    loss.backward()         # Compute gradients (Backpropagation Through Time happens here)
    optimizer.step()        # Update model parameters based on gradients

    # --- Track metrics ---
    total_loss += loss.item() # Accumulate the loss (loss.item() gets the scalar value)

    # Calculate accuracy for the batch
    _, predicted_classes = torch.max(outputs.data, 1) # Get the index (class) with the highest score
    total_samples += labels.size(0) # Add the number of samples in this batch
    correct_predictions += (predicted_classes == labels).sum().item()

• Avaliação do modelo: após o treinamento, testamos a capacidade da RNN de prever pontos futuros com base nos padrões aprendidos a partir dos dados fictícios. Isso nos permite verificar o quanto o modelo generalizou;

all_sequences, all_labels = dataset[:]
# Get model predictions for the entire dataset
outputs = model(all_sequences)

# Find the predicted class for each sample
_, predicted = torch.max(outputs.data, 1)

# Calculate total number of samples and correct predictions
total = all_labels.size(0)
correct = (predicted == all_labels).sum().item()

# Print the final accuracy
print(f'Accuracy of the model on the {total} training sequences: {100 * correct / total:.2f} %')

• Exemplo de código: o código utilizado neste capítulo pode ser baixado.

Em resumo, implementar uma RNN básica envolve preparar os dados, definir a arquitetura, treinar o modelo e avaliar seu desempenho. Essa abordagem prática fornece uma visão de como as RNNs podem ser aplicadas em tarefas de previsão de sequências.