En este módulo, aplicaremos los conocimientos adquiridos en los módulos anteriores para abordar un problema de pronóstico de series temporales utilizando PyTorch. Este proyecto te permitirá consolidar tus habilidades en el manejo de datos, construcción de modelos y entrenamiento de redes neuronales recurrentes (RNNs).
Objetivos del Proyecto
- Comprender los conceptos básicos del pronóstico de series temporales.
- Preprocesar y preparar los datos de series temporales para el modelado.
- Construir y entrenar una RNN para el pronóstico de series temporales.
- Evaluar el rendimiento del modelo y realizar ajustes para mejorar la precisión.
- Introducción al Pronóstico de Series Temporales
¿Qué es una Serie Temporal?
Una serie temporal es una secuencia de datos puntos, típicamente consistentes en mediciones sucesivas hechas a intervalos de tiempo uniformes. Ejemplos comunes incluyen datos de ventas mensuales, temperaturas diarias, y precios de acciones.
Características de las Series Temporales
- Tendencia: Componente a largo plazo que muestra un aumento o disminución general.
- Estacionalidad: Patrones que se repiten a intervalos regulares.
- Ciclo: Fluctuaciones que ocurren a intervalos irregulares.
- Ruido: Variaciones aleatorias que no siguen un patrón específico.
- Preprocesamiento de Datos
Carga de Datos
Para este proyecto, utilizaremos un conjunto de datos de ejemplo que contiene las temperaturas diarias de una ciudad durante varios años.
import pandas as pd
# Cargar el conjunto de datos
data = pd.read_csv('daily_temperatures.csv', parse_dates=['date'], index_col='date')
print(data.head())Normalización de Datos
La normalización es crucial para mejorar la convergencia del modelo.
from sklearn.preprocessing import MinMaxScaler # Normalizar los datos scaler = MinMaxScaler(feature_range=(0, 1)) data['temperature'] = scaler.fit_transform(data['temperature'].values.reshape(-1, 1))
Creación de Secuencias de Entrenamiento
Convertimos la serie temporal en secuencias de entrada y salida para el modelo.
import numpy as np
def create_sequences(data, seq_length):
xs, ys = [], []
for i in range(len(data) - seq_length):
x = data[i:i+seq_length]
y = data[i+seq_length]
xs.append(x)
ys.append(y)
return np.array(xs), np.array(ys)
seq_length = 30 # Usamos 30 días de datos para predecir el siguiente día
X, y = create_sequences(data['temperature'].values, seq_length)
- Construcción y Entrenamiento del Modelo
Definición del Modelo
Utilizaremos una RNN simple con LSTM para el pronóstico.
import torch
import torch.nn as nn
import torch.optim as optim
class LSTMModel(nn.Module):
def __init__(self, input_size, hidden_layer_size, output_size):
super(LSTMModel, self).__init__()
self.hidden_layer_size = hidden_layer_size
self.lstm = nn.LSTM(input_size, hidden_layer_size)
self.linear = nn.Linear(hidden_layer_size, output_size)
self.hidden_cell = (torch.zeros(1,1,self.hidden_layer_size),
torch.zeros(1,1,self.hidden_layer_size))
def forward(self, input_seq):
lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq) ,1, -1), self.hidden_cell)
predictions = self.linear(lstm_out.view(len(input_seq), -1))
return predictions[-1]
# Parámetros del modelo
input_size = 1
hidden_layer_size = 100
output_size = 1
model = LSTMModel(input_size, hidden_layer_size, output_size)Entrenamiento del Modelo
Definimos la función de pérdida y el optimizador, y entrenamos el modelo.
loss_function = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
epochs = 100
for i in range(epochs):
for seq, labels in zip(X, y):
optimizer.zero_grad()
model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
torch.zeros(1, 1, model.hidden_layer_size))
y_pred = model(torch.FloatTensor(seq))
single_loss = loss_function(y_pred, torch.FloatTensor([labels]))
single_loss.backward()
optimizer.step()
if i%10 == 1:
print(f'epoch: {i:3} loss: {single_loss.item():10.8f}')
- Evaluación del Modelo
Predicción y Visualización
Evaluamos el modelo utilizando un conjunto de datos de prueba y visualizamos los resultados.
import matplotlib.pyplot as plt
# Generar predicciones
model.eval()
test_inputs = data['temperature'].values[-seq_length:].tolist()
for i in range(30): # Predecir los próximos 30 días
seq = torch.FloatTensor(test_inputs[-seq_length:])
with torch.no_grad():
model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size),
torch.zeros(1, 1, model.hidden_layer_size))
test_inputs.append(model(seq).item())
# Invertir la normalización
actual_predictions = scaler.inverse_transform(np.array(test_inputs[seq_length:]).reshape(-1, 1))
# Visualizar los resultados
plt.plot(data.index[-60:], scaler.inverse_transform(data['temperature'].values[-60:].reshape(-1, 1)), label='Actual')
plt.plot(pd.date_range(start=data.index[-1], periods=31, closed='right'), actual_predictions, label='Predicted')
plt.legend()
plt.show()Conclusión
En este proyecto, hemos cubierto los pasos esenciales para el pronóstico de series temporales utilizando PyTorch. Desde la carga y preprocesamiento de datos hasta la construcción, entrenamiento y evaluación de un modelo LSTM, hemos aplicado técnicas clave para abordar problemas de series temporales. Este proyecto no solo refuerza los conceptos aprendidos en módulos anteriores, sino que también proporciona una base sólida para abordar problemas más complejos en el futuro.
Resumen de Conceptos Clave
- Series Temporales: Comprensión de sus componentes y características.
- Preprocesamiento: Normalización y creación de secuencias de datos.
- Modelado: Construcción y entrenamiento de una RNN con LSTM.
- Evaluación: Predicción y visualización de resultados.
Próximos Pasos
- Experimentar con diferentes arquitecturas de RNN y parámetros de hiperajuste.
- Implementar técnicas avanzadas de preprocesamiento y manejo de datos faltantes.
- Explorar otros tipos de series temporales y problemas de pronóstico.
¡Felicidades por completar este proyecto! Ahora estás mejor preparado para enfrentar desafíos de pronóstico de series temporales en el mundo real.
PyTorch: De Principiante a Avanzado
Módulo 1: Introducción a PyTorch
- ¿Qué es PyTorch?
- Configuración del Entorno
- Operaciones Básicas con Tensores
- Autograd: Diferenciación Automática
Módulo 2: Construcción de Redes Neuronales
- Introducción a las Redes Neuronales
- Creación de una Red Neuronal Simple
- Funciones de Activación
- Funciones de Pérdida y Optimización
Módulo 3: Entrenamiento de Redes Neuronales
- Carga y Preprocesamiento de Datos
- Bucle de Entrenamiento
- Validación y Pruebas
- Guardar y Cargar Modelos
Módulo 4: Redes Neuronales Convolucionales (CNNs)
- Introducción a las CNNs
- Construcción de una CNN desde Cero
- Aprendizaje por Transferencia con Modelos Preentrenados
- Ajuste Fino de CNNs
Módulo 5: Redes Neuronales Recurrentes (RNNs)
- Introducción a las RNNs
- Construcción de una RNN desde Cero
- Redes de Memoria a Largo Plazo (LSTM)
- Unidades Recurrentes con Puerta (GRUs)
Módulo 6: Temas Avanzados
- Redes Generativas Antagónicas (GANs)
- Aprendizaje por Refuerzo con PyTorch
- Despliegue de Modelos PyTorch
- Optimización del Rendimiento