Implementamos una RNN básica para demostrar cómo la red procesa datos secuenciales y realiza predicciones. Se utiliza un pequeño conjunto de datos ficticio para mostrar cómo la RNN aprende de los datos y ajusta sus pesos.

• Creación de datos ficticios: primero, generamos un pequeño conjunto de datos que consiste en secuencias numéricas simples. Estas secuencias se utilizarán para entrenar nuestra RNN y que aprenda patrones dentro de los datos;

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

• Construcción del modelo RNN: creamos una arquitectura RNN simple con una capa oculta. La capa de entrada recibe los datos, mientras que la capa oculta los procesa y pasa la salida al siguiente paso. La capa final proporciona la predicción;

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)

• Entrenamiento de la RNN: durante el entrenamiento, la RNN ajusta sus pesos internos mediante retropropagación para minimizar los errores de predicción. Utilizaremos una función de pérdida (como el error cuadrático medio) para medir el rendimiento del 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()

• Evaluación del modelo: después del entrenamiento, probamos la capacidad de la RNN para predecir puntos de datos futuros basándose en los patrones aprendidos de los datos ficticios. Esto nos ayuda a ver qué tan bien se ha generalizado el modelo;

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} %')

• Ejemplo de código: el código utilizado en este capítulo se puede descargar.

En resumen, implementar una RNN básica implica preparar los datos, definir la arquitectura, entrenar el modelo y evaluar su rendimiento. Este enfoque práctico proporciona una visión de cómo las RNN pueden aplicarse a tareas de predicción de secuencias.