Modello usato per addestramento

from keras.models import Sequential
from keras.layers import Bidirectional, LSTM, GRU, Dense, Dropout

# Costruzione del modello
model = Sequential()

# Aggiungere più strati LSTM con un numero minore di unità
from keras.models import Sequential
from keras.layers import Bidirectional, LSTM, GRU, Dense, Dropout

# Costruzione del modello
model = Sequential()

# Aggiungere un singolo strato Bidirectional LSTM con meno unità
model.add(Bidirectional(LSTM(128, return_sequences=True), input_shape=(1, X.shape[2])))
model.add(Dropout(0.3))

# Aggiungere un singolo strato Bidirectional GRU
model.add(Bidirectional(GRU(128)))
model.add(Dropout(0.3))

# Strato finale di output
model.add(Dense(1))

# Compilare il modello 
model.compile(optimizer='adam', loss='mse')

Come si vede ho scelto il modello bidirezionale GRU e LSTM, in una rete non complessa
Ho infatti sperimentato diversi modelli e questo è quello che mi ha dato i migliori risultati

Le reti neurali bidirezionali LSTM e GRU sono varianti delle reti neurali ricorrenti (RNN) progettate per catturare le dipendenze temporali nei dati in entrambe le direzioni temporali: passato e futuro.
Questo significa che sono in grado di considerare il contesto precedente e successivo durante l'elaborazione delle sequenze di dati.

Reti bidirezionali LSTM (Long Short-Term Memory)

Le reti bidirezionali LSTM incorporano due strutture LSTM separate: una che elabora i dati in avanti lungo la sequenza temporale e l'altra che elabora i dati all'indietro.
Questo consente alla rete di catturare le dipendenze temporali sia da sinistra a destra che da destra a sinistra nella sequenza di dati. Le LSTM sono dotate di meccanismi speciali, come le porte di input, output e dimenticanza, che consentono loro di memorizzare e utilizzare informazioni a lungo termine nelle sequenze di dati.

Le reti neurali bidirezionali sono particolarmente utili in un'analisi di sequenze con molti dati poiché consentono di catturare le dipendenze temporali sia in avanti che all'indietro nella sequenza.
Questo è particolarmente vantaggioso quando si hanno grandi quantità di dati e si desidera ottenere una comprensione più completa delle relazioni temporali presenti nei dati stessi.

Reti bidirezionali GRU (Gated Recurrent Unit)

Le reti bidirezionali GRU funzionano in modo simile alle LSTM, ma utilizzano una struttura più semplice chiamata Gated Recurrent Unit (GRU).
Le GRU hanno meno parametri rispetto alle LSTM e sono più facili da addestrare. Una GRU ha due porte principali: una porta di aggiornamento e una porta di reset.
Queste porte controllano il flusso di informazioni attraverso la rete e permettono alla GRU di catturare le dipendenze a lungo termine nelle sequenze di dati.
Le reti bidirezionali GRU sono spesso utilizzate in applicazioni in cui è importante ridurre la complessità del modello senza sacrificare le prestazioni, come il riconoscimento del linguaggio naturale e la generazione di sequenze.

In sintesi, sia le reti bidirezionali LSTM che GRU sono potenti strumenti per modellare relazioni complesse nelle sequenze di dati, consentendo alla rete di considerare sia il contesto passato che futuro.
La scelta tra LSTM e GRU dipende spesso dalle esigenze specifiche del problema e dalla complessità del modello richiesta.

Il modello si apre con due istruzioni

model.add(Bidirectional(LSTM(128, return_sequences=True), input_shape=(1, X.shape[2])))
model.add(Dropout(0.3))

 

Queste due istruzioni definiscono un modello di rete neurale con uno strato bidirezionale LSTM seguito da uno strato Dropout per la regolarizzazione.

• Bidirectional: Questo strato avvolge uno strato LSTM e lo rende bidirezionale, ovvero elabora i dati sia in avanti che all'indietro lungo la sequenza temporale.
• LSTM(128, return_sequences=True): Questo è lo strato LSTM all'interno della struttura bidirezionale.
  Specifica che la rete LSTM avrà 128 unità (o nodi) e restituirà sequenze complete invece di solo l'output all'ultimo timestamp temporale.
  Questo è utile quando si hanno più timestamp di output, come nel caso della previsione di serie temporali.
• input_shape=(1, X.shape[2]): Specifica la forma dell'input per la rete.
  Definisce che il modello accetta dati di input tridimensionali, con una dimensione del batch di 1 (per l'elaborazione di un esempio alla volta) e una lunghezza della sequenza o il numero di attributi di X come numero di caratteristiche per ogni istanza dei dati di input.
  
• model.add(Dropout(0.3)): Questa istruzione aggiunge uno strato Dropout al modello.
  Dropout(0.3): Specifica il tasso di dropout, che è la frazione delle unità di input da eliminare casualmente durante l'addestramento.
  In questo caso, il 30% delle unità di input viene eliminato casualmente durante l'addestramento per prevenire l'overfitting, ovvero per migliorare la generalizzazione del modello.

Compilare il modello con MSE

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

Configura il modello per utilizzare l'ottimizzatore Adam durante l'addestramento e la funzione di perdita Mean Squared Error (MSE) per valutare l'errore del modello durante l'addestramento.
Ottimizzatore Adam Adam è un algoritmo di ottimizzazione basato su una stima adattativa dei momenti del gradiente.
loss='mse' La funzione di perdita è 'mse', che sta per Mean Squared Error (Errore quadratico medio).
MSE è comunemente utilizzato nelle task di regressione ed è definito come la media degli errori quadratici tra le previsioni del modello e i valori reali dei dati di addestramento

Accuratezza del modello con MAPE o RMSE

Una alternativa è quella di usare MAPE
import tensorflow as tf from keras import backend as K

from keras import backend as K
def mean_absolute_percentage_error(y_true, y_pred):
    return K.mean(K.abs((y_true - y_pred) / y_true)) * 100

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

MAPE è una misura della percentuale di errore medio tra le previsioni del modello e i valori reali dei dati.


Oppure RMSE

from keras import backend as K

def root_mean_squared_error(y_true, y_pred):
    return K.sqrt(K.mean(K.square(y_pred - y_true)))

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

RMSE è una misura della deviazione tra le previsioni del modello e i valori reali dei dati.