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

Memoria a Largo Plazo (LSTM)

Siguiente ►
►

Introducción

Las Redes Neuronales de Memoria a Largo Plazo (LSTM, por sus siglas en inglés) son un tipo especial de Redes Neuronales Recurrentes (RNN) diseñadas para manejar el problema del desvanecimiento del gradiente y la retención de información a largo plazo. Las LSTM son especialmente útiles en tareas de series temporales, procesamiento de lenguaje natural y cualquier otra tarea donde la secuencia y el contexto sean importantes.

Conceptos Clave

  1. Celdas LSTM

Las celdas LSTM están compuestas por varios componentes clave:

  • Puerta de Entrada (Input Gate): Controla la cantidad de nueva información que se almacena en la celda.
  • Puerta de Olvido (Forget Gate): Decide cuánta información de la celda anterior se debe olvidar.
  • Puerta de Salida (Output Gate): Determina la cantidad de información que se envía al siguiente estado oculto.

  1. Estado de la Celda y Estado Oculto

  • Estado de la Celda (Cell State): Transporta información a lo largo de la secuencia, permitiendo que la red retenga información a largo plazo.
  • Estado Oculto (Hidden State): Transporta información a corto plazo y se utiliza para generar la salida en cada paso de tiempo.

Implementación de LSTM en TensorFlow

Paso 1: Importar las Bibliotecas Necesarias

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

Paso 2: Preparar los Datos

Para este ejemplo, utilizaremos datos de series temporales generados aleatoriamente.

import numpy as np

# Generar datos de ejemplo
def generate_data(seq_length, num_samples):
    X = np.random.rand(num_samples, seq_length, 1)
    y = np.random.rand(num_samples, 1)
    return X, y

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

Paso 3: Construir el Modelo LSTM

model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(seq_length, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

Paso 4: Entrenar el Modelo

model.fit(X, y, epochs=200, verbose=0)

Paso 5: Evaluar el Modelo

loss = model.evaluate(X, y, verbose=0)
print(f'Loss: {loss}')

Ejercicio Práctico

Ejercicio 1: Predecir una Serie Temporal

Objetivo: Utilizar una LSTM para predecir la siguiente valor en una serie temporal.

Instrucciones:

  1. Genera una serie temporal de datos senoidales.
  2. Divide los datos en secuencias de entrada y salida.
  3. Construye y entrena un modelo LSTM para predecir el siguiente valor en la serie.

Código de Ejemplo:

import numpy as np
import matplotlib.pyplot as plt

# Generar datos senoidales
def generate_sine_wave(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.reshape(num_samples, seq_length, 1), y.reshape(num_samples, seq_length, 1)

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

# Construir el modelo LSTM
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(seq_length, 1), return_sequences=True))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# Entrenar el modelo
model.fit(X, y, epochs=200, verbose=0)

# Predecir la serie temporal
predictions = model.predict(X, verbose=0)

# Visualizar los resultados
plt.plot(y[0], label='Real')
plt.plot(predictions[0], label='Predicción')
plt.legend()
plt.show()

Solución del Ejercicio

El código anterior genera una serie temporal senoidal, construye y entrena un modelo LSTM para predecir el siguiente valor en la serie, y finalmente visualiza los resultados.

Conclusión

En esta sección, hemos aprendido sobre las Redes Neuronales de Memoria a Largo Plazo (LSTM) y cómo implementarlas en TensorFlow. Las LSTM son poderosas para manejar secuencias y retener información a largo plazo, lo que las hace ideales para tareas como la predicción de series temporales y el procesamiento de lenguaje natural. En el próximo módulo, exploraremos las Unidades Recurrentes Gated (GRUs), una alternativa a las LSTM.

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