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

Construyendo una RNN

Siguiente ►
►

En este tema, aprenderemos a construir una Red Neuronal Recurrente (RNN) utilizando TensorFlow. Las RNNs son especialmente útiles para procesar datos secuenciales, como series temporales, texto y datos de audio. Vamos a desglosar el proceso en pasos claros y proporcionar ejemplos prácticos para que puedas seguirlos fácilmente.

Objetivos

  • Comprender la estructura básica de una RNN.
  • Construir una RNN simple utilizando TensorFlow.
  • Entrenar la RNN con un conjunto de datos secuenciales.
  • Evaluar el rendimiento de la RNN.

  1. Estructura Básica de una RNN

Una RNN es una red neuronal que tiene conexiones recurrentes, lo que significa que la salida de una capa se retroalimenta como entrada para la misma capa en el siguiente paso temporal. Esto permite que la red mantenga una "memoria" de los estados anteriores.

Componentes Clave:

  • Capa Recurrente: La capa que tiene conexiones recurrentes.
  • Estado Oculto: La memoria de la red que se actualiza en cada paso temporal.
  • Entrada Secuencial: Los datos que se alimentan a la red en secuencia.

  1. Construcción de una RNN Simple

Vamos a construir una RNN simple utilizando la API de Keras en TensorFlow. Para este ejemplo, utilizaremos una secuencia de números como datos de entrada.

Paso 1: Importar las Bibliotecas Necesarias

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense
import numpy as np

Paso 2: Preparar los Datos

Vamos a crear una secuencia de números y dividirla en secuencias más pequeñas para entrenar la RNN.

# Crear una secuencia de números
data = np.array([i for i in range(100)])

# Definir la longitud de las secuencias
sequence_length = 10

# Crear las secuencias de entrada y las etiquetas
X = []
y = []

for i in range(len(data) - sequence_length):
    X.append(data[i:i + sequence_length])
    y.append(data[i + sequence_length])

X = np.array(X)
y = np.array(y)

# Reshape para que sea compatible con la entrada de la RNN
X = X.reshape((X.shape[0], X.shape[1], 1))

Paso 3: Definir el Modelo

Vamos a definir un modelo secuencial con una capa SimpleRNN y una capa densa para la salida.

model = Sequential()
model.add(SimpleRNN(50, activation='relu', input_shape=(sequence_length, 1)))
model.add(Dense(1))

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

Paso 4: Entrenar el Modelo

Entrenamos el modelo con los datos preparados.

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

Paso 5: Evaluar el Modelo

Podemos evaluar el modelo utilizando una parte de los datos que no se usaron para el entrenamiento.

# Crear una nueva secuencia para la evaluación
test_data = np.array([i for i in range(90, 110)])
X_test = []
y_test = []

for i in range(len(test_data) - sequence_length):
    X_test.append(test_data[i:i + sequence_length])
    y_test.append(test_data[i + sequence_length])

X_test = np.array(X_test)
y_test = np.array(y_test)

X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

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

  1. Ejercicio Práctico

Ejercicio 1: Predecir una Secuencia de Números

Modifica el código anterior para predecir una secuencia de números diferente. Por ejemplo, intenta predecir la secuencia de números pares.

Solución:

# Crear una secuencia de números pares
data = np.array([i for i in range(0, 200, 2)])

# Definir la longitud de las secuencias
sequence_length = 10

# Crear las secuencias de entrada y las etiquetas
X = []
y = []

for i in range(len(data) - sequence_length):
    X.append(data[i:i + sequence_length])
    y.append(data[i + sequence_length])

X = np.array(X)
y = np.array(y)

# Reshape para que sea compatible con la entrada de la RNN
X = X.reshape((X.shape[0], X.shape[1], 1))

# Definir el modelo
model = Sequential()
model.add(SimpleRNN(50, activation='relu', input_shape=(sequence_length, 1)))
model.add(Dense(1))

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

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

# Evaluar el modelo
test_data = np.array([i for i in range(180, 220, 2)])
X_test = []
y_test = []

for i in range(len(test_data) - sequence_length):
    X_test.append(test_data[i:i + sequence_length])
    y_test.append(test_data[i + sequence_length])

X_test = np.array(X_test)
y_test = np.array(y_test)

X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

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

Conclusión

En esta lección, hemos aprendido a construir una RNN simple utilizando TensorFlow. Hemos cubierto la estructura básica de una RNN, cómo preparar los datos, definir el modelo, entrenarlo y evaluarlo. Las RNNs son poderosas para trabajar con datos secuenciales y tienen muchas aplicaciones en el mundo real, como el procesamiento de lenguaje natural y la predicción de series temporales.

En el próximo tema, exploraremos las Memorias a Largo Plazo (LSTM), una variante de las RNNs que aborda algunos de los problemas comunes de las RNNs estándar.

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