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

LSTM y GRU

Siguiente ►
►

Introducción

En este tema, exploraremos dos tipos de redes neuronales recurrentes (RNN) avanzadas: Long Short-Term Memory (LSTM) y Gated Recurrent Units (GRU). Ambas arquitecturas están diseñadas para abordar el problema del desvanecimiento del gradiente y mejorar la capacidad de las RNN para capturar dependencias a largo plazo en secuencias de datos.

Objetivos de Aprendizaje

Al finalizar este tema, deberías ser capaz de:

  1. Comprender la estructura y funcionamiento de las LSTM.
  2. Comprender la estructura y funcionamiento de las GRU.
  3. Comparar las diferencias y similitudes entre LSTM y GRU.
  4. Implementar LSTM y GRU en un entorno de programación.

  1. Long Short-Term Memory (LSTM)

Estructura de una LSTM

Una LSTM es una variante de las RNN que introduce una estructura de memoria más compleja para mantener información durante largos períodos de tiempo. La unidad LSTM consta de tres puertas principales:

  1. Puerta de entrada (Input Gate): Controla la cantidad de nueva información que se almacena en la celda de memoria.
  2. Puerta de olvido (Forget Gate): Decide cuánta información de la celda de memoria anterior debe olvidarse.
  3. Puerta de salida (Output Gate): Determina qué parte de la información de la celda de memoria se utiliza para la salida.

Fórmulas Matemáticas

Las operaciones dentro de una unidad LSTM se pueden describir mediante las siguientes ecuaciones:

  1. Puerta de olvido: \[ f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \]

  2. Puerta de entrada: \[ i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \] \[ \tilde{C}t = \tanh(W_C \cdot [h{t-1}, x_t] + b_C) \]

  3. Actualización de la celda de memoria: \[ C_t = f_t \cdot C_{t-1} + i_t \cdot \tilde{C}_t \]

  4. Puerta de salida: \[ o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \] \[ h_t = o_t \cdot \tanh(C_t) \]

Ejemplo de Implementación en Python con TensorFlow

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# Definir el modelo
model = Sequential()
model.add(LSTM(50, input_shape=(timesteps, features)))
model.add(Dense(1))

# Compilar el modelo
model.compile(optimizer='adam', loss='mse')

# Resumen del modelo
model.summary()

  1. Gated Recurrent Units (GRU)

Estructura de una GRU

Las GRU son una simplificación de las LSTM que combinan la puerta de entrada y la puerta de olvido en una sola puerta llamada "puerta de actualización". Además, las GRU tienen una "puerta de reinicio" que controla cuánta información pasada se olvida.

Fórmulas Matemáticas

Las operaciones dentro de una unidad GRU se pueden describir mediante las siguientes ecuaciones:

  1. Puerta de actualización: \[ z_t = \sigma(W_z \cdot [h_{t-1}, x_t] + b_z) \]

  2. Puerta de reinicio: \[ r_t = \sigma(W_r \cdot [h_{t-1}, x_t] + b_r) \]

  3. Cálculo de la nueva memoria: \[ \tilde{h}t = \tanh(W \cdot [r_t \cdot h{t-1}, x_t] + b) \]

  4. Actualización del estado oculto: \[ h_t = (1 - z_t) \cdot h_{t-1} + z_t \cdot \tilde{h}_t \]

Ejemplo de Implementación en Python con TensorFlow

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import GRU, Dense

# Definir el modelo
model = Sequential()
model.add(GRU(50, input_shape=(timesteps, features)))
model.add(Dense(1))

# Compilar el modelo
model.compile(optimizer='adam', loss='mse')

# Resumen del modelo
model.summary()

  1. Comparación entre LSTM y GRU

Característica LSTM GRU
Complejidad Más compleja debido a tres puertas (entrada, olvido, salida) Menos compleja con dos puertas (actualización, reinicio)
Rendimiento Mejor en tareas con dependencias a largo plazo Similar rendimiento con menos parámetros
Tiempo de entrenamiento Más lento debido a la complejidad Más rápido debido a la simplicidad

  1. Ejercicio Práctico

Ejercicio

Implementa una red LSTM y una red GRU para predecir una serie temporal de datos de ventas. Compara el rendimiento de ambos modelos.

Solución

  1. Preparar los datos:
import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# Cargar datos
data = pd.read_csv('sales_data.csv')
sales = data['sales'].values.reshape(-1, 1)

# Escalar datos
scaler = MinMaxScaler()
sales_scaled = scaler.fit_transform(sales)

# Crear secuencias de entrenamiento
timesteps = 10
X, y = [], []
for i in range(len(sales_scaled) - timesteps):
    X.append(sales_scaled[i:i+timesteps])
    y.append(sales_scaled[i+timesteps])
X, y = np.array(X), np.array(y)
  1. Definir y entrenar el modelo LSTM:
# Modelo LSTM
model_lstm = Sequential()
model_lstm.add(LSTM(50, input_shape=(timesteps, 1)))
model_lstm.add(Dense(1))
model_lstm.compile(optimizer='adam', loss='mse')

# Entrenar el modelo
model_lstm.fit(X, y, epochs=20, batch_size=32)
  1. Definir y entrenar el modelo GRU:
# Modelo GRU
model_gru = Sequential()
model_gru.add(GRU(50, input_shape=(timesteps, 1)))
model_gru.add(Dense(1))
model_gru.compile(optimizer='adam', loss='mse')

# Entrenar el modelo
model_gru.fit(X, y, epochs=20, batch_size=32)
  1. Evaluar y comparar los modelos:
# Evaluar el modelo LSTM
loss_lstm = model_lstm.evaluate(X, y)
print(f'Pérdida del modelo LSTM: {loss_lstm}')

# Evaluar el modelo GRU
loss_gru = model_gru.evaluate(X, y)
print(f'Pérdida del modelo GRU: {loss_gru}')

Conclusión

En este tema, hemos explorado las arquitecturas LSTM y GRU, sus diferencias y similitudes, y cómo implementarlas en TensorFlow. Las LSTM y GRU son herramientas poderosas para manejar secuencias de datos y capturar dependencias a largo plazo, cada una con sus propias ventajas y desventajas. Con esta base, estás preparado para aplicar estas técnicas en problemas de series temporales y procesamiento del lenguaje natural.

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