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

Unidades Recurrentes Gated (GRUs)

Siguiente ►
►

Introducción

Las Unidades Recurrentes Gated (GRUs) son un tipo de red neuronal recurrente (RNN) que se utilizan para modelar secuencias y datos temporales. Las GRUs son una variante de las LSTM (Long Short-Term Memory) y están diseñadas para resolver el problema del desvanecimiento del gradiente, permitiendo que las redes aprendan dependencias a largo plazo de manera más efectiva.

Conceptos Clave

  1. Estructura de una GRU

Las GRUs tienen una estructura más simple que las LSTM, con menos parámetros y sin una celda de memoria separada. Las GRUs utilizan dos puertas principales:

  • Puerta de actualización (update gate): Controla cuánto de la información pasada debe ser llevada al futuro.
  • Puerta de reinicio (reset gate): Controla cuánto de la información pasada debe ser olvidada.

  1. Fórmulas Matemáticas

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

  1. Puerta de actualización: \[ z_t = \sigma(W_z \cdot [h_{t-1}, x_t]) \]
  2. Puerta de reinicio: \[ r_t = \sigma(W_r \cdot [h_{t-1}, x_t]) \]
  3. Cálculo del estado candidato: \[ \tilde{h}t = \tanh(W \cdot [r_t * h{t-1}, x_t]) \]
  4. Cálculo del nuevo estado: \[ h_t = (1 - z_t) * h_{t-1} + z_t * \tilde{h}_t \]

Donde:

  • \( \sigma \) es la función sigmoide.
  • \( \tanh \) es la función tangente hiperbólica.
  • \( W_z, W_r, W \) son matrices de pesos.
  • \( h_{t-1} \) es el estado oculto anterior.
  • \( x_t \) es la entrada en el tiempo \( t \).

Implementación en TensorFlow

Paso 1: Importar las Librerías Necesarias

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

Paso 2: Preparar los Datos

Para este ejemplo, utilizaremos datos secuenciales generados aleatoriamente.

import numpy as np

# Generar datos secuenciales aleatorios
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 GRU

model = Sequential()
model.add(GRU(50, input_shape=(seq_length, 1)))
model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')
model.summary()

Paso 4: Entrenar el Modelo

model.fit(X, y, epochs=20, batch_size=32)

Paso 5: Evaluar el Modelo

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

Ejercicio Práctico

Ejercicio 1: Construir y Entrenar una GRU para Predicción de Series Temporales

  1. Objetivo: Construir una GRU para predecir la siguiente valor en una serie temporal.
  2. Datos: Utiliza una serie temporal de tu elección (por ejemplo, datos de temperatura diaria).

Pasos:

  1. Preparar los datos: Divide la serie temporal en secuencias de entrada y salida.
  2. Construir el modelo: Utiliza una capa GRU seguida de una capa densa.
  3. Entrenar el modelo: Ajusta el modelo a los datos de entrenamiento.
  4. Evaluar el modelo: Evalúa el rendimiento del modelo en datos de prueba.

Solución

import pandas as pd

# Cargar datos de serie temporal (por ejemplo, datos de temperatura)
data = pd.read_csv('temperature_data.csv')
series = data['temperature'].values

# Preparar los datos
def create_sequences(series, seq_length):
    X, y = [], []
    for i in range(len(series) - seq_length):
        X.append(series[i:i+seq_length])
        y.append(series[i+seq_length])
    return np.array(X), np.array(y)

seq_length = 10
X, y = create_sequences(series, seq_length)
X = X.reshape((X.shape[0], X.shape[1], 1))

# Dividir en conjuntos de entrenamiento y prueba
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# Construir el modelo
model = Sequential()
model.add(GRU(50, input_shape=(seq_length, 1)))
model.add(Dense(1))

model.compile(optimizer='adam', loss='mse')
model.summary()

# Entrenar el modelo
model.fit(X_train, y_train, epochs=20, batch_size=32)

# Evaluar el modelo
loss = model.evaluate(X_test, y_test)
print(f'Loss: {loss}')

Conclusión

En esta sección, hemos aprendido sobre las Unidades Recurrentes Gated (GRUs), su estructura y cómo implementarlas en TensorFlow. Las GRUs son una herramienta poderosa para modelar datos secuenciales y temporales, ofreciendo una alternativa más simple y eficiente a las LSTM. Con la práctica y la experimentación, puedes aplicar GRUs a una variedad de problemas de series temporales y secuencias.

En el próximo módulo, exploraremos técnicas avanzadas de TensorFlow, incluyendo la creación de capas y modelos personalizados. ¡Sigue adelante!

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