Buongiorno,

anzitutto grazie per le risposte. Ho tentato le soluzioni proposte ma il risultato rimane comunque alto, sicuramente a causa della scarsa quantità di dati in mio possesso al momento (solo 300).

L'idea di inserire i pezzi nel motore di ML è molto interessante, ma non saprei come inserirli in quanto non ho un tempo di produzione per ogni singolo articolo, ma solo dell'intero ordine. Il nostro processo è il seguente: Commessa (che contiene più ordini - tutti con lo stesso inizio) > Ordini (Inizi uguali per commessa - Fine diverse) > Articoli (Ciascuno inserito in una commessa ed appartenente ad un ordine).

Vorrei creare una tabella contenente gli articoli (circa 10000) in cui sono presenti:

• Orario di inizio (preso da Commessa)

• Orario di fine (preso da ordine - uguale per tutti gli articoli del medesimo ordine)

• Tutti i dati del singolo artcolo

• Numero di commessa

Però mi si pongono due problemi, ovvero:

• Il numero di commessa dovrebbe essere un valore categoriale, ma trattandolo come un one_hot_encoded_data avrei 300 colonne in più e non credo siano funzionali

• Posto che questo ragionamento funzioni, per fare una previsione corretta dovrei inserire nel motore di previsione tutti gli articoli che vorrei inserire in una commessa, ma come si fa a dare al motore più righe in contemporanea?

Grazie a chi mi vorrà aiutare!

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à.