XGBoost

Leggendo alcuni articoli ho visto che viene consigliato l'utlilizzo di XGBoost al posto di LSTM sul forecasting di serie tempo...proviamoci con i dati gia' usati nei tentativi precedenti

 

 

Guardando il grafico si conferma che se il modello non conosce una accelerazione non e' in grado di prevederla anche se si usa variabile forzante come la pioggia

Inoltre non vedo particolari motivi per privilegiare XGBoost su LSTM

 

 # -*- coding: utf-8 -*-
"""xgboost.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1zmFI2Djb4bD1hVbJfvFGYgqh0EpfRnRj
"""

import pandas as pd
import matplotlib.pyplot as plt


dati = pd.read_csv('/content/prima.csv')
print(dati)
train = dati.head(int(len(dati)*0.8))
test = dati.tail(int(len(dati)*0.2))

train["Data"] = pd.to_datetime(train["Data"])
test["Data"] = pd.to_datetime(test["Data"])

train = train.set_index("Data")
test = test.set_index("Data")

train["Est"].plot(    , figsize=(10, 5), label="train")
test["Est"].plot(style="b", figsize=(10, 5), label="test")
plt.title("Dati")
plt.legend()

X_train = train.drop('Est', axis =1)
y_train = train['Est']

X_test = test.drop('Est', axis =1)
y_test = test['Est']

!pip install xgboost

import xgboost as xgb

reg = xgb.XGBRegressor(n_estimators=1000)
reg.fit(X_train, y_train, verbose = False)

xgb.plot_importance(reg)

test['Est_Prediction'] = reg.predict(X_test)

train['Est'].plot(style='k', figsize=(10,5), label = 'train')
test['Est'].plot(style='b', figsize=(10,5), label = 'test')
test['Est_Prediction'].plot(style='r', figsize=(10,5), label = 'prediction')
plt.title('XGBoost')
plt.legend()

Ipad 1

Mi e' capitato di tirare fuori dalla discarica informatica di ufficio un paio di Ipad prima generazione per vedere se erano utilizzabili

Una volta connessi all'alimentazione gli Ipad mostravano lo schermo flashare circa una volta al secondo...nessun segno dell'icona di ricarica...nessun altro segno di vita

 

Ho provato a metterli in DFU ed incredibilmente i dispositivi sono stati visti ma il ripristino via ITunes e' fallito con un errore generico che non spiega niente sulle condizioni interne

Ho trovato il programma idevicerestore su Linux che e' molto interessante, specialmente in modo verbose, per capire come funziona il sistema Ipad

La procedura sembra funzionare per il ripristino di IOs ma quando alla fine il dispositivo deve riavviarsi  la procedura fallisce miseramennte (il problema e' segnalato da altre persone https://github.com/libimobiledevice/idevicerestore/issues/324)

Sembra che la batteria sia completamente morta e che non si ricarichi

Purtroppo mi sa che sono diventati dei fermacarte...non so se avro' il tempo e la voglia di aprirli per vedere come sono dentro

ConvLSTM (2)

Proviamo un approccio differente

Fino ad adesso avevo usato solo i dati di allungamento come variabile dipendente e pioggia e temperatura come variabili indipendenti. Adesso provo a mettere la derivata seconda dell'allungamento

Deformazione

Derivata prima della deformazione

Derivata seconda della deformazione

Confronto tra pioggia e derivata seconda della deformazione

Grafico di previsione tramite ConvLSTM

# -*- coding: utf-8 -*-
"""convlstm.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/1yXzW-fOBePUvgY63uMJTjSprP5vMy0tn
"""

import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import ConvLSTM2D, BatchNormalization, Flatten, Dense
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

df = pd.read_csv("prima2.csv", parse_dates=["Data"])
df.set_index("Data", inplace=True)

features = df[['Temp', 'Rain']]  # Input variables
target = df[['Acc']]  # What we are predicting

scaler = MinMaxScaler()
features_scaled = scaler.fit_transform(features)

def create_sequences(data, labels, seq_length=10):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length])  # Take the last `seq_length` time steps
        y.append(labels[i+seq_length])  # Predict the next step
    return np.array(X), np.array(y)

seq_length = 20  # Lookback period
X, y = create_sequences(features_scaled, target.to_numpy(), seq_length)

X = X.reshape((X.shape[0], seq_length, 1, X.shape[2], 1))  # (samples, time, height, width, channels)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

model = Sequential([
    ConvLSTM2D(filters=64, kernel_size=(1, 1), activation='relu', return_sequences=True,
               input_shape=(seq_length, 1, X.shape[3], 1)),
    BatchNormalization(),
    ConvLSTM2D(filters=32, kernel_size=(1, 1), activation='relu', return_sequences=False),
    BatchNormalization(),
    Flatten(),
    Dense(32, activation='relu'),
    Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

y_pred = model.predict(X_test)
#y_pred = (y_pred > 0.5).astype(int)  # Convert probabilities to binary (0 or 1)

# Commented out IPython magic to ensure Python compatibility.
import matplotlib.pyplot as plt
# %matplotlib inline

plt.plot(y_test, label="Actual Acc,")
plt.plot(y_pred, linestyle="dashed", label="Predicted Acc")
plt.legend()
plt.show()

ConvLSTM

Continua l'esplorazione della previsione di serie tempo stavolta con ConvLSTM (il codice e' stato riadattato partendo da Gemini AI)

Il dataset e' sempre multivariato con Est come variabile che vuole essere prevista

Data,Est,Temp,Rain
2023-10-01,-55.7,18.7,0
2023-10-02,-55.6,19,0
2023-10-03,-55.6,19.2,0
2023-10-04,-55.5,19.5,0.2
2023-10-05,-55.9,18.8,0.2
2023-10-06,-55.7,18.1,0

 

 

import pandas as pd
import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt

# 1. Caricamento e preparazione dei dati
def load_and_prepare_data(filepath):
    df = pd.read_csv(filepath, parse_dates=['Data'], index_col='Data')
    df = df.fillna(method='ffill')  # Gestione dei valori mancanti
    scaler = MinMaxScaler()
    scaled_data = scaler.fit_transform(df)
    return scaled_data, scaler, df.columns.get_loc('Est')

# 2. Creazione delle sequenze per il training
def create_sequences(data, target_index, seq_length):
    xs, ys = [], []
    for i in range(len(data) - seq_length):
        x = data[i:i + seq_length]
        y = data[i + seq_length, target_index]
        xs.append(x)
        ys.append(y)
    return np.array(xs), np.array(ys)

# 3. Costruzione del modello LSTM
def build_model(input_shape):
    model = tf.keras.Sequential([
        tf.keras.layers.LSTM(50, return_sequences=True, input_shape=input_shape),
        tf.keras.layers.LSTM(50),
        tf.keras.layers.Dense(1)
    ])
    model.compile(optimizer='adam', loss='mse')
    return model

# 4. Addestramento e valutazione del modello
def train_and_evaluate_model(model, X_train, y_train, X_test, y_test):
    model.fit(X_train, y_train, epochs=50, batch_size=32, validation_split=0.1, verbose=1)
    loss = model.evaluate(X_test, y_test)
    print(f'Test Loss: {loss}')
    return model

# 5. Previsioni e inversione della scala
def make_predictions(model, X_test, scaler, target_index):
    predictions = model.predict(X_test)
    dummy = np.zeros((len(predictions), X_test.shape[2]))
    dummy[:, target_index] = predictions[:, 0]
    predictions_original = scaler.inverse_transform(dummy)[:, target_index]
    return predictions_original

def plot_predictions(predictions, y_test, scaler, target_index):
    # Inverti la scala dei dati reali
    dummy_real = np.zeros((len(y_test), X_test.shape[2]))
    dummy_real[:, target_index] = y_test
    y_test_original = scaler.inverse_transform(dummy_real)[:, target_index]

    plt.figure(figsize=(12, 6))
    plt.plot(y_test_original, label='Dati reali')
    plt.plot(predictions, label='Previsioni')
    plt.legend()
    plt.title('Previsioni vs. Dati reali')
    plt.xlabel('Tempo')
    plt.ylabel('Valore di est')
    plt.show()

def make_single_prediction(model, scaler, seq_length, temp, rain, target_index):
    # Crea una sequenza di input fittizia
    dummy_data = np.zeros((seq_length, 3))
    dummy_data[:, 1] = temp  # temp nella seconda colonna
    dummy_data[:, 2] = rain  # rain nella terza colonna

    # Scala la sequenza di input
    scaled_dummy_data = scaler.transform(dummy_data)

    # Rimodella la sequenza per l'input del modello
    input_data = np.reshape(scaled_dummy_data, (1, seq_length, 3))

    # Effettua la previsione
    prediction = model.predict(input_data)

    # Inverti la scala della previsione
    dummy_prediction = np.zeros((1, 3))
    dummy_prediction[0, target_index] = prediction[0, 0]
    prediction_original = scaler.inverse_transform(dummy_prediction)[0, target_index]

    return prediction_original

# Main
filepath = 'prima.csv'
seq_length = 20  # Lunghezza della sequenza per il modello LSTM
prediction_steps = 20  # dati futuri previsti

scaled_data, scaler, target_index = load_and_prepare_data(filepath)
X, y = create_sequences(scaled_data, target_index, seq_length)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=False)

model = build_model(X_train.shape[1:])
trained_model = train_and_evaluate_model(model, X_train, y_train, X_test, y_test)
predictions = make_predictions(trained_model, X_test, scaler, target_index)

print(predictions)
plot_predictions(predictions, y_test, scaler, target_index)

# Esempio di singola previsione
temp_input = 25.0
rain_input = 10.0
single_prediction = make_single_prediction(trained_model, scaler, seq_length, temp_input, rain_input, target_index)
print(f"Previsione per temp={temp_input} e rain={rain_input}: {single_prediction}")

(Non) comprare Epson XP810

promemoria...non devo comprare stampanti Epson

Oggi mi e' capitato di mettere le mani su una Epson XP 810 che mostrava un errore (waste ink pad) e non permetteva di essere resettata

Un breve giro su Google ed ho scoperto che la stampante ha un contatore in un chip che, una volta raggiunto un determinato numero, blocca la stampante anche se non ci sono reali problemi hardware

Conoscendo il codice di sblocco si puo' resettare il contatore via software  e continuare ad usare il dispositivo...ma questi codici sono in vendita su siti pirati e quindi eviterei

LSTM BiLSTM multivariato

Ho provato ad estendere la prova di questo post utilizzando un dataset multivariato composto da temperatura e pioggia  (dati giornalieri)

I dati sono estesi da ottobre 2023 a marzo 2024. La cosa interessante e' che il dataset di addestramento non comprende la accelerazione che e' iniziata il 3 di marzo e quindi la rete di fatto "non conosce" il trend di accelerazione

 E' stato utilizzato lo script in calce (riadattando questo esempio) usando sia LSTM che BiLSTM

La differenza risulta nel fatto che LSTM si puo' usare per forecasting puro mentre per una post-analisi e' piu' conveniente BiLSTM

LSTM

BiLSTM

# Commented out IPython magic to ensure Python compatibility.

import numpy as np

import pandas as pd

from matplotlib import pyplot as plt

# %matplotlib inline

import seaborn as sns

import time

df = pd.read_csv('/content/ridotto.csv')

df['date'] = pd.to_datetime(df['Data'])

del df['Data']

columns = list(df.columns)

print(columns)

df_corr = df.corr()

df_corr

look_back = 20

sample_size = len(df) - look_back

past_size = int(sample_size*0.8)

future_size = sample_size - past_size +1

def make_dataset(raw_data, look_back=20):

_X = []

_y = []

for i in range(len(raw_data) - look_back):

_X.append(raw_data[i : i + look_back])

_y.append(raw_data[i + look_back])

_X = np.array(_X).reshape(len(_X), look_back, 1)

_y = np.array(_y).reshape(len(_y), 1)

return _X, _y

from sklearn import preprocessing

Xs = []

for i in range(len(columns)):

Xs.append(preprocessing.minmax_scale(df[columns[i]]))

Xs = np.array(Xs)

X_est, y_est = make_dataset(Xs[0], look_back=look_back)

X_temp, y_temp = make_dataset(Xs[1], look_back=look_back)

X_rain, y_rain = make_dataset(Xs[2], look_back=look_back)

X_con = np.concatenate([X_est, X_temp, X_rain], axis=2)

X = X_con

y = y_est

X.shape

y.shape

X_past = X[:past_size]

X_future = X[past_size-1:]

y_past = y[:past_size]

y_future = y[past_size-1:]

X_train = X_past

y_train = y_past

import tensorflow as tf

from tensorflow.keras.layers import Input, LSTM, Dense, BatchNormalization, Bidirectional

from tensorflow.keras.models import Model

from tensorflow.keras.optimizers import SGD, Adam

# LSTM

def create_LSTM_model():

input = Input(shape=(np.array(X_train).shape[1], np.array(X_train).shape[2]))

x = LSTM(64, return_sequences=True)(input)

x = BatchNormalization()(x)

x = LSTM(64)(x)

output = Dense(1, activation='relu')(x)

model = Model(input, output)

return model

# Bidirectional-LSTM

def create_BiLSTM_model():

input = Input(shape=(np.array(X_train).shape[1], np.array(X_train).shape[2]))

x = Bidirectional(LSTM(64, return_sequences=True))(input)

x = BatchNormalization()(x)

x = Bidirectional(LSTM(64))(x)

output = Dense(1, activation='relu')(x)

model = Model(input, output)

return model

model = create_BiLSTM_model()

model.summary()

model.compile(optimizer=Adam(learning_rate=0.0001), loss='mean_squared_error')

t1 = time.time()

history = model.fit(X_train, y_train, epochs = 350, batch_size = 64, verbose = 0)

t2 = time.time()

tt = t2 - t1

t_h = tt//3600

t_m = (tt - t_h*3600)//60

t_s = (tt - t_h*3600 - t_m*60)//1

print('Training Time : '+str(t_h)+' h, '+str(t_m)+' m, '+str(t_s)+' s')

predictions = model.predict(X_past)

future_predictions = model.predict(X_future)

plt.figure(figsize=(18, 9))

plt.plot(df['date'][look_back:], y, color="b", label="Real data")

plt.plot(df['date'][look_back:look_back + past_size], predictions, color="r", linestyle="dashed", label="prediction")

plt.plot(df['date'][-future_size:], future_predictions, color="g", linestyle="dashed", label="future_predisction")

plt.legend()

plt.show()

se si vuole aggiungere in dataset di validazione

X_train, X_val, y_train, y_val = train_test_split(X_past, y_past, test_size=0.2, shuffle=False)

history = model.fit(X_train, y_train, epochs=350, batch_size=64, verbose=0, validation_data=(X_val, y_val))

# ... (codice successivo)

# Visualizzazione della perdita di addestramento e validazione
plt.figure(figsize=(12, 6))
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.legend()
plt.show()

Grafico Voight Log(v)-Log(a)

 Nel precedente post la previsione del tempo dell'evento di frana mostra una finestra di errore di +/- 6 giorni

Proviamo un approccio differente

la relazione lineare tra inverso della velocita' e e tempo e' solo una semplificazione che vale per il valore di alfa=2...ma e' realmente questo il valore corretto

Per stimarlo  si puo' usare il grafico log10(v) vs log10(a) (A relation to describe rate-dependent material failure Barry Voight Science 243)

Il valore della pendenza della retta di regressione indica il valore di alfa (in questo caso 1.72) 

α=10log(A)−β⋅log(V)

 Il valore di alfa e' molto differente da 2. Come si puo' interpretare?

La formula completa e'

 seppure non cambi il tempo stimato dal modello per l'evento si vede che il valore di alfa modifica la forma della serie tempo. Con i dati a disposizione ed il valore di alfa=1.72 si ha che la forma della curva risulterebbe di tipo concavo

Se si fa l'ipotesi di andamento lineare e siamo in realta' in condizioni di concavita' la regressione lineare crea una stima dell'evento anticipata rispetto a quella del modello non lineare 

A rendere le cose ancora piu' complicate che alfa non ' da considerarsi a priori costante ma puo' essere funzione del tempo

 

SLO (Shear Line Optimization) Method

il valore del coefficiente angolare della retta corrisponde al tempo accumulo di