Para la predicción de temperaturas, se utiliza un conjunto de datos que incluye características como temperaturas anteriores y promedios históricos. El objetivo es predecir la temperatura máxima actual.

Lectura y Preprocesamiento de Datos

Se importan las bibliotecas necesarias y se carga el archivo CSV con los datos meteorológicos.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import torch
from sklearn.preprocessing import StandardScaler
import datetime

# Cargar datos desde CSV
data_set = pd.read_csv('ruta/al/archivo/temps.csv')

# Extraer componentes de fecha
anios = data_set['year']
meses = data_set['month']
dias = data_set['day']

# Formatear fechas
fechas = [str(int(a)) + '-' + str(int(m)) + '-' + str(int(d)) for a, m, d in zip(anios, meses, dias)]
fechas = [datetime.datetime.strptime(fecha, '%Y-%m-%d') for fecha in fechas]

# Visualización de datos con subplots
plt.style.use('ggplot')
fig, ejes = plt.subplots(nrows=2, ncols=2, figsize=(10, 10))
fig.autofmt_xdate(rotation=45)

ejes[0, 0].plot(fechas, data_set['actual'])
ejes[0, 0].set_ylabel('Temperatura')
ejes[0, 0].set_title('Temperatura Máxima Actual')

ejes[0, 1].plot(fechas, data_set['temp_1'])
ejes[0, 1].set_ylabel('Temperatura')
ejes[0, 1].set_title('Temperatura Máxima del Día Anterior')

ejes[1, 0].plot(fechas, data_set['temp_2'])
ejes[1, 0].set_xlabel('Fecha')
ejes[1, 0].set_ylabel('Temperatura')
ejes[1, 0].set_title('Temperatura Máxima de Hace Dos Días')

ejes[1, 1].plot(fechas, data_set['average'])
ejes[1, 1].set_xlabel('Fecha')
ejes[1, 1].set_ylabel('Temperatura')
ejes[1, 1].set_title('Temperatura Promedio Histórica')

plt.tight_layout(pad=2)
plt.show()

Preparación de Datos para el Modelo

Los datos categóricos se codifican en formato one-hot, se separan las etiquetas y se normalizan las características.

# Codificación one-hot para atributos categóricos
data_set = pd.get_dummies(data_set)

# Separar etiquetas y características
etiquetas = np.array(data_set['actual'])
atributos = data_set.drop('actual', axis=1)
nombres_atributos = list(atributos.columns)
atributos = np.array(atributos)

# Escalado de características
escalador = StandardScaler()
atributos = escalador.fit_transform(atributos)

# Conversión a tensores de PyTorch
X = torch.tensor(atributos, requires_grad=True, dtype=torch.double)
Y = torch.tensor(etiquetas, dtype=torch.double).unsqueeze(1)

# Dimensiones de entrada
dim_entrada = atributos.shape[1]

Construcción y Etnrenamiento de la Red Neuronal

Se definen los parámetros del modelo y se ejecuta el bucle de entrenamiento para minimizar el error cuadrático medio.

# Hiperparámetros
neuronas_ocultas = 32
tasa_aprendizaje = 0.005
epocas = 5000

# Inicialización de pesos y sesgos
pesos_capa1 = torch.randn((dim_entrada, neuronas_ocultas), dtype=torch.double, requires_grad=True)
sesgos_capa1 = torch.randn(neuronas_ocultas, dtype=torch.double, requires_grad=True)
pesos_capa2 = torch.randn((neuronas_ocultas, 1), dtype=torch.double, requires_grad=True)

# Almacenar pérdidas
historial_perdidas = []

# Entrenamiento
for epoca in range(epocas):
    # Propagación hacia adelante
    capa_oculta = torch.matmul(X, pesos_capa1) + sesgos_capa1
    activacion = torch.sigmoid(capa_oculta)
    predicciones = torch.matmul(activacion, pesos_capa2)
    
    # Cálculo de la pérdida
    perdida = torch.mean((predicciones - Y) ** 2)
    historial_perdidas.append(perdida.item())
    
    # Retropropagación y actualización
    perdida.backward()
    
    with torch.no_grad():
        pesos_capa1 -= tasa_aprendizaje * pesos_capa1.grad
        sesgos_capa1 -= tasa_aprendizaje * sesgos_capa1.grad
        pesos_capa2 -= tasa_aprendizaje * pesos_capa2.grad
    
    # Reiniciar gradientes
    pesos_capa1.grad.zero_()
    sesgos_capa1.grad.zero_()
    pesos_capa2.grad.zero_()
    
    # Registro periódico
    if epoca % 500 == 0:
        print(f'Época {epoca}, Pérdida: {perdida.item():.4f}')

El entrenamiento ajusta iterativamente los parámetros del modelo para reducir el error de predicción.