Ciao, grazie mille per averci scritto 🤗 Allora per quanto riguarda il funzionamento del programma da noi proposto ci sono diversi motivi per il quale potrebbe non funzionare, ad esempio il sistema operativo installato... Comunque se sei interessato ad un programmino semplice, che possa girare su windows, non esitare a mandarci una email a python.ai.solution@gmail.com. Ti scriveremo una piccola demo gratuita da far girare anche online se ti dovesse servire . Per quanto riguarda il servizio intelligente sul Trading, capita spesso ultimamente che vada in crash per il troppo traffico. Quando ti fa la rotellina di caricamento non esitare a mandarci una mail o usare la chat del sito per dircelo, risolveremo al più presto. Al momento abbiamo ripristinato il servizio, facci sapere se riesci ad ad accedere. Grazie ancora per averci scritto e scusaci il disagio causato dal momentaneo mancato servizio intelligente del nostro sito 🤗 Per qualsiasi altro problema non esitare ad aprire un altra discussione sul forum o a contattarci direttamente, speriamo di esserti stati di aiuto 🤗

Cosa dire, grazie Martina e grazie Moderatori di I.A. Italia! Ho provato il SaaS ed è davvero carino ed ha già tutte le aggiunte che avrei voluto farci, ha funzionato benissimo e velocissimo. Anche il codice di Martina mi potrà essere molto utile, naturalmente dovrò studiare un bel po' prima di capirci davvero qualcosa ma già adesso, grazie a questi 2 esempi, ho le idee molto più chiare su come funziona questa tecnica. Grazie davvero per la disponibilità ed a presto! Mario

Attenzione, lo Stregatto, è disponibile anche senza installare nulla, ma devi far parte della community Discord, Se segui le istruzioni per la installazione in locale, hai bisogno di Docker, come supporto, che in definitiva è la via più semplice. In qualsiasi caso, sono a disposizione per eventuali altre comunicazioni.

Grazie mille!

Ciao Elia, ultimamente anche io mi sono appassionata alla Xai. Da quando ne ho letto su questo sito : https://www.intelligenzaartificialeitalia.net/post/intelligenza-artificiale-spiegabile-come-spiegare-un-modello-al-tuo-capo Per quanto riguarda l'implementazione di un modello BERT ti consiglio vivamente di usare quelli disponibili su HuggingFace, troverai oltre 8mila modelli già allenati, sicuramente ci sarà quello che cerchi. ( https://huggingface.co/models?search=bert ) Per implementare un qualsiasi modello ti serviranno solo 3 righe di codice from transformers import pipeline >>> unmasker = pipeline('fill-mask', model='bert-base-uncased') >>> unmasker("Hello I'm a [MASK] model.") [{'sequence': "[CLS] hello i'm a fashion model. [SEP]", 'score': 0.1073106899857521, 'token': 4827, 'token_str': 'fashion'}, {'sequence': "[CLS] hello i'm a role model. [SEP]", 'score': 0.08774490654468536, 'token': 2535, 'token_str': 'role'}, {'sequence': "[CLS] hello i'm a new model. [SEP]", 'score': 0.05338378623127937, 'token': 2047, 'token_str': 'new'}, {'sequence': "[CLS] hello i'm a super model. [SEP]", 'score': 0.04667217284440994, 'token': 3565, 'token_str': 'super'}, {'sequence': "[CLS] hello i'm a fine model. [SEP]", 'score': 0.027095865458250046, 'token': 2986, 'token_str': 'fine'}] Più nello specifico cosa volevi fare ?

Notavo che le auto più piccole (più lontane) vengono riconosciute più facilmente (ma non tutte!!!!!) rispetto a quelle in primo piano più grandi...

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.

Forse questo codice può esserti utile è uno dei primi che ho trovato quando mi sono avvicinata all'I.A., anche io come te affascinata dalla semplicità di applicazione nell'ambito marketing e finanziario. import pandas as pd import numpy as np import matplotlib.pyplot as plt %matplotlib inline from matplotlib.pylab import rcParams rcParams['figure.figsize']=20,10 from keras.models import Sequential from keras.layers import LSTM,Dropout,Dense from sklearn.preprocessing import MinMaxScaler #carico file datase df=pd.read_csv("FileStoricoAzione.csv") df.head() df["Date"]=pd.to_datetime(df.Date,format="%Y-%m-%d") df.index=df['Date'] #grafico storico plt.figure(figsize=(16,8)) plt.plot(df["Close"],label='Storico prezzo di chiusura') #Ordino, filtro e normalizzo, data e chiusura. data=df.sort_index(ascending=True,axis=0) new_dataset=pd.DataFrame(index=range(0,len(df)),columns=['Date','Close']) for i in range(0,len(data)): new_dataset["Date"][i]=data['Date'][i] new_dataset["Close"][i]=data["Close"][i] scaler=MinMaxScaler(feature_range=(0,1)) final_dataset=new_dataset.values train_data=final_dataset[0:987,:] valid_data=final_dataset[987:,:] new_dataset.index=new_dataset.Date new_dataset.drop("Date",axis=1,inplace=True) scaler=MinMaxScaler(feature_range=(0,1)) scaled_data=scaler.fit_transform(final_dataset) x_train_data,y_train_data=[],[] for i in range(60,len(train_data)): x_train_data.append(scaled_data[i-60:i,0]) y_train_data.append(scaled_data[i,0]) x_train_data,y_train_data=np.array(x_train_data),np.array(y_train_data) x_train_data=np.reshape(x_train_data,(x_train_data.shape[0],x_train_data.shape[1],1)) #Costruisco il Modello neurale lstm_model=Sequential() lstm_model.add(LSTM(units=50,return_sequences=True,input_shape=(x_train_data.shape[1],1))) lstm_model.add(LSTM(units=50)) lstm_model.add(Dense(1)) inputs_data=new_dataset[len(new_dataset)-len(valid_data)-60:].values inputs_data=inputs_data.reshape(-1,1) inputs_data=scaler.transform(inputs_data) #compilo e alleno il modello lstm_model.compile(loss='mean_squared_error',optimizer='adam') lstm_model.fit(x_train_data,y_train_data,epochs=1,batch_size=1,verbose=2) #prendo un periodo di 60 giorni da predirre X_test=[] for i in range(60,inputs_data.shape[0]): X_test.append(inputs_data[i-60:i,0]) X_test=np.array(X_test) X_test=np.reshape(X_test,(X_test.shape[0],X_test.shape[1],1)) predicted_closing_price=lstm_model.predict(X_test) predicted_closing_price=scaler.inverse_transform(predicted_closing_price) #Salvo il modello allenato da poter riutilizzare o vendere lstm_model.save("modello_previsioni_azioni_da_1_milione_di_dollari.h5") #Grafico previsione train_data=new_dataset[:987] valid_data=new_dataset[987:] valid_data['Predictions']=predicted_closing_price plt.plot(train_data["Close"]) plt.plot(valid_data[['Close',"Predictions"]]) Per esempio prova ad usare questo file CSV Spero possa aiutarti nel tuo progetto, buona serata.😀

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

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?

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.

Ciao, sono Francesco project manager di IA Italia, interessante ! Puoi scriverci meglio della tua idea su assistenza@intelligenzaartificialeitalia.net

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 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 ?