Allego anche i grafici di tensorboard

Ciao Paolo, in primis grazie mille per la celere risposta e il supporto. Ho usato il codice che mi hai fornito apportando delle piccole modifiche che provo a riportare di seguito   df['SCADENZA'] = pd.to_datetime(df['SCADENZA'], format='%d/%m/%Y').astype("int64") / 10**9 df['TARGET'] = pd.to_datetime(df['DATA_INVIO_FILE'], format='%d/%m/%Y', errors='coerce').notna().astype(int) df['DATA_INVIO_FILE'] = pd.to_datetime(df['DATA_INVIO_FILE'], format='%d/%m/%Y', errors='coerce').astype("int64") / 10**9 def clean_numeric(df, columns): for col in columns: df.loc[:, col] = (df[col] .astype(str) .str.strip() .str.replace('.', '') .str.replace(',', '.') .str.replace('-', '') .replace('', np.nan) .astype(float)) return df .... def ML(mode): conn = sqlite3.connect('../MachineLearning.db') query = "SELECT SCADENZA,PORTAF,TIPO_CR,LAG,TIPO_DOCUMENTO,TIPO_FF,FACTOR,PERC,NETTOSPLIT,IMPORTO1,IMPORTO2,DATA_INVIO_FILE FROM Dati" # Assuming TARGET is also in this query df = pd.read_sql_query(query, conn) conn.close() numerical_features = ['PERC', 'NETTOSPLIT', 'IMPORTO1', 'IMPORTO2'] df = clean_numeric(df, numerical_features) numerical_features.extend(['SCADENZA', 'DATA_INVIO_FILE']) categorical_features = ['PORTAF', 'TIPO_CR', 'LAG', 'TIPO_DOCUMENTO', 'TIPO_FF', 'FACTOR'] .....Olltre ad aver aggiungo la scrittura dei csv per alcuni punti per vedere i dati come vengono elaborati. Allego il codice completo. Purtroppo continua ad andare Overfitting. Sto analizzando i dati elaborati, per capire: Cosa Estrae Come li "Converte" Su cosa si Addestra e cosa mi tira fuori alla fine dell'addestramento Nel mentre tu hai qualche altro consiglio da potermi fornire ?

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')

non conoscendo il contesto, con le informazioni che hai fornito, potrei pensare ad una codificazione di errori, e tempi ma in quel caso ci dovrebbe essere una sequenza "parlata"... della serie, primi ttt.code = tempo secondi zzz.code= classe errore terzi yyy.code = tipo di errore... vi saranno delle conversioni da qualche parte, se è una macchina vi sarà un libretto tecnico.... ecc...

1. Le sequenze numeriche sono diverse tra loro, ma alcuni valori possono essere presenti nelle sequenze successive, ma per qualche ragione a noi attualmente sconosciuta riusciamo a ridurre i probabili valori successivi con il metodo sopra descritto; 2. Andrebbero esclusi solo alcuni, ma non conoscendo l'algoritmo che vi è in questa "black box", non sappiamo quale sia. La sequenza è una specie di "firma", che indica lo stato attuale della macchina, come fosse un indice, ma non è criptografato; 3. Infatti non ha una logica conosciuta, ma questa condizione di esclusione di alcune sequenze precedenti è ripetibile in tutta la storicizzazione di questi valori; Spero di aver fatto luce ai tuoi quesiti.

Per quanto riguarda "prepare_data", cosa dovrebbe contenere? In quale forma dovrei preparare i dati? Immagino che X_train dovrebbe contenere una lista la cui dimensione è tipo 2000 array dove ogni array contiene a sua volta 140 array di sequenze numeriche (12 numeri appunto), mentre Y_train dovrebbe contenere un array di 2000 array dove ogni array contiene una sequenza 140 valori booleani. Corretto? Ma X_test e Y_test?

Per quanto riguarda i dati, non sappiamo quale sia l'algoritmo generato dal sistema, poichè come abbiamo detto prima, è un sistema chiuso, dal quale preleviamo dati da esso. Sapere però quali potrebbero essere i valori probabili in uscita, considerando un insieme ridotto, ci permetterebbe di integrare una elaborazione successiva su di essi più rapido ed in anticipo.

Caro Marco, Non puoi neanche lontanamente immaginare quanto mi sia di aiuto il tuo commento. Non avrei mai immaginato di ricevere una benchè minima risposta, tantomeno in meno di 2 ore! Considera che ho chiesto in molti altri forum indicazioni su questo problema, e pensa che nessuno mi aveva mai risposto. Non solo mi hai risposto, ma sei stato in grado di darmi dei punti di vista differenti e di questo te ne sono immensamente grato. Oggi pomeriggio inizio a metterci mano e vi aggiorno sugli sviluppi, perchè ce ne saranno. Grazie davvero.

Buongiorno Romeo, La sua analisi è più che corretta. Forse però un paio di precisazioni possono esserci d’aiuto. Ogni articolo è presente solo in una commessa e la lavorazione successiva (sempre la stessa, ovvero la piegatura) è registrata per ogni singolo articolo con un inizio ed una fine. Non ho mai approfondito questa possibilità di calcolo perché non ho idea di come tecnicamente sia possibile fornire l’informazione al motore di calcolo che un prodotto appartenga ad una commessa senza utilizzare un hothandler che creerebbe un infinità di nuove colonne. Riuscirebbe ad aiutarmi in questo aspetto? Perché “sbloccando” questa possibilità allora le opzioni disponibili si ampliano notevolmente! Grazie mille per il tempo che mi sta dedicando!

Una elaborazione non può che partire dai dati, se si hanno a disposizioni dati, si può cercare di fare delle previsioni sulle lavorazioni. Io credo che ogni articolo possa avere degli attributi (lavorazioni), gli ordini, possono contenere una eterogenia di articoli, il problema quindi si pone, qualora un articolo, subisse una diversificazione di lavorazioni in riferimento alla commessa, in altre parole, una articolo "A" (semilavorato o meno) subisce X lavorazioni prima di essere evaso nella commessa C, lo stesso articolo però potrebbe subire Y lavorazioni nella commessa C1. In questo caso non credo sia possibile giungere ad una elaborazione affidabile dei dati. Se ad ogni articolo si associano sempre le stesse lavorazioni, allora le cose potrebbero essere messe in relazione, su un database, ovviamente bisogna avere dei dati coerenti con quella tipologia di catalogazione dei dati. Una delle parti più difficili nell'utilizzo del machine learning credo consista proprio nella preparazione dei dati, questo potrebbe essere un caso tipico.

Salve e benvenuto nel forum! Per affrontare il tuo problema di previsione dei tempi di lavorazione degli ordini utilizzando il deep learning, ci sono diverse strategie e considerazioni da tenere in considerazione. 1. Preprocessing dei dati: Prima di alimentare i dati alla rete neurale, è importante eseguire un buon preprocessing per preparare i dati in modo ottimale. Questo può includere la normalizzazione dei dati per ridurre la scala dei valori e rendere più semplice il processo di apprendimento della rete neurale. Ecco un esempio di come potresti normalizzare i tuoi dati utilizzando la libreria scikit-learn in Python: from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) 1. Architettura della rete neurale: La scelta dell'architettura della rete neurale è cruciale per il successo del modello. Nel tuo caso, potresti considerare l'utilizzo di reti neurali ricorrenti (RNN) o reti neurali convoluzionali (CNN) in combinazione con strati densi per gestire la sequenzialità dei dati temporali e le caratteristiche spaziali dei dati, rispettivamente. Ecco un esempio di come potresti definire una semplice rete neurale usando TensorFlow e Keras: import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dense model = Sequential([ LSTM(64, input_shape=(X_train.shape[1], X_train.shape[2])), Dense(1) ]) 1. Ottimizzatori e funzioni di perdita: La scelta dell'ottimizzatore e della funzione di perdita può avere un impatto significativo sulle prestazioni del modello. Puoi sperimentare con diversi ottimizzatori come Adam, RMSprop o SGD e diverse funzioni di perdita come la mean squared error (MSE) o la mean absolute error (MAE). Ecco un esempio di come potresti compilare il modello con l'ottimizzatore Adam e la funzione di perdita MSE: model.compile(optimizer='adam', loss='mse') 1. Utilizzo dei dati degli articoli: Hai menzionato di avere dati su ogni singolo articolo contenuto nella commessa. Questi dati possono essere utilizzati per arricchire il set di dati della tua rete neurale. Ad esempio, potresti considerare l'aggiunta di features come il tipo di materiale utilizzato, la complessità dell'articolo, o altre caratteristiche rilevanti che potrebbero influenzare i tempi di lavorazione. 1. Iperparametri della rete neurale: Gli iperparametri sono parametri esterni al modello che influenzano le prestazioni e la complessità del modello. Alcuni esempi di iperparametri per una rete neurale includono il numero di neuroni in ogni strato, il tasso di apprendimento dell'ottimizzatore, il numero di epoche di addestramento, il batch size, e così via. Trovare i valori ottimali per questi iperparametri è fondamentale per ottenere prestazioni ottimali dal tuo modello. # Esempio di definizione degli iperparametri num_neurons_layer1 = 64 num_neurons_layer2 = 64 learning_rate = 0.001 batch_size = 32 epochs = 50 La ricerca degli iperparametri può essere effettuata attraverso tecniche come il grid search, che esamina diverse combinazioni di iperparametri per trovare la migliore. Di seguito un esempio di come puoi implementare il grid search con scikit-learn: from sklearn.model_selection import GridSearchCV from tensorflow.keras.wrappers.scikit_learn import KerasRegressor # Funzione per creare il modello def create_model(num_neurons_layer1=64, num_neurons_layer2=64, learning_rate=0.001): model = Sequential([ LSTM(num_neurons_layer1, input_shape=(X_train.shape[1], X_train.shape[2]), return_sequences=True), Dropout(0.2), LSTM(num_neurons_layer2, return_sequences=False), Dense(1) ]) optimizer = Adam(learning_rate=learning_rate) model.compile(loss='mse', optimizer=optimizer) return model # Creazione del modello Keras per scikit-learn keras_model = KerasRegressor(build_fn=create_model, epochs=epochs, batch_size=batch_size, verbose=0) # Definizione della griglia degli iperparametri param_grid = { 'num_neurons_layer1': [32, 64, 128], 'num_neurons_layer2': [32, 64, 128], 'learning_rate': [0.001, 0.01, 0.1] } # Creazione dell'oggetto GridSearchCV grid_search = GridSearchCV(estimator=keras_model, param_grid=param_grid, scoring='neg_mean_squared_error', cv=3) grid_result = grid_search.fit(X_train, y_train) # Stampa dei risultati del grid search print("Best MSE: {:.4f} using {}".format(grid_result.best_score_, grid_result.best_params_)) In questo esempio, vengono definite diverse combinazioni di iperparametri nella griglia param_grid. La funzione create_model crea un modello Keras con gli iperparametri specificati. L'oggetto GridSearchCV cerca la combinazione ottimale di iperparametri attraverso la validazione incrociata. I risultati, inclusi il miglior punteggio e i migliori parametri, vengono stampati alla fine. Ecco un esempio di come potresti strutturare il tuo codice utilizzando TensorFlow e Keras: import tensorflow as tf from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dense, Dropout from tensorflow.keras.optimizers import Adam # Definizione dell'architettura della rete neurale model = Sequential() model.add(LSTM(64, input_shape=(sequence_length, num_features), return_sequences=True)) model.add(Dropout(0.2)) model.add(LSTM(64, return_sequences=False)) model.add(Dense(1)) # Compilazione del modello optimizer = Adam(learning_rate=0.001) model.compile(loss='mse', optimizer=optimizer) # Addestramento del modello history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_val, y_val)) # Valutazione del modello loss = model.evaluate(X_test, y_test) print("Test Loss:", loss) # Utilizzo del modello per fare previsioni predictions = model.predict(X_test) In questo esempio, si crea un modello sequenziale con due strati LSTM seguiti da un layer densamente connesso per l'output. Si utilizza l'ottimizzatore Adam con una learning rate di 0.001 e la funzione di perdita MSE. Successivamente, il modello viene addestrato sui dati di addestramento per 50 epoche con un batch size di 32, utilizzando i dati di validazione per monitorare le prestazioni durante l'addestramento. Il modello viene valutato sui dati di test e utilizzato per fare previsioni. Assicurati di adattare questo esempio ai tuoi dati specifici, modificando la forma degli input e degli output del modello e scegliendo l'architettura, l'ottimizzatore e la funzione di perdita più adatti al tuo problema. Buona fortuna!

Un commento "al volo", a mio parere, sarebbe meglio trovare un sistema per fornire degli esempi di lavorazione, partendo da tempistiche singole, ricavate da codice pezzo, dove il pezzo può contenere anche altri dati, tipo lunghezza profilo o rapporto profilo area, lamiera spessore. In qualsiasi caso, dei parametri che possano essere combinati per ricavare una velocità.

Probabilmente hai un contatore che non è ben dimensionato, attenzione che gli indici partono da 0 e non da 1.... stai iterando con un indice che raggiunge un numero che non rientra nell'indice della lista... da quello che riesco ad interpretare, l'indice j di una delle tre liste, oltrepassa il limite. Sappimi dire...

Ok eccolo: Last login: Sat Apr 16 16:29:33 on ttys000 iMac-di-Ezio:~ eziopagliarino$ cd '/Users/eziopagliarino/Desktop/Sistema esperto MODIFICATO/' && '/usr/local/bin/python3' '/Users/eziopagliarino/Desktop/Sistema esperto MODIFICATO/medical_expert_system.py' && echo Exit status: $? && exit 1 Ciao! Sono qui per aiutarti a migliorare la tua salute. Per questo dovrai rispondere ad alcune domande sulle tue condizioni Accusi qualcuno dei seguenti sintomi ?: Fatica: no Bassa temperatura corporea: no Tosse: no Occhi infossati: si Irrequietezza: si Svenimento: no Dolore al petto: si Febbre: no Mal di gola: si Nausea: si Visione offuscata: si Mal di testa: si Mal di schiena: no Non ho trovato alcuna malattia che corrisponda ai tuoi sintomi esatti Traceback (most recent call last): File "/Users/eziopagliarino/Desktop/Sistema esperto MODIFICATO/medical_expert_system.py", line 228, in engine.run() # Run it! File "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/experta/engine.py", line 165, in run activation.rule( File "/Library/Frameworks/Python.framework/Versions/3.8/lib/python3.8/site-packages/experta/rule.py", line 87, in __call__ return self._wrapped(*args, **kwargs) File "/Users/eziopagliarino/Desktop/Sistema esperto MODIFICATO/medical_expert_system.py", line 215, in not_matched if(temp_list[j] == lis[j] and lis[j] == "si"): IndexError: list index out of range iMac-di-Ezio:Sistema esperto MODIFICATO eziopagliarino$

Quando vuoi, sai che qualche dritta, se ci riesco te la posso indicare, tieni presente che, forse, per fare ciò da te richiesto, l percorso è lungo e dovrai approcciarti a TensorFlow, Keras, Pandas e ad altri moduli basilari per il trattamento dei dati e delle immagini. In questo senso, potresti prendere una spunto ad esempio da qui: https://amslaurea.unibo.it/17606/1/tesi.pdf