Predicción de Temperaturas

La idea de este proyecto es predecir las temperaturas desde un set de datos y hacer una comparativa entre distintos modelos de predicción LGBM, Conv1D y GRU.

Extraemos data de temperatura, presión, etc...

zip_path = tf.keras.utils.get_file( origin='https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip', fname='jena_climate_2009_2016.csv.zip', extract=True) csv_path, _ = os.path.splitext(zip_path)

Nos concentramos en la temperatura, creamos un nuevo dataframe llamado temp.

df.index = pd.to_datetime(df['Date Time'], format='%d.%m.%Y %H:%M:%S') temp = df['T (degC)'] T_plot = sns.scatterplot(data=temp) sns.set(rc={"figure.figsize":(16, 4)}) T_plot.figure.savefig("/T_plot.png")

Vemos que los datos tienen cierta regularidad. Debería ser posible hacer una predicción. Preparando la data para el forecast, tenemos que lograr esto, en nuestra serie de tiempo:

# [[[1],[2],[3],[4],[5]]] [6] # [[[2],[3],[4],[5],[6]]] [7] # [[[3],[4],[5],[6],[7]]] [8] # X y

def df_to_X_y(df, window_size=5): #El ws corresponde a el largo del row, podría no ser siempre igual. df_as_np = df.to_numpy() X = [] y = [] for i in range(len(df_as_np)-window_size): row = [[a] for a in df_as_np[i:i+5]] X.append(row) # Agregamos la lista en X label = df_as_np[i+5] y.append(label) # Agregamos el elemento que corresponde en y return np.array(X), np.array(y)

El shape de X es (N° de filas, N° de col, elementos). Si vemos el dataframe temp, no concuerda la cantidad de datos (70091) con el shape de X (70086). Esto es, porque los últimos 5 terminos de temp no alcanzan a 'iterar' en la función. Ahora definimos los valores de entrenamiento:

X_train, y_train = X[:60000], y[:60000] X_val, y_val = X[60000:65000], y[60000:65000] X_test, y_test = X[65000:], y[65000:] X_train.shape, y_train.shape, X_val.shape, y_val.shape, X_test.shape, y_test.shape

Acá, entrenaremos con los primeros 60000 términos. La segunda línea es de validación 60000-65000, estos datos son ocupados por el algoritmo para ajustar sus propios parámetros en cada 'epoch' y dismimuir el error. La tercera línea es de testeo, la usaremos para ver como predice nuestro forecast respecto a datos reales. Importamos los paquetes necesarios y llamamos a nuestro modelo 'model1' que tendrá los parámetros para realizar el forecast.

from tensorflow.keras.models import Sequential from tensorflow.keras.layers import * from tensorflow.keras.callbacks import ModelCheckpoint from tensorflow.keras.losses import MeanSquaredError from tensorflow.keras.metrics import RootMeanSquaredError from tensorflow.keras.optimizers import Adam model1= Sequential() #Keras es una API secuencial model1.add(InputLayer((5, 1))) #Especificamos el 'shape' de X model1.add(LSTM(64)) # Especificamos la dimensionalidad del espacio de salida model1.add(Dense(8, 'relu')) model1.add(Dense(1, 'linear')) model1.summary()

Ahora estudiamos como se comportan los datos predichos con los reales.

train_tests = model1.predict(X_test).flatten() train_test_results = pd.DataFrame(data={'Train Test Predictions':train_tests, 'Actuals':y_test}) plt.plot(train_test_results['Train Test Predictions'][1000:2000]) plt.plot(train_test_results['Actuals'][1000:2000])

Condensamos todo en una sola función, para mostrar el dataframe, el 'mean squared error' y el gráfico.

from sklearn.metrics import mean_squared_error as mse def plot_predictions1(model, X, y, start=0, end=100): predictions = model.predict(X).flatten() df = pd.DataFrame(data={'Predictions':predictions, 'Actuals':y}) plt.plot(df['Predictions'][start:end]) plt.plot(df['Actuals'][start:end]) return df, mse(y, predictions)

plot_predictions1(model1, X_test, y_test)

Diferentes modelos, más variables

Modelo Conv1D

Conv es un modelo para matrices en 2d pero podemos utilizarlo en 1d también, tenemos que considerar los parámetros correctos (Los parámetros pueden ser consultados ejecutando model.summary()). La ventaja es que la cantidad de parámetros de este modelo es más baja, con respecto a LSTM. Esto nos da ventaja desde el punto de vista computacional (se ejecuta más rápido).

model2= Sequential() model2.add(InputLayer((5, 1))) #El window size es 5. Los datos a predecir es 1. model2.add(Conv1D(64,kernel_size=2)) model2.add(Flatten()) model2.add(Dense(8, 'relu')) model2.add(Dense(1, 'linear')) cp2 = ModelCheckpoint('model2/', save_best_only=True) model2.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model2.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=10, callbacks=[cp2], verbose=0)

Modelo GRU

Consideramos un nuevo modelo, GRU. Este modelo tiene menos parámetros respecto a LSTM, pero más respecto a Conv1D.

model3= Sequential() model3.add(InputLayer((5, 1))) model3.add(GRU(64)) model3.add(Flatten()) model3.add(Dense(8, 'relu')) model3.add(Dense(1, 'linear')) cp3 = ModelCheckpoint('model3/', save_best_only=True) model3.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model3.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=10, callbacks=[cp3], verbose=0)

Adición de variables temporales

Agregamos variables temporales adicionales en segundos al dataframe. Esto, porque la variable temporal está claramente correlacionada con la forma que varía la temperatura (por ejemplo en invierno la temperatura es mínima y en verano es máxima). La correlación también se observa en un día, durante el mediodía la temperatura es máxima y en la noche es mínima. La función para transformar la variable temporal, tiene que ser sinusoidal, ya que las temperaturas también siguen esta forma. Si logramos que la variable temporal tenga una correlación con la temperatura, esto ayudará al modelo a decrecer su validation loss de manera más eficiente.

temp_df = pd.DataFrame({'Temperature':temp}) temp_df['Seconds'] = temp_df.index.map(pd.Timestamp.timestamp) temp_df

Vemos que los segundos parten desde un valor muy grande. Para nuestro cálculo, no es necesario cambiarlo. Si fuera necesario cambiar el tiempo en segundos, solamente tenemos que hacer un shift de los segundos fijando el cero en el primer término.

Agregamos nuevas columnas al dataframe, donde ponemos las sinusoidales aplicadas a la variable temporal. Aplicamos las función sin y cos en la variable temporal de la siguiente manera:

T_day(t) = Sin(t * 2 pi / day), T_day(t) = Cos(t * 2 pi / day), T_year(t) = Sin(t * 2 pi / year), T_year = Cos(t* 2 pi / year)

Claramente, day y year dentro de las funciones son el período de las funciones temporales.

day = 60*60*24 year = 365.2425*day temp_df['Day sin']= np.sin(temp_df['Seconds']* (2 * np.pi / day)) temp_df['Day cos']= np.cos(temp_df['Seconds']* (2 * np.pi / day)) temp_df['Year sin']= np.sin(temp_df['Seconds']* (2 * np.pi / year)) temp_df['Year cos']= np.cos(temp_df['Seconds']* (2 * np.pi / year)) temp_df = temp_df.drop('Seconds', axis=1) temp_df.head()

model4= Sequential() model4.add(InputLayer((6, 5))) # 6 Layers y 5 variables de interes model4.add(LSTM(64)) model4.add(Dense(8, 'relu')) model4.add(Dense(1, 'linear')) cp4 = ModelCheckpoint('model4/', save_best_only=True) model4.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model4.fit(X2_train, y2_train, validation_data=(X2_val, y2_val), epochs=10, callbacks=[cp4], verbose=0)

model5= Sequential() model5.add(InputLayer((7, 6))) # 7 Layers y 6 variables de interes model5.add(LSTM(64)) model5.add(Dense(8, 'relu')) model5.add(Dense(2, 'linear')) #ahora es 2, por las 2 variables del output cp5 = ModelCheckpoint('model5/', save_best_only=True) model5.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model5.fit(X3_train, y3_train, validation_data=(X3_val, y3_val), epochs=10, callbacks=[cp5], verbose=0)

model6 = Sequential() model6.add(InputLayer((7, 6))) model6.add(LSTM(32, return_sequences=True)) model6.add(LSTM(64)) model6.add(Dense(8, 'relu')) model6.add(Dense(2, 'linear')) cp6 = ModelCheckpoint('model6/', save_best_only=True) model6.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model6.fit(X3_train, y3_train, validation_data=(X3_val, y3_val), epochs=10, callbacks=[cp6], verbose=0)

model7 = Sequential() model7.add(InputLayer((7, 6))) model7.add(Conv1D(64, kernel_size=2, activation='relu')) model7.add(Flatten()) model7.add(Dense(8, 'relu')) model7.add(Dense(2, 'linear')) cp7 = ModelCheckpoint('model7/', save_best_only=True) model7.compile(loss=MeanSquaredError(), optimizer=Adam(learning_rate=0.0001), metrics=[RootMeanSquaredError()]) model7.fit(X3_train, y3_train, validation_data=(X3_val, y3_val), epochs=10, callbacks=[cp7], verbose=0)

Conclusiones

A continuación hacemos un dataframe comparativo, resumiendo los Mean Squared Error (MSE) de todas nuestras predicciones,

def PredMSE(model, X, y): predictions = model.predict(X).flatten() return mse(y, predictions) def PredMSEb(model, X, y): predictions = model.predict(X) temp_preds = postprocess_temp(predictions[:, 1]) temp_actuals = postprocess_temp(y[:, 1]) return mse(temp_actuals, temp_preds) df_Summ = pd.DataFrame({'Modelos': ['LSTM(64)','Conv1D(64)','GRU(64)','LSTM(64)-TF','LSTM(64)-TF-P','LSTM(32)-LSTM(64)-TF-P','Conv1D(64)-TF-P'], 'Mean Squared Error': [PredMSE(model1,X_test,y_test), PredMSE(model2,X_test,y_test), PredMSE(model3,X_test,y_test), PredMSE(model4,X2_test,y2_test), PredMSEb(model5,X3_test,y3_test),PredMSEb(model6,X3_test,y3_test), PredMSEb(model7,X3_test,y3_test)]}) df_Summ

graficando,

sns.barplot(data=df_Summ,x='Modelos',y='Mean Squared Error') plt.title('Models MSE Comparison')