Attenzione, in Firefox il codice esce tradotto in italiano....

Infatti...

Ciao Martina, grazie mille per quanto hai scritto. Vorrei allenare un modello BERT sul testo biblico (il Dataset ce l'ho) per poi chiedergli di completare delle frasi tratte da una parte di testo biblico sul quale non si è allenato. Vorrei poi analizzare le sue risposte tramite XAI (individuando risposte alternative sulla base di counterfactual explanation) per individuare dei pattern che mi aiuterebbero a comprendere il comportamento delle parole in base al contesto in cui si trovano. Vorrei poi rendere il tutto disponibile attraverso un'interfaccia web. Ho controllato non sembra esserci nulla sul testo biblico

Sarà che sto diventando vecchio e non ho più l'intuito che serve per capire bene il contesto del discorso, ma ci sono delle cose che non mi sono chiare: se l'obbiettivo è quello di calcolare i tempi di lavorazione in base ad un ordine, ci sono dei dati che servono alla elaborazione e dei dati "etichetta", che servono solo come riferimento. I dati che sono variabili nel processo di lavoro sono, se non ho capito male: Numero e tipologia dei fogli contestuali all'ordine, che avranno dimenzioni x e y standard (lamiere) e z (spessore) variabile in relazione ai pezzi da produrre per quell'ordine. Le componenti che costituiscono le variabili inerenti il lavoro quindi sono riferibili ad una classificazione dei pezzi in relazione allo spessore. Lo spessore determina la velocità di avanzamento dell'utensile. spessori diversi = velocità diverse. La lavorazione di un pezzo dipende dalla lunghezza del perimetro di taglio e dallo spessore della lamiera. quindi, il tempo impiegato per la lavorazione, dipende dal numero di pezzi classificati, per dimensioni e per tipologia. in altre parole: lamiere tipo 1 => velocità 1v lamiere tipo 2 => velocità 2v ... pezzi tipo P1A, P1B, P1C.... P1N.. pezzi diversificati per perimetro ma appartenenti alla classe delle lamiere tipo 1 pezzi tipk P2A, P2B, P2C ... pezzi diversificati per perimetro ma appartenenti alla classe delle lamiere tipo 2 ecc. il nesting si ottiene mediante un software CAM (Computer Aided Manufacturing, produzione assistita da computer) che crea strutture nidificate ("nest") e prepara le parti per il taglio. Il nesting è il processo che consente di posizionare in modo efficiente più forme in un'area di superficie specificata. Pertanto, la soluzione migliore è la creazione di strutture di nesting per raggruppare il maggior numero possibile di parti. Questo processo massimizza l'utilizzo, diminuisce gli sprechi e riduce al minimo i costi dei materiali, quindi se noi abbiamo il percorso di nesting per un ordine riferito alle lamiere, dovremmo avere anche il tempo netto di lavorazione della macchina. Sino a qui la mia analisi è valida?

In linea di massima non è cambiato molto, però, se si vuole sfruttare al meglio le possibilità di una chat-bot, non legato espressamente ad un LLM, a mio avviso, in questo momento, la miglior piattaforma per effettuare un salto di qalità in questo ambito è senza dubbio : https://github.com/cheshire-cat-ai Per un approfondimento su questo tema, consiglio inoltre un mio testo introduttivo, disponibile anche in formato digitale:

Ciao Romeo, sono riuscito a trovare alcuni sistemi esperti in python qui: https://github.com/topics/pyknow ed è esattamente quello che desideravo perchè posso sperimentare cambiamenti ed ottenere quello che mi aspettavo. Sono felice per questo. A presto con nuove notizie....(se non ti disturbo) Ezio

XML è un linguaggio di markup utilizzato per rappresentare e distribuire strutture di dati che possono essere spesso difficili da creare utilizzando formati tabulari più standard. Fondamentalmente, il formato XML è simile all'HTML (che è un altro linguaggio di markup, appunto), in quanto i dati sono organizzati in elementi, che definiscono il tipo di informazioni esposte, e ogni elemento contiene il valore effettivo sotto forma di contenuto o attributi. La pagina XML su Wikipedia offre una n visione completa di tutti i dettagli e aspetti tecnici di questo formato, ma i concetti chiave sono semplici. Ogni informazione è delimitata da un tag specifico, come questo: john@mail.com A 16 alice@mail.com B 17 bob@mail.com < / email> C 16 hannah@mail.com A 17 In questo esempio, ogni studente è rappresentato da un elemento, che ha un nameattributo contenente il nome di uno studente specifico. Ciascuno di questi elementi ha quindi sottoelementi definiti dai tag , e ; tra questi tag è presente il contenuto effettivo dei dati riferiti allo studente dato. Supponiamo che questi dati vengano salvati in un file XML chiamato "students.xml". Possiamo pensare a questa struttura come a un DataFrame panda in cui ogni studente rappresenta un'osservazione, con il suo nameattributo che è l'identificatore principale e i sottoelementi sono altre caratteristiche dell'osservazione. Una rappresentazione tabulare di questi dati sarebbe come questa: Quindi vogliamo trovare un modo per convertire i dati strutturati in XML in una tabella più funzionale. Data la struttura dei file XML, possiamo rappresentarli come un albero, e questo è l'approccio utilizzato dal modulo xml.etree.ElementTree Python. L'analisi del nostro file "students.xml" inizia dalla radice dell'albero, ovvero l' elemento, che contiene l'intera struttura dati. import xml.etree.ElementTree as et xtree = et.parse("students.xml") xroot = xtree.getroot() Ora possiamo iterare attraverso ogni nodo dell'albero, il che significa che otterremo ogni elemento studente e prenderemo il suo nameattributo e tutti i suoi sottoelementi per costruire il nostro dataframe. for node in xroot: s_name = node.attrib.get("name") s_mail = node.find("email").text s_grade = node.find("grade").text s_age = node.find("age").text Per ottenere l' nameattributo utilizziamo la attrib.get()funzione, mentre il contenuto testuale di ogni elemento può essere recuperato utilizzando la find()funzione dei nodi. Ogni iterazione restituirà un set di dati che può essere pensato come un'osservazione in un DataFrame panda; possiamo costruire questa procedura come segue: import pandas as pd import xml.etree.ElementTree as et xtree = et.parse("students.xml") xroot = xtree.getroot() df_cols = ["name", "email", "grade", "age"] rows = [] for node in xroot: s_name = node.attrib.get("name") s_mail = node.find("email").text if node is not None else None s_grade = node.find("grade").text if node is not None else None s_age = node.find("age").text if node is not None else None rows.append({"name": s_name, "email": s_mail, "grade": s_grade, "age": s_age}) out_df = pd.DataFrame(rows, columns = df_cols) Lo svantaggio di questo approccio è che devi conoscere in anticipo la struttura del file XML e devi codificare i nomi delle colonne di conseguenza. Possiamo provare a convertire questo codice in una funzione più utile e versatile, senza dover codificare alcun valore: import pandas as pd import xml.etree.ElementTree as et def parse_XML (xml_file, df_cols): "" "Analizza il file XML di input e memorizza il risultato in un DataFrame panda con le colonne indicate. Il primo elemento di df_cols dovrebbe essere la variabile identificatore , che è un attributo di ogni elemento del nodo nei dati XML; altre caratteristiche verranno analizzate dal contenuto di testo di ogni sottoelemento. "" " xtree = et.parse(xml_file) xroot = xtree.getroot() rows = [] for node in xroot: res = [] res.append(node.attrib.get(df_cols[0])) for el in df_cols[1:]: if node is not None and node.find(el) is not None: res.append(node.find(el).text) else: res.append(None) rows.append({df_cols[i]: res[i] for i, _ in enumerate(df_cols)}) out_df = pd.DataFrame(rows, columns=df_cols) return out_df Un pezzo di codice interessante è la comprensione dei dettami in: {df_cols [i]: res [i] for i, _ in enumerate (df_cols)} dove viene creato un dizionario nel nome della colonna del modulo: il valore del nodo e aggiunto all'elenco delle righe. Questi verranno infine utilizzati per creare il dataframe completo. Utilizziamo ora la funzione parse_XML("students.xml", ["name", "email", "grade", "age"]) Questa è un'implementazione più efficiente della funzione di analisi XML, sebbene abbiamo ancora bisogno di conoscere la struttura di base del documento XML di input che vogliamo analizzare. Grazie per aver fatto qui la tua domanda, fammi sapere se funziona.

Eccoci qui 🤗 Non preoccuparti fai benissimo a fare queste domande, ci teniamo molto a fornire solo materiale di qualità e funzionante. Allora è stato molto complesso trovare tutte le dipendenze precise ma ce l'abbiamo fatta. Copia e incolla queste righe al posto delle celle prima di "from imageai.Detection import ObjectDetection" !pip install tensorflow==2.4.0 !pip install keras==2.4.3 numpy==1.19.3 pillow==7.0.0 scipy==1.4.1 h5py==2.10.0 matplotlib==3.3.2 opencv-python keras-resnet==0.2.0 !pip install imageai --upgrade il risultato finale dovrà essere questo : Facci sapere se il problema è risolto 😉

Allora ecco il codice completo per colab : !pip install basemap e poi import numpy as np import pandas as pd import matplotlib.pyplot as plt import datetime import time from mpl_toolkits.basemap import Basemap from keras.models import Sequential from keras.layers import Dense from keras.wrappers.scikit_learn import KerasClassifier import tensorflow as tf from sklearn.model_selection import GridSearchCV #read data data = pd.read_csv("/content/Dataset_Terremoti.csv") data = data[['Date', 'Time', 'Latitude', 'Longitude', 'Depth', 'Magnitude']] data.head() #preprocessing dati timestamp = [] for d, t in zip(data['Date'], data['Time']): try: ts = datetime.datetime.strptime(d+' '+t, '%m/%d/%Y %H:%M:%S') timestamp.append(time.mktime(ts.timetuple())) except ValueError: # print('ValueError') timestamp.append('ValueError') timeStamp = pd.Series(timestamp) data['Timestamp'] = timeStamp.values final_data = data.drop(['Date', 'Time'], axis=1) final_data = final_data[final_data.Timestamp != 'ValueError'] final_data.head() #display data m = Basemap(projection='mill',llcrnrlat=-80,urcrnrlat=80, llcrnrlon=-180,urcrnrlon=180,lat_ts=20,resolution='c') longitudes = data["Longitude"].tolist() latitudes = data["Latitude"].tolist() #m = Basemap(width=12000000,height=9000000,projection='lcc', #resolution=None,lat_1=80.,lat_2=55,lat_0=80,lon_0=-107.) x,y = m(longitudes,latitudes) fig = plt.figure(figsize=(12,10)) plt.title("All affected areas") m.plot(x, y, "o", markersize = 2, color = 'blue') m.drawcoastlines() m.fillcontinents(color='coral',lake_color='aqua') m.drawmapboundary() m.drawcountries() plt.show() #train and test data X = final_data[['Timestamp', 'Latitude', 'Longitude']] y = final_data[['Magnitude', 'Depth']] from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) print(X_train.shape, X_test.shape, y_train.shape, X_test.shape) from keras.models import Sequential from keras.layers import Dense def create_model(neurons, activation, optimizer, loss): model = Sequential() model.add(Dense(neurons, activation=activation, input_shape=(3,))) model.add(Dense(neurons, activation=activation)) model.add(Dense(2, activation='softmax')) model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy']) return model #find best parameters model = KerasClassifier(build_fn=create_model, verbose=0) #neurons = [16, 64, 128, 256] neurons = [16] #batch_size = [10, 20, 50, 100] batch_size = [10] epochs = [10] # activation = ['relu', 'tanh', 'sigmoid', 'hard_sigmoid', 'linear', 'exponential'] activation = ['sigmoid', 'relu'] # optimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam'] optimizer = ['SGD', 'Adadelta'] loss = ['squared_hinge'] param_grid = dict(neurons=neurons, batch_size=batch_size, epochs=epochs, activation=activation, optimizer=optimizer, loss=loss) #GridSearchCV grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1, cv=3) #convert from Numpy array to tensor X_train = X_train.values.astype('float32') y_train = y_train.values.astype('float32') X_test = X_test.values.astype('float32') y_test = y_test.values.astype('float32') grid_result = grid.fit(X_train, y_train) #sequential model model = Sequential() model.add(Dense(16, activation='relu', input_shape=(3,))) model.add(Dense(16, activation='relu')) model.add(Dense(2, activation='softmax')) model.compile(optimizer='SGD', loss='squared_hinge', metrics=['accuracy']) model.fit(X_train, y_train, epochs=10, batch_size=10, verbose=1) #test score = model.evaluate(X_test, y_test, batch_size=10) print(score) FACCI SAPERE SE FUNZIONA :)

Ciao Romeo, sono nuovamente a chiederti un aiuto. Ho fatto alcuni esperimenti su un sistema esperto medico aggiungendo una malattia con relativi sintomi ma purtroppo mi da sempre errore che non riesco a capire. Ho semplicemente aggiunto una regola e la relativa nuova malattia. Ti allego il dettaglio dell'errore. Purtroppo non riesco a caricare i due script python. Chiedo scusa ma non riesco a venirne a capo. Grazie

Partire da una black box, per estrarre delle previsioni direi che, se non si hanno cognizioni su chi genere l'output, è come giocare con dei pseudorandom. Come dire fare dei calcoli sulla previsione del gioco del Lotto, conoscendo quali sono state le vincite in passato. La mia domanda è quindi: sicuri che i numeri estratti debbano essere diversi da quelli estratti precedentemente? in qualsiasi caso, vi può essere una logica nascosta? < Io e il mio Team avremmo bisogno di prevedere la sequenza successiva, analizzando le sequenze precedenti.> ... escludendole? le sequenze, contengono dei dati temporali... criptografati? Su che cosa devo interpretare la frase < Ma sappiamo che è impossibile. Ma noi abbiamo trovato una "sorta" di logica.> che, per me risuona come una contraddizione logica? Io potrei dire che in questo caso, la statistica non aiuta e faccio riferimento a questo: http://progettomatematica.dm.unibo.it/Prob2/2calcolocombinatorio.html in qualsiasi caso, ma solo per ragioni tecniche, suggerisco questo: https://it.mathworks.com/discovery/lstm.html Buona fortuna.

Eccoci 🤗 Allora se usi google colab prova questo codice : #solo per google colab from google.colab.patches import cv2_imshow import cv2 cars_cascade = cv2.CascadeClassifier('haarcascade_car.xml') def detect_cars(frame): cars = cars_cascade.detectMultiScale(frame, 1.15, 4) for (x, y, w, h) in cars: cv2.rectangle(frame, (x, y), (x+w,y+h), color=(0, 255, 0), thickness=2) return frame def Simulator(): CarVideo = cv2.VideoCapture('cars.mp4') while CarVideo.isOpened(): ret, frame = CarVideo.read() controlkey = cv2.waitKey(1) if ret: cars_frame = detect_cars(frame) #se stai programmando in locale #cv2.imshow('frame', cars_frame) #se usi colab cv2_imshow(cars_frame) else: break if controlkey == ord('q'): break CarVideo.release() cv2.destroyAllWindows() Simulator() Facci sapere se così funziona 😊

Ciao! non sono un ssuper esperto di IA ma ho fattto diversi corsi con intelligenzaartificialeitalia.net e provo a rispondere alla tua domanda sperando di essere di aiuto. Partendo dal fatto che la tua richiesta è piuttosto complessa e richiede una soluzione avanzata di deep learning. Ecco qualche consiglio che posso fornirti alcune linee guida su come affrontare il problema utilizzando Python e librerie di deep learning come TensorFlow o PyTorch. ( Sulla base delle mie esperienze passate ) 1. Preparazione dei dati - Converti le sequenze esadecimali in array numerici per facilitare l'elaborazione. - Crea un dataset di addestramento e di test suddividendo i dati storici disponibili. - Normalizza i dati per migliorare le prestazioni del modello. ( Questo passaggio non è obbligatorio ma ti consiglio di fare dei test ) Come dicono sempre i ragazzi di IntelligenzaArtificialeItalia.net lo sviluppo di applicativi come questi è pura ricerca ! 2. Testare un Modello di sequenza - Poiché si tratta di un problema di previsione di sequenze, potresti considerare l'utilizzo di reti neurali ricorrenti (RNN) come le LSTM (Long Short-Term Memory) o le GRU (Gated Recurrent Unit). - Queste architetture sono particolarmente adatte per elaborare sequenze di dati e apprendere le dipendenze a lungo termine tra gli elementi. 3. Architettura del modello ( Complessa da stimare su due piedi, solitamente ci vogliono settimane di test ) - L'architettura potrebbe consistere in uno strato di input che accetta le sequenze di 140 insiemi di 12 valori. - Questo strato di input potrebbe essere collegato a uno o più strati LSTM o GRU per elaborare le sequenze. - L'output del modello dovrebbe essere un array di 140 valori booleani che rappresentano la previsione per la sequenza successiva. 4. Addestramento del modello - Utilizza l'algoritmo di backpropagation attraverso il tempo (BPTT) per addestrare il modello sui dati storici. - Ottimizza una funzione di perdita appropriata, come la cross-entropy binaria per le previsioni booleane. - Applica tecniche come il dropout e la regolarizzazione per evitare l ov.erfitting. Ecco un esempio di codice Python semplificato che potrebbe essere un punto di partenza: --- import numpy as np from tensorflow.keras.models import Sequential from tensorflow.keras.layers import LSTM, Dense # Preparazione dei dati X_train, y_train, X_test, y_test = prepare_data(historical_data) # Definizione del modello model = Sequential() model.add(LSTM(64, input_shape=(140, 12))) model.add(Dense(140, activation='sigmoid')) # Compilazione del modello model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) # Addestramento del modello model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test)) # Previsione su nuovi dati new_sequence = np.array([[...]]) # Preparazione dei nuovi dati prediction = model.predict(new_sequence) --- Questo è solo un esempio di base e richiederà sicuramente ulteriori ottimizzazioni e personalizzazioni per adattarsi ai tuoi dati specifici e ai requisiti di prestazioni. Per aiutarti sarebbe utile avere più informazioni sul sistema e sui dati disponibili per migliorare l'accuratezza del modello. Ad esempio, se ci sono eventuali pattern noti o proprietà delle sequenze che potrebbero essere sfruttate come caratteristiche aggiuntive. Comunque il problema che hai descritto è fattibile da affrontare utilizzando tecniche di deep learning, ma richiede una comprensione approfondita dei dati e delle architetture di rete neurale appropriate. Spero di essere stato un minimo di aiuto 🙏

Bhe si in effetti trovare un modello allenato su testi biblici è un po difficile, però hugging face ti permette di allenare i modelli con i tuoi dati Come puoi vedere in alto a destra trovi un bottoncino TRAIN per ogni modello esistente. Segui questa guida fatto molto bene , che mi ha aiutato ad allenare il mio primo modello tramite hugging face. -> https://huggingface.co/blog/how-to-train

Buonasera Romeo, la sua analisi è corretta, tranne che per noi lo spessore è uno solo quindi i pezzi sono tutti all'interno delle lamiere tipo 1. Il nostro plasma fa il nesting, ma oltre al taglio ci sono molte altre lavorazioni successive che allungano i tempi di completamento dell'ordine. L'ideale sarebbe non calcolare le tempistiche non dalla commessa ma dal singolo ordine, ma non ho la minima idea di come creare un machine learning che "veda" l'ordine come un insieme di articoli, per questo ho cercato questa via. Grazie mille per il tempo che mi ha dedicato per questa risposta!