Ciao a tutti, sono nuovo di questo mondo e sono un paio di settimane che sto studiando , per la programmazione in python, dei vari framework, logiche, approci da applicare.
Arrivo al dunque spiegando il mio quesito:
Ho una tabella chiamata Dati con i seguenti campi:
Scadenza : Date > X
Portaf : String > X
Tipo_CR : String > X
Lag : String > X
Tipo_Doc : String > X
Tipo_FF : String > X
Perc : Decimal > X
Factor : String > X
Netto_Split : Decimal > X
Importo1 : Decimal > X
Importo2 : Decimal > X
Data_Invio : Date > Y
Da Scadenza a Importo2 sono campi che vanno in X come input e il campo Data_Invio va in Y come output.
Essendo Data_Invio un campo ti tipo Date, lo converto in Booleano ( Target ) , se il campo è valorizzato allora il record è selezionato ( 1 ) altrimenti non è selezionato ( 0 ) .
Fornendo un set di dati input, a seguito dell'apprendimento della tabella, mi dovrà predire quali record verranno selezionati o no
Converto i campi di tipo Date in timestamp e i campi di tipo string con OneHotEncoder, ottendendo il seguente output:
Sto usando tensorflow e sklearn.
Il dataset a disposizione e di circa 3M di record, durante l'addestramento, già al secondo Epoch, ottengo un accuracy di 1
che mi sembra molto strano.
Questa è parte del codice che ho scritto , nella funzione train_model ho settato un Sequential 128, 64, 1 e settando il fit con batch_size=32, validation_split=0.2,
Purtroppo la predizione non è vera, in quanto i parametri usati in input per il test sono relativi a dati realmente selezionati. Quindi tempo di aver sbagliato qualcosa nell'approccio ( considerato la tipologia dei dati a disposizione ) o nella configurazione della NN .
Qualcuno mi saprebbe fornire un supporto in merito?
Grazie mille a tutti.
Allego anche i grafici di tensorboard
import sqlite3
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.callbacks import TensorBoard
from imblearn.over_sampling import SMOTE
def preprocess_data(df):
# Gestione dei valori mancanti
df.fillna(method='ffill', inplace=True)
# Conversione delle date in timestamp
df['SCADENZA'] = pd.to_datetime(df['SCADENZA']).astype(int) / 10**9
df['DATA_INVIO_FILE'] = pd.to_datetime(df['DATA_INVIO_FILE']).astype(int) / 10**9
# Separazione delle features e target
features = df.drop(columns=['TARGET'])
target = df['TARGET']
return features, target
def build_preprocessor(numerical_features, categorical_features):
preprocessor = ColumnTransformer(
transformers=[
('num', StandardScaler(), numerical_features),
('cat', OneHotEncoder(), categorical_features)
])
return preprocessor
def build_model(input_shape):
model = Sequential([
Dense(64, activation='relu'),
Dropout(0.3),
Dense(32, activation='relu'),
Dropout(0.3),
Dense(1, activation='sigmoid')
])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
return model
def ML(mode):
conn = sqlite3.connect('../MachineLearning.db')
query = "SELECT * FROM Dati" # Assuming TARGET is also in this query
df = pd.read_sql_query(query, conn)
conn.close()
numerical_features = ['PERC', 'NETTOSPLIT', 'IMPORTO1', 'IMPORTO2', 'SCADENZA', 'DATA_INVIO_FILE']
categorical_features = ['PORTAF', 'TIPO_CR', 'LAG', 'TIPO_DOC', 'TIPO_FF', 'FACTOR']
features, target = preprocess_data(df)
preprocessor = build_preprocessor(numerical_features, categorical_features)
X = preprocessor.fit_transform(features)
y = target.values
# Bilanciamento del dataset
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)
# Training e validation split
X_train, X_val, y_train, y_val = train_test_split(X_res, y_res, test_size=0.2, random_state=42)
if mode == 'train':
model = build_model(X_train.shape[1])
log_dir = './logs'
tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1)
model.fit(X_train, y_train, epochs=10, batch_size=32, validation_data=(X_val, y_val), callbacks=[tensorboard_callback])
model.save('data/trained_model.h5')
print("Addestramento completato. Il modello è stato salvato in 'trained_model.h5'.")
print(f"TensorBoard logs salvati in: {log_dir}")
elif mode == 'predict':
model = tf.keras.models.load_model('data/trained_model.h5')
X_predict = preprocessor.transform(features) # Assuming predict_df corresponds to some portion of features
predictions = model.predict(X_predict)
df['PREDICTION'] = (predictions > 0.5).astype(int)
df.to_csv('risultati_previsione.csv', index=False)
print("Predizione completata. I risultati sono stati salvati in 'risultati_previsione.csv'.")
# Usage example: ML('train') or ML('predict')
Ciao Salvatore! Sono Paolo dalla redazione di IntelligenzaArtificialeItalia.net. Ho dato un'occhiata alla tua situazione e vedo che ci sono un paio di cose che potremmo migliorare insieme per far funzionare al meglio il tuo modello di deep learning. 🚀
Checkup iniziale: Prima di tutto, facciamo un rapido controllo sulla pulizia dei dati. Assicurati che non ci siano valori mancanti o incoerenti, specialmente nelle date convertite in timestamp. Un piccolo errore qui può rovinare tutto il dataset!
Riduci l'Overfitting: Hai notato un'accuratezza perfetta troppo presto, il che grida overfitting. Potremmo semplificare il modello. Magari inizia con meno neuroni per strato, tipo 64 e 32, e vedi come va. Aggiungi anche Dropout tra gli strati per aiutare a prevenire l'overfitting:
from tensorflow.keras.layers import Dropout # Aggiungendo Dropout model.add(Dropout(0.5)) # Dove 0.5 è la frazione di input da annullareBilancia il Dataset: Se i tuoi dati sono sbilanciati (troppe istanze di una classe rispetto all'altra), il modello potrebbe diventare prevenuto. Usa tecniche di bilanciamento come il SMOTE o prova a pesare le classi nel tuo modello.
Validazione e Metriche: Cambia la tua metrica di successo. Oltre all'accuratezza, considera di utilizzare la precisione, il recall, e l'AUC-ROC per avere un quadro più chiaro di come il modello performa su classi diverse.
Cross-Validation: Per assicurarti che il modello sia stabile e generalizzi bene, implementa una cross-validation. Questo evita che il modello si "memorizzi" i tuoi dati di training.
Debugging e Log: Dai un'occhiata ai log di training. Se il modello ha sempre le stesse metriche ad ogni epoch, potrebbe essere un segno che non sta imparando nulla di nuovo. Potrebbe essere utile anche visualizzare i dati in input al modello proprio prima del training per assicurarsi che tutto sia in ordine.
Regolarizzazione: Considera di aggiungere una regolarizzazione L1 o L2 alle tue reti per penalizzare i pesi troppo grandi e ridurre l'overfitting:
python
Copia codice
from tensorflow.keras.regularizers import l2 # Aggiungendo la regolarizzazione L2 model.add(Dense(64, activation='relu', kernel_regularizer=l2(0.01)))
Per darci dentro, ecco un esempio di come potresti strutturare il tuo modello con queste modifiche:
from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout from tensorflow.keras.regularizers import l2 model = Sequential([ Dense(64, activation='relu', kernel_regularizer=l2(0.001)), Dropout(0.3), Dense(32, activation='relu', kernel_regularizer=l2(0.001)), Dropout(0.3), Dense(1, activation='sigmoid') ]) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy', 'AUC'])Questi passaggi dovrebbero aiutarti a ottenere un modello più robusto e affidabile.
Comunque senza divagarci in chiacchere, ho provato ad aggiungere io per te qualche cosetta, fammi sapere se con questo codice le cose migliorano. E' il file allegato Salvatore.txt
Se hai bisogno di ulteriori dettagli o vuoi discutere altri aspetti, sono qui per aiutarti! 💪