Serie de Tiempo Simple

Una serie de tiempo es una secuencia de datos recolectados en intervalos de tiempo regulares, ordenados cronológicamente.

Estos datos pueden representar diversos fenómenos, como la temperatura diaria, las ventas mensuales, el precio de acciones, o cualquier otra variable que se registre a lo largo del tiempo. El análisis de series de tiempo busca identificar patrones, tendencias, y estacionalidades para hacer predicciones o comprender mejor el comportamiento del fenómeno estudiado.

Hacemos una implementacion en Python para predecir la variación estacional de la temperatura a lo largo de un año.

Importamos los módulos necesarios

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

Generación de la Serie Temporal

series_temporales = np.sin(0.1 * np.arange(200)) + np.random.randn(200) * 0.1

Se genera una serie temporal con una componente sinusoidal y un ruido aleatorio, como explicamos anteriormente.

Función para Crear Secuencias de Datos y 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)

sta función toma la serie temporal data y un window_size (tamaño de ventana) y genera secuencias de longitud window_size y sus etiquetas correspondientes, que son el siguiente valor en la serie temporal.

División de 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:]

Creación del Modelo RNN

model = tf.keras.Sequential([
    tf.keras.layers.SimpleRNN(32, input_shape=(window_size, 1)),
    tf.keras.layers.Dense(1)
])

• Se define un modelo secuencial de tf.keras.

• La primera capa es una SimpleRNN con 32 unidades y una forma de entrada que corresponde a la window_size y 1 característica.

• La segunda capa es una capa densa (Dense) con una unidad de salida.

Compilación y entrenamiento del Modelo

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

model.fit(X_train, y_train, epochs=50, verbose=0)

Evaluación del Modelo

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

Predicción de Valores Futuros

future = 10  # 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]

• future define el número de puntos futuros a predecir.

• last_sequence es la última secuencia de los datos de entrenamiento.

• En el bucle, se predicen los siguientes valores uno a uno y se actualiza last_sequence desplazándola y añadiendo la nueva predicción al final.

Visualización de 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()

Se grafica la serie temporal original y las predicciones futuras usando matplotlib