TensorFlow / Python: Predicción de Series Temporales con Redes Neuronales Recurrentes (RNN)

La “predicción de series temporales” se refiere a la tarea de prever valores futuros en una secuencia de datos organizada en función del tiempo. En otras palabras, implica hacer estimaciones o pronósticos sobre cómo evolucionarán los datos en el futuro, basándose en patrones y tendencias observadas en el pasado.

Estos modelos pueden ser muy efectivos para tareas como predecir valores futuros en el mercado de valores, el clima, la demanda de productos, predicción del tráfico y mucho más.

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# Datos de ejemplo: serie temporal univariada (ajusta esto con tus datos)
series_temporales = np.sin(0.1 * np.arange(200)) + np.random.randn(200) * 0.1

# Función para crear secuencias de datos y sus etiquetas
def create_sequences(data, window_size):
    sequences = []
    labels = []
    for i in range(len(data) - window_size):
        sequences.append(data[i:i+window_size])
        labels.append(data[i+window_size])
    return np.array(sequences), np.array(labels)

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

# Crear el modelo de la RNN
model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(32, input_shape=(window_size, 1)),
    tf.keras.layers.Dense(1)
])

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

# Entrenar el modelo
model.fit(X_train, y_train, epochs=50, verbose=0)

# Evaluar el modelo
test_loss = model.evaluate(X_test, y_test)
print(f'Pérdida en el conjunto de prueba: {test_loss:.4f}')

# Predecir valores futuros
future = 50  # Número de puntos en el futuro para predecir
last_sequence = X[-1]  # Última secuencia de la serie temporal
predicted = []

for _ in range(future):
    next_value = model.predict(last_sequence.reshape(1, window_size, 1))
    predicted.append(next_value[0, 0])
    last_sequence = np.roll(last_sequence, shift=-1)
    last_sequence[-1] = next_value[0, 0]

# Visualizar la serie temporal original y las predicciones
plt.plot(np.arange(len(series_temporales)), series_temporales, label='Serie Temporal Original')
plt.plot(np.arange(len(series_temporales), len(series_temporales) + future), predicted, label='Predicciones Futuras')
plt.legend()
plt.show()

Explicación del código:

1. Generación de Datos de Serie Temporal:
   • En el código, se crea una serie temporal univariada de ejemplo. Esta serie temporal se genera como una función seno con ruido aleatorio. Puedes modificar esta parte del código para utilizar tus propios datos de serie temporal. La serie temporal de ejemplo se almacena en la variable series_temporales.
2. Creación de Secuencias y Etiquetas:
   • Para entrenar una RNN, es necesario crear secuencias de datos junto con sus etiquetas correspondientes. El código define una función llamada create_sequences que toma la serie temporal y una ventana deslizante y crea secuencias de datos (ventanas) junto con las etiquetas correspondientes. Estas secuencias y etiquetas se almacenan en las variables X y y.
3. División de Datos en Conjuntos de Entrenamiento y Prueba:
   • Luego, el código divide los datos en conjuntos de entrenamiento (X_train y y_train) y prueba (X_test y y_test) para poder evaluar el modelo de manera efectiva. En este ejemplo, se utiliza el 80% de los datos como entrenamiento y el 20% restante como prueba.
4. Construcción del Modelo RNN:
   • El modelo de RNN se construye utilizando la biblioteca Keras de TensorFlow. En este caso, se utiliza un modelo secuencial de Keras. El modelo consta de una capa RNN (una capa SimpleRNN) y una capa de salida densa. La capa RNN se utiliza para aprender patrones temporales en los datos. El número de unidades en la capa RNN se establece en 32.
5. Compilación del Modelo:
   • El modelo se compila configurando el optimizador y la función de pérdida. En este ejemplo, se utiliza el optimizador ‘adam’ y la función de pérdida ‘mse’ (Mean Squared Error), que es comúnmente utilizada en problemas de regresión. El modelo se compila para minimizar la pérdida cuadrática media entre las predicciones y las etiquetas reales.
6. Entrenamiento del Modelo:
   • El modelo se entrena en los datos de entrenamiento (X_train y y_train) durante un número específico de épocas (en este caso, 50). Durante el entrenamiento, el modelo ajusta sus pesos para aprender los patrones de la serie temporal.
7. Evaluación del Modelo:
   • Después del entrenamiento, el modelo se evalúa en el conjunto de prueba (X_test y y_test) para medir su capacidad para hacer predicciones precisas. La pérdida en el conjunto de prueba se calcula y se muestra en la consola.
8. Predicción de Valores Futuros:
   • Finalmente, el modelo se utiliza para hacer predicciones de valores futuros en la serie temporal. El código predice los próximos valores en la serie y los almacena en la variable predicted. Estas predicciones se generan a partir de la última secuencia de datos en la serie temporal.
9. Visualización de Resultados:
   • Para visualizar los resultados, el código utiliza Matplotlib. La serie temporal original y las predicciones se trazan en un gráfico para permitir una comparación visual. Esto muestra cómo el modelo se desempeña en la tarea de predecir valores futuros en la serie temporal.