El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Introducción a las RNNs

Siguiente ►
►

¿Qué son las Redes Neuronales Recurrentes (RNNs)?

Las Redes Neuronales Recurrentes (RNNs) son un tipo de red neuronal diseñada para trabajar con datos secuenciales. A diferencia de las redes neuronales tradicionales, las RNNs tienen conexiones recurrentes que permiten que la información persista. Esto las hace especialmente útiles para tareas donde el contexto y el orden de los datos son importantes, como el procesamiento de lenguaje natural (NLP), la traducción automática, y el análisis de series temporales.

Características Clave de las RNNs:

  • Memoria: Las RNNs pueden recordar información de entradas anteriores gracias a sus conexiones recurrentes.
  • Parámetros Compartidos: Los mismos parámetros (pesos) se aplican a cada paso de la secuencia, lo que reduce la complejidad del modelo.
  • Capacidad de Modelar Secuencias: Son ideales para datos secuenciales donde el orden de los datos es crucial.

Arquitectura de una RNN

Una RNN típica consiste en una capa recurrente que procesa una secuencia de entradas. Cada unidad en la capa recurrente tiene una conexión hacia adelante y una conexión recurrente que alimenta su propia salida de vuelta como entrada en el siguiente paso de tiempo.

Diagrama de una RNN Simple:

x_t -> [h_t] -> y_t
      ^   |
      |   v
      h_(t-1)
  • x_t: Entrada en el tiempo t.
  • h_t: Estado oculto en el tiempo t.
  • y_t: Salida en el tiempo t.
  • h_(t-1): Estado oculto en el tiempo t-1.

Implementación Básica de una RNN en PyTorch

Vamos a implementar una RNN simple en PyTorch para entender mejor su funcionamiento.

Paso 1: Importar las Bibliotecas Necesarias

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

Paso 2: Definir la Arquitectura de la RNN

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)
        out, hn = self.rnn(x, h0)
        out = self.fc(out[:, -1, :])
        return out
  • input_size: Dimensión de la entrada.
  • hidden_size: Dimensión del estado oculto.
  • output_size: Dimensión de la salida.

Paso 3: Crear una Instancia del Modelo y Definir el Optimizador y la Función de Pérdida

input_size = 10
hidden_size = 20
output_size = 1

model = SimpleRNN(input_size, hidden_size, output_size)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

Paso 4: Entrenar la RNN

# Datos de ejemplo
inputs = torch.randn(100, 5, input_size)  # (batch_size, sequence_length, input_size)
targets = torch.randn(100, output_size)   # (batch_size, output_size)

num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

Ejercicio Práctico

Ejercicio 1: Implementar una RNN para Predecir una Serie Temporal

  1. Objetivo: Implementar una RNN que prediga el siguiente valor en una serie temporal.
  2. Datos: Generar una serie temporal sintética.
  3. Pasos:
    • Generar datos de entrenamiento y prueba.
    • Definir la arquitectura de la RNN.
    • Entrenar la RNN.
    • Evaluar el rendimiento del modelo.

Solución del Ejercicio 1

import numpy as np

# Generar datos sintéticos
def generate_data(seq_length, num_samples):
    X = np.array([np.sin(np.linspace(0, 2*np.pi, seq_length)) for _ in range(num_samples)])
    y = np.array([np.sin(np.linspace(0, 2*np.pi, seq_length+1))[1:] for _ in range(num_samples)])
    return X, y

seq_length = 50
num_samples = 1000
X, y = generate_data(seq_length, num_samples)

# Convertir a tensores
X = torch.tensor(X, dtype=torch.float32)
y = torch.tensor(y, dtype=torch.float32)

# Definir la RNN
class TimeSeriesRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(TimeSeriesRNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), self.hidden_size).to(x.device)
        out, hn = self.rnn(x, h0)
        out = self.fc(out[:, -1, :])
        return out

input_size = 1
hidden_size = 20
output_size = 1

model = TimeSeriesRNN(input_size, hidden_size, output_size)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Entrenar la RNN
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    outputs = model(X.unsqueeze(-1))
    loss = criterion(outputs, y.unsqueeze(-1))
    
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

Conclusión

En esta sección, hemos introducido las Redes Neuronales Recurrentes (RNNs) y su arquitectura básica. También hemos implementado una RNN simple en PyTorch y un ejercicio práctico para predecir una serie temporal. Las RNNs son poderosas para trabajar con datos secuenciales, pero también tienen limitaciones, como la dificultad para aprender dependencias a largo plazo. En las siguientes secciones, exploraremos variantes de RNNs como LSTM y GRU que abordan algunas de estas limitaciones.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados