: Se non sai cosa è il Machine Learning, clicca qui Se non conosci le principali applicazioni Machine Learning, clicca qui Se non sai come scaricare e gestire le librerie, clicca qui Se non sai cosa sia un Dataset, clicca qui Se non conosci i principali algoritmi di Machine Learning , clicca qui Se non Ho parlato di più di questo algoritmo qui. Che cos'è un algoritmo di aumento del gradiente?

Prerequisiti : Se non sai perchè utilizzeremo python, clicca qui Se non hai ancora installato Python, clicca qui Se non sai come scaricare e gestire le librerie, clicca qui Se non sai cosa sia un Dataset, clicca qui In questo articolo ti mostrerò come scrivere un programma python che prevede il prezzo delle azioni utilizzando una tecnica di apprendimento automatico chiamata Long Short-Term Memory (LSTM) . Questo programma è davvero semplice e dubito che da questo programma ne riusciare a trarre un profitto importante, ma è leggermente meglio che indovinare! Ricorda che il prezzo delle azioni può essere influenzato da molti parametri diversi. Lunga memoria a breve termine (LSTM) è una rete neurale artificiale ricorrente (RNN) utilizzato nel campo dell'apprendimento profonda. A differenza delle reti neurali feed forward standard, LSTM ha connessioni di feedback. Non solo può elaborare singoli punti dati (come le immagini), ma anche intere sequenze di dati . - Wikipedia Gli LSTM sono ampiamente utilizzati per i problemi di predizione di sequenza e si sono dimostrati estremamente efficaci. Il motivo per cui funzionano così bene è perché LSTM è in grado di memorizzare le informazioni passate che sono importanti e dimenticare le informazioni che non lo sono. -Stackabuse.com Iniziamo a programmare il nostro modello: Inizierò affermando cosa voglio che faccia questo programma. Voglio che questo programma preveda i prezzi delle azioni Apple Inc. 60 giorni nel futuro in base al prezzo di chiusura corrente. Per prima cosa scriverò una descrizione del programma. # Descrizione: questo programma utilizza una rete neurale artificiale ricorrente chiamata Long Short Term Memory (LSTM) per prevedere il prezzo di chiusura delle azioni di una società (Apple Inc.) utilizzando il prezzo delle azioni degli ultimi 60 giorni. Successivamente caricherò / importerò le librerie che verranno utilizzate in questo programma. import math import pandas_datareader as web import numpy as np import pandas as pd from sklearn.preprocessing import MinMaxScaler from keras.models import Sequential from keras.layers import Dense, LSTM import matplotlib.pyplot as plt plt.style.use('fivethirtyeight') Riceverò la quotazione delle azioni della società "Apple Inc." utilizzando il ticker di borsa delle società (AAPL) dal 1 gennaio 2012 al 17 dicembre 2019. #Ricevi la quotazione di borsa df = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17') #stampa le quotazioni df Output: High Low Open CloseVolumeAdj CloseDate 2012-01-0314.73214214.60714214.62142814.686786302220800.012.5666762012-01-0414.81000014.61714314.64285814.765715260022000.012.6342132012-01-0514.94821514.73821414.81964314.929643271269600.012.7744812012-01-0615.09821414.97214314.99178615.085714318292800.012.9080232012-01-0915.27678615.04821415.19642815.061786394024400.012.887549.....................2019-12-1167.77500267.12500067.20249967.69249778756800.066.5678862019-12-1268.13999966.83000266.94500067.864998137310400.066.7375182019-12-1368.82499767.73249867.86499868.787498133587600.067.6447072019-12-1670.19750269.24500369.25000069.964996128186000.068.8026352019-12-1770.44249769.69999769.89250270.102501114158400.068.937851 2003 rows × 6 columns Queste sono le quotazione di azioni Apple. Successivamente, mostrerò il numero di righe e colonne nel set di dati. Il risultato mostra che abbiamo 2003 righe o giorni in cui è stato registrato il prezzo delle azioni e 6 colonne. df.shape Output: (2003, 6) Crea un grafico per visualizzare i dati. #Visualizza la cronologia del prezzo di chiusura plt.figure(figsize=(16,8)) plt.title('Close Price History') plt.plot(df['Close']) plt.xlabel('Date',fontsize=18) plt.ylabel('Close Price USD ($)',fontsize=18) plt.show() Output: Grafico che mostra la cronologia dei prezzi delle azioni di chiusura di Apple Inc. Crea un nuovo data frame con solo il prezzo di chiusura e convertilo in un array. Quindi creare una variabile per memorizzare la lunghezza del set di dati di addestramento. Desidero che il set di dati di addestramento contenga circa l'80% dei dati. #nuova dataframe solo con le chiusure data = df.filter(['Close']) #Convertiamolo in un numpy array dataset = data.values training_data_len = math.ceil( len(dataset) *.8) Ora ridimensiona il set di dati in modo che sia valori compresi tra 0 e 1 incluso, lo faccio perché è generalmente buona pratica ridimensionare i dati prima di darli alla rete neurale. #Scala tutti i dati in modo che siano valori compresi tra 0 e 1 scaler = MinMaxScaler(feature_range=(0, 1)) scaled_data = scaler.fit_transform(dataset) ​ Creare un set di dati di addestramento che contenga i valori del prezzo di chiusura degli ultimi 60 giorni che si desidera utilizzare per prevedere il valore del prezzo di chiusura 61 °. Quindi la prima colonna nel set di dati ' x_train ' conterrà i valori dal set di dati dall'indice 0 all'indice 59 (60 valori in totale) e la seconda colonna conterrà i valori dal set di dati dall'indice 1 all'indice 60 (60 valori) E così via e così via. Il set di dati " y_train " conterrà il 61 ° valore situato all'indice 60 per la sua prima colonna e il 62 ° valore situato all'indice 61 del set di dati per il suo secondo valore e così via e così via. #Crea il set di dati per l'addestramento in scala train_data = scaled_data[0:training_data_len , : ] #Dividi i dati nel x_train e y_train x_train=[] y_train = [] for i in range(60,len(train_data)): x_train.append(train_data[i-60:i,0]) y_train.append(train_data[i,0]) Ora converti il ​​set di dati indipendente " x_train " e il set di dati dipendente " y_train " in array numpy in modo che possano essere utilizzati per l'addestramento del modello LSTM. # Converti x_train e y_train in array x_train, y_train = np.array(x_train), np.array(y_train) Rimodellare i dati in modo tridimensionale nella forma numero di campioni numero di fasi temporali numero di caratteristiche Il modello LSTM si aspetta un set di dati tridimensionale. #Reshape i dati nella forma accettata da LSTM x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1)) Costruisci il modello LSTM per avere due strati LSTM con 50 neuroni e due strati densi, uno con 25 neuroni e l'altro con 1 neurone di output. #Costruiamo il LSTM network model model = Sequential() model.add(LSTM(units=50, return_sequences=True,input_shape=(x_train.shape[1],1))) model.add(LSTM(units=50, return_sequences=False)) model.add(Dense(units=25)) model.add(Dense(units=1)) Compilare il modello utilizzando la funzione di perdita dell'errore quadratico medio (MSE) e l'ottimizzatore adam. #Compila il modello model.compile model.compile(optimizer='adam', loss='mean_squared_error') Addestra il modello utilizzando i set di dati di addestramento. La dimensione del batch è il numero totale di esempi di addestramento presenti in un singolo batch ed epoch è il numero di iterazioni in cui un intero set di dati viene passato avanti e indietro attraverso la rete neurale. #Allena il modello model.fit(x_train, y_train, batch_size=1, epochs=10) Output: Epoch 1/10 1543/1543 [==============================] - 21s 14ms/step - loss: 6.0664e-04 Epoch 2/10 1543/1543 [==============================] - 21s 13ms/step - loss: 2.9017e-04 Epoch 3/10 1543/1543 [==============================] - 21s 13ms/step - loss: 2.4941e-04 Epoch 4/10 1543/1543 [==============================] - 20s 13ms/step - loss: 1.5669e-04 Epoch 5/10 1543/1543 [==============================] - 21s 13ms/step - loss: 1.6930e-04 Epoch 6/10 1543/1543 [==============================] - 21s 13ms/step - loss: 1.5684e-04 Epoch 7/10 1543/1543 [==============================] - 21s 14ms/step - loss: 1.6119e-04 Epoch 8/10 1543/1543 [==============================] - 22s 14ms/step - loss: 1.4235e-04 Epoch 9/10 1543/1543 [==============================] - 24s 15ms/step - loss: 1.4032e-04 Epoch 10/10 1543/1543 [==============================] - 23s 15ms/step - loss: 1.4214e-04 Crea un set di dati di test. #Dati di test test_data = scaled_data[training_data_len - 60: , : ] #Crea i set di dati x_test e y_test x_test = [] y_test = dataset[training_data_len : , : ] #Recupera tutte le righe dall'indice 1603 al resto e tutte le colonne (in questo caso è solo la colonna "Chiudi"), così 2003 - 1603 = 400 righe di dati for i in range(60,len(test_data)): x_test.append(test_data[i-60:i,0]) Quindi converti il ​​set di dati di test indipendente ' x_test ' in un array numpy in modo che possa essere utilizzato per testare il modello LSTM. # Converti x_test in un array numpy x_test = np.array(x_test) Rimodellare i dati in modo tridimensionale nella forma [numero di campioni , numero di fasi temporali e numero di caratteristiche ]. Questo deve essere fatto, perché il modello LSTM si aspetta un set di dati tridimensionale. #Reshape i dati nella forma accettata da LSTM x_test = np.reshape(x_test, (x_test.shape[0],x_test.shape[1],1)) Ora ottieni i valori previsti dal modello utilizzando i dati del test. #Otteniamo le predizioni del modello predictions = model.predict(x_test) predictions = scaler.inverse_transform(predictions) Ottieni l'errore quadratico medio (RMSE), che è una buona misura dell'accuratezza del modello. Un valore pari a 0 indica che i valori previsti dai modelli corrispondono perfettamente ai valori effettivi del set di dati del test. Più basso è il valore, migliori saranno le prestazioni del modello. Ma di solito è meglio usare anche altre metriche per avere davvero un'idea di come si è comportato bene il modello. # Calcola / Ottieni il valore di RMSE rmse=np.sqrt(np.mean(((predictions- y_test)**2))) rmse Output: 1.020505485309228 Tracciamo e visualizziamo i dati. # Traccia / Crea i dati per il train = data[:training_data_len] valid = data[training_data_len:] valid['Predictions'] = predictions #Visualize the data plt.figure(figsize=(16,8)) plt.title('Model') plt.xlabel('Date', fontsize=18) plt.ylabel('Close Price USD ($)', fontsize=18) plt.plot(train['Close']) plt.plot(valid[['Close', 'Predictions']]) plt.legend(['Train', 'Val', 'Predictions'], loc='lower right') plt.show() Output: Il grafico che mostra i prezzi di formazione (allenamento), effettivi (validi) e previsti (previsioni).Mostra i prezzi validi e previsti. valid Output: Close Predictions Date 2018-05-1746.74750146.8632932018-05-1846.57749946.3976942018-05-2146.90750146.3534812018-05-2246.79000146.7314762018-05-2347.09000046.534359.........2019-12-1167.69249766.0610052019-12-1267.86499866.4198382019-12-1368.78749866.5070722019-12-1669.96499667.5563352019-12-1770.10250168.624374 400 rows × 2 columns I valori del prezzo effettivo (chiusura) e previsto (previsioni).Voglio testare ancora il modello e ottenere il valore del prezzo di chiusura previsto di Apple Inc. per il 18 dicembre 2019 (18/12/2019). Convertirò i dati in un array che contiene solo il prezzo di chiusura. Quindi otterrò il prezzo di chiusura degli ultimi 60 giorni e ridimensionerò i dati in modo che siano valori compresi tra 0 e 1 inclusi. Dopodiché creerò un elenco vuoto e vi aggiungerò il prezzo degli ultimi 60 giorni, quindi lo convertirò in un array numpy e lo rimodellerò in modo da poter inserire i dati nel modello. Ultimo ma non meno importante, inserirò i dati nel modello e otterrò il prezzo previsto. # Ottieni la citazione apple_quote = web.DataReader('AAPL', data_source='yahoo', start='2012-01-01', end='2019-12-17') #Crea un nuovo dataframe new_df = apple_quote.filter(['Close']) # Ottieni il prezzo di chiusura degli ultimi 60 giorni last_60_days = new_df[-60:].values #Scala i dati in modo che siano valori compresi tra 0 e 1 last_60_days_scaled = scaler.transform(last_60_days) #Crea un elenco vuoto X_test = [] #Appendi agli ultimi 60 giorni X_test.append(last_60_days_scaled) # Converti il ​​set di dati X_test in un array X_test = np.array(X_test) #ridimensioni i dati X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], 1)) # Ottieni il prezzo scalato previsto pred_price = model.predict(X_test) pred_price = scaler.inverse_transform (pred_price) print (pred_price) Output: [[68.51323]] Ora vediamo qual era il prezzo effettivo per quel giorno. apple_quote2 = web.DataReader('AAPL', data_source='yahoo', start='2019-12-18', end='2019-12-18') print(apple_quote2['Close']) Output: Date 2019-12-18 69.934998 Name: Close, dtype: float64 Proprio come volevamo "quasi" una predizione Perfetta. Scarica Gratuitamente tutto il Progetto Per scaricare gratuitamente devi prima registrati/accede al portale. Scorri in fondo alla pagina per registrati o accedere Condividi e commenta l'articolo se ti è stato utile , Grazie !

La libreria è dotata di centinaia di funzioni e algoritmi utili, tutti a nostra disposizione gratuitamente La funzione può essere utilizzata con due algoritmi. Per fortuna, non dobbiamo scrivere quegli algoritmi da soli. Possiamo abilitare un oggetto flag all'interno della funzione cv2.inpaint() e scegliere qualsiasi algoritmo Imparerai gli approcci di deep learning per risolvere problemi complessi.

Nei progetti di Machine Learning, abbiamo bisogno di un set di dati di addestramento . Il machine learning dipende fortemente dai dati, senza dati è impossibile che un "AI" apprenda. È l'aspetto più cruciale che rende possibile l'addestramento degli algoritmi ... È un insieme di procedure che consumano la maggior parte del tempo dedicato a progetti di machine learning Le applicazioni di machine learning richiedono un numero elevato di punti dati, ma questo non significa

 è uno strumento software che utilizza tecniche di deep learning per attribuire un attributo di proprietà  per l'algoritmo classificatore di tensorflow Un classificatore TensorFlow è un algoritmo di machine  learning che viene utilizzato per identificare o categorizzare entità in base a un insieme di dati.  TensorFlow fornisce una vasta gamma di classificatori predefiniti, tra cui: • DNN (Deep Neural Networks L'apprendimento automatico supervisionato è una tecnica di machine learning che utilizza un insieme di

L’apprendimento delle lingue è una delle attività più utili e gratificanti che possiamo fare, sia per motivi personali che professionali. Ma come possiamo imparare le lingue in modo efficace ed efficiente, senza annoiarci o scoraggiarci? La risposta potrebbe essere l’intelligenza artificiale (IA). L’IA è la capacità delle macchine di svolgere compiti che normalmente richiedono intelligenza umana, come il riconoscimento di immagini, la comprensione del linguaggio naturale o la generazione di testi. Grazie ai progressi della tecnologia e della scienza, l’IA sta diventando sempre più potente e accessibile, offrendo nuove opportunità e sfide per l’apprendimento delle lingue. In questo articolo, vedremo come usare l’IA per imparare nuove lingue in modo facile e divertente, sfruttando le sue potenzialità e facendo attenzione ai suoi limiti. Vedremo come usare ChatGPT, un chatbot basato sull’IA che può generare conversazioni in diverse lingue a partire da testi o parole chiave. Vedremo anche quali sono le migliori app con l’IA per imparare una lingua, che ti ascoltano, ti valutano e ti danno dei consigli. Infine, vedremo quali sono i migliori prompt per imparare una nuova lingua, che ti stimolano a scrivere, leggere, ascoltare e parlare in modo naturale e coinvolgente. Come usare l’IA per imparare nuove lingue L’IA non è solo uno strumento per automatizzare o semplificare alcune attività, ma anche un potente alleato per imparare nuove cose, sia per motivi personali che professionali. Che si tratti di una nuova lingua, una nuova materia o una nuova abilità, l’IA può aiutarci a rendere il nostro apprendimento più efficace, efficiente e divertente. Ma come? E quali sono i vantaggi e le sfide di usare l’IA per imparare? L’IA può aiutarci a imparare in diversi modi, a seconda delle nostre esigenze, dei nostri obiettivi e delle nostre preferenze. Alcuni dei modi più comuni e innovativi sono: Usare l’IA per personalizzare il nostro percorso di apprendimento. L’IA può analizzare i nostri dati, i nostri test, i nostri feedback e il nostro comportamento per capire il nostro livello, il nostro stile e i nostri interessi di apprendimento. In base a questi fattori, l’IA può adattare il contenuto, la difficoltà, il ritmo e il tipo di feedback che ci offre, per renderlo più adatto e stimolante per noi. In questo modo, possiamo imparare a modo nostro, senza annoiarci o scoraggiarci. Un esempio di questo tipo di IA è Duolingo, una delle app più popolari per l’apprendimento delle lingue, che usa l’IA per creare dei corsi personalizzati e interattivi per ogni utente. Usare l’IA per interagire con un interlocutore virtuale. L’IA può generare delle conversazioni in diverse lingue, a partire da testi o parole chiave, usando dei modelli di IA che imitano lo stile e il tono del linguaggio umano. Questo ci permette di avere delle conversazioni personalizzate con un interlocutore virtuale, che ci corregge gli errori, ci suggerisce delle varianti linguistiche, ci propone dei temi interessanti e ci fa delle domande per stimolare la nostra risposta. In questo modo, possiamo praticare le nostre abilità di scrittura, lettura, ascolto e parlato, in modo naturale e coinvolgente. Un esempio di questo tipo di IA è ChatGPT, un chatbot basato sull’IA che può generare conversazioni in diverse lingue. Usare l’IA per valutare e migliorare la nostra pronuncia. L’IA può ascoltare il nostro parlato, confrontarlo con quello di un madrelingua, e darci un punteggio basato su vari criteri, come l’intonazione, lo stress, il ritmo e la pronuncia dei singoli suoni. L’IA può anche darci dei suggerimenti per migliorare la nostra pronuncia, come ripetere delle frasi, ascoltare dei modelli, registrare la nostra voce e confrontarla con quella del madrelingua. In questo modo, possiamo ricevere dei feedback immediati e oggettivi, senza timore di essere giudicati o scoraggiati. Un esempio di questo tipo di IA è ELSA Speak, una app che usa l’IA per aiutarti a migliorare la tua pronuncia in inglese. I vantaggi di usare l’IA per imparare sono molti, tra cui: La possibilità di imparare in qualsiasi momento e luogo, senza bisogno di un insegnante o di un interlocutore umano. La possibilità di imparare a modo nostro, seguendo i nostri interessi, i nostri obiettivi e il nostro ritmo. La possibilità di ricevere dei feedback personalizzati, accurati e tempestivi, che ci aiutano a correggere i nostri errori e a migliorare le nostre competenze. La possibilità di rendere il nostro apprendimento più divertente e stimolante, usando dei giochi, delle storie, delle sfide e delle ricompense. Le sfide di usare l’IA per imparare sono invece: La limitata capacità dell’IA di riconoscere le sfumature del linguaggio umano, come l’ironia, l’umorismo o le emozioni. La possibile frustrazione o noia nel ripetere sempre gli stessi esercizi o testi. La necessità di integrare l’IA con altre risorse o metodi per imparare anche altri aspetti della lingua, come la grammatica, il vocabolario o la cultura. La preoccupazione per la privacy e l’etica dei dati che forniamo all’IA. Come usare ChatGPT per imparare una lingua ChatGPT è un chatbot basato sull’IA che può generare conversazioni in diverse lingue a partire da testi o parole chiave. ChatGPT usa un modello di IA chiamato GPT-3, che è in grado di produrre testi coerenti e creativi su qualsiasi argomento, imitando lo stile e il tono del linguaggio umano. ChatGPT può essere usato per imparare una lingua in modo facile e divertente, perché ti permette di avere delle conversazioni personalizzate con un interlocutore virtuale, che ti corregge gli errori, ti suggerisce delle varianti linguistiche, ti propone dei temi interessanti e ti fa delle domande per stimolare la tua risposta. In questo paragrafo, vedremo come usare ChatGPT per imparare una lingua, quali sono i trucchi e i concetti interessanti che puoi sfruttare, e quali sono le fonti e le risorse che puoi consultare per approfondire. Ecco alcuni spunti di possibili messaggi che puoi usare per imparare una lingua con ChatGPT: Puoi chiedere al chatbot di insegnarti delle parole o delle espressioni utili nella lingua che vuoi imparare. Per esempio, puoi scrivere: “How do you say hello in French?” o “What does bonjour mean in English?”. Il chatbot ti risponderà con la traduzione o la spiegazione della parola o dell’espressione che hai chiesto. Puoi chiedere al chatbot di correggerti se fai degli errori nella lingua che vuoi imparare. Per esempio, puoi scrivere: “I am study English for two years” o “Je suis étudier le français depuis deux ans”. Il chatbot ti risponderà con la forma corretta della frase che hai scritto, e ti spiegherà la regola grammaticale che hai violato. Puoi chiedere al chatbot di darti dei consigli o delle dritte per imparare meglio la lingua che vuoi imparare. Per esempio, puoi scrivere: “What is the best way to learn German?” o “How can I improve my pronunciation in Spanish?”. Il chatbot ti risponderà con dei suggerimenti pratici e utili, basati sulla sua esperienza o sulle sue conoscenze. Puoi chiedere al chatbot di parlarti della cultura, della storia o della geografia del paese o dei paesi dove si parla la lingua che vuoi imparare. Per esempio, puoi scrivere: “Tell me something interesting about Italy” o “What are the main attractions in Japan?”. Il chatbot ti risponderà con delle informazioni curiose e interessanti, che ti aiuteranno a conoscere meglio il contesto e le sfumature della lingua che vuoi imparare. Puoi chiedere al chatbot di farti delle domande sulla lingua che vuoi imparare, per verificare il tuo livello e la tua comprensione. Per esempio, puoi scrivere: “Ask me a question in Portuguese” o “Quiz me on Chinese vocabulary”. Il chatbot ti risponderà con una domanda adeguata al tuo livello, e ti darà il feedback sulla tua risposta. Le migliori app con l’IA per imparare una lingua L’IA è una tecnologia che può aiutarti a imparare una lingua in modo facile e divertente, offrendoti delle funzioni e delle attività che si adattano al tuo livello, al tuo stile e ai tuoi obiettivi di apprendimento. Ci sono molte app con l’IA per imparare una lingua, ma quali sono le migliori? In base alle mie ricerche, ho selezionato le seguenti app, che si distinguono per la qualità, la varietà e l’innovazione dei loro contenuti e metodi: Babbel: Babbel è una delle app più popolari e famose per l’apprendimento delle lingue. Ti offre corsi gratuiti e personalizzati in oltre 40 lingue, basati su esercizi interattivi, giochi e storie. Babbel usa l’IA per adattare il livello di difficoltà, il tipo di feedback e il contenuto dei corsi alle tue esigenze e ai tuoi interessi. Babbel ha anche un chatbot che ti permette di praticare la conversazione con un interlocutore virtuale. Puoi trovare maggiori informazioni su Babbel qui. Memrise: Memrise è un’altra app per l’apprendimento delle lingue che usa l’IA per rendere il processo più efficace ed efficiente. Memrise ti offre corsi in oltre 20 lingue, basati su video reali, audio autentici e ripetizioni spaziate. Memrise usa l’IA per creare dei percorsi di apprendimento personalizzati, che ti aiutano a memorizzare le parole e le frasi più importanti e utili per te. Memrise ha anche una funzione di realtà aumentata, che ti permette di vedere e parlare con degli animali in 3D nella tua lingua preferita. Puoi trovare maggiori informazioni su Memrise qui. Mondly: Mondly è un’altra app per l’apprendimento delle lingue che sfrutta l’IA per offrirti una esperienza immersiva e coinvolgente. Mondly ti offre corsi in oltre 40 lingue, basati su dialoghi realistici, vocabolario ricco e grammatica essenziale. Mondly usa l’IA per creare delle situazioni di vita reale, in cui puoi interagire con dei personaggi virtuali, usando la tua voce e il tuo microfono. Mondly ha anche una funzione di realtà virtuale, che ti permette di immergerti in scenari interattivi nella tua lingua preferita. Puoi trovare maggiori informazioni su Mondly qui. MosaChat-AI: MosaChat-AI è il nostro tutor linguistico con intelligenza artificiale, che ti aiuta a imparare una lingua in modo naturale e divertente. MosaChat-AI ti propone delle conversazioni su vari argomenti, come il cibo, il viaggio, lo sport e la musica. MosaChat-AI ti corregge gli errori, ti spiega le regole grammaticali, ti suggerisce dei sinonimi e ti fa delle domande per stimolare la tua risposta. MosaChat-AI si adatta al tuo livello e ai tuoi obiettivi di apprendimento, e tiene traccia dei tuoi progressi. Puoi trovare maggiori informazioni su MosaChat-AI qui. L’importante è trovare l’app che ti piace di più e che ti motiva a continuare a imparare. Migliori prompt per imparare una lingua ChatGPT è un chatbot generico, che può generare conversazioni su qualsiasi argomento, senza uno scopo specifico. Siamo noi che possiamo usare ChatGPT per imparare una lingua, inviandogli dei messaggi che lo stimolino a fungere da diversi tipi di persone che ci possono aiutare a imparare la lingua che desideriamo. Ecco alcuni spunti di possibili messaggi che puoi usare per imparare una lingua con ChatGPT: Prompt 1: Da adesso fingi di essere un insegnante madrelingua [inserisci qui la lingua]. Devi aiutarmi a migliorare la mia scrittura, correggendomi gli errori grammaticali e proponendomi nuovi modi di dire. Scrivimi una frase [inserisci qui la lingua] su un argomento a tua scelta e chiedimi di riscriverla usando parole diverse. Poi valuta la mia risposta e dammi dei consigli per migliorare. Prompt 2: Da adesso fingi di essere un amico madrelingua [inserisci qui la lingua]. Devi aiutarmi a migliorare il mio ascolto, parlandomi [inserisci qui la lingua] e facendomi delle domande. Usa un linguaggio informale e familiare, e inserisci delle espressioni tipiche della lingua parlata. Poi leggi la mia risposta e correggimi se pronuncio male o se uso parole sbagliate. Prompt 3: Da adesso fingi di essere un turista madrelingua [inserisci qui la lingua]. Devi aiutarmi a migliorare la mia lettura, mandandomi dei messaggi [inserisci qui la lingua] con delle foto o dei link di luoghi che hai visitato o che vorresti visitare. Usa un linguaggio semplice e chiaro, e spiegami cosa c’è nelle foto o nei link, e perché ti piacciono o ti interessano. Poi chiedimi di leggere i tuoi messaggi e di risponderti con delle domande o dei commenti. Prompt 4: Da adesso fingi di essere un esperto madrelingua [inserisci qui la lingua]. Devi aiutarmi a migliorare la mia cultura, insegnandomi delle cose interessanti sulla lingua, la storia, la geografia o l’arte di [inserisci qui il paese o i paesi dove si parla la lingua]. Usa un linguaggio formale e preciso, e inserisci dei dati, delle date o dei nomi importanti. Poi chiedimi di ripetere o di riassumere quello che mi hai insegnato, e controlla se ho capito bene o se ho sbagliato qualcosa. Prompt 5: Da adesso fingi di essere un compagno madrelingua [inserisci qui la lingua]. Devi aiutarmi a migliorare la mia motivazione, incoraggiandomi a studiare e a praticare [inserisci qui la lingua]. Usa un linguaggio gentile e positivo, e dimostrami il tuo apprezzamento e il tuo sostegno. Poi chiedimi di raccontarti i miei progressi, le mie difficoltà e i miei obiettivi, e dammi dei consigli o delle risorse per aiutarmi. Conclusione su come usare l’IA per imparare nuove lingue In questo articolo, abbiamo visto come usare l’IA per imparare nuove lingue in modo facile e divertente. Abbiamo scoperto come l’IA può aiutarci a personalizzare il nostro percorso di apprendimento, a interagire con un interlocutore virtuale, a valutare e migliorare la nostra pronuncia, a imparare delle cose interessanti sulla cultura e la storia delle lingue che vogliamo imparare, e a motivarci e incoraggiarci a continuare a studiare. Abbiamo anche visto quali sono le migliori app con l’IA per imparare una lingua, e quali sono i migliori prompt per stimolare l’IA a fungere da diversi tipi di persone che ci possono aiutare a imparare una lingua. Speriamo che questo articolo ti sia stato utile e ti abbia ispirato a usare l’IA per imparare nuove lingue. Ti ringraziamo per aver letto il nostro articolo, e ti invitiamo a lasciare un commento, una domanda o un suggerimento. A nome della redazione di Intelligenzaartificialeitalia.net, ti auguriamo buon apprendimento e buon divertimento con l’IA!

learning. apprendimento automatico, è "quale algoritmo devo usare?" algoritmi. Sebbene esistano molti altri algoritmi di Machine Learning, questi sono i più popolari. Se sei un principiante del Machine Learning, questi sarebbero un buon punto di partenza per imparare.

Da quando MyHeritage ha lanciato il suo strumento Deep Nostalgia, che rianima i morti con la tecnologia Abbiamo dato a Deep Nostalgia una foto di Einstein. Deep Nostalgia AI fa progressi esponenziali Pochi direbbero che un'animazione realistica di antenati Alimentato tramite un algoritmo di deep learning creato da D-ID, Deep Nostalgia ha fornito a molti utenti

Come capire se uno studente o un dipendente sta utilizzando ChatGPT di OpenAI per completare un compito? Questo articolo ti darà tutti gli strumenti per capirlo! Il 30 novembre 2022, OpenAI ha rilasciato il sistema AI "ChatGPT" (https://openai.com/blog/chatgpt/), che è un assistente universale alla scrittura che può generare una varietà di risultati, inclusi i compiti scolastici. L'output (ad esempio, saggi, frasi, email, codici, etc... ) fornito da ChatGPT è così buono, che se fossi uno studente, userei ChatGPT per completare la maggior parte dei miei compiti scolastici con piccole revisioni. Ciò si traduce in un dilemma per i professori e gli insegnati, perchè è molto difficile capire se è lo studente che ha scritto il saggio o se l ha scritto ChatGPT. Avrebbero bisogno di una sorta di strumento per verificarlo. Ad esempio, se l'insegnante assegna i compiti sull'importanza della Dottrina Monore, uno studente può utilizzare ChatGPT per scrivere un saggio sulla Dottrina Monroe: OUTPUT CHATGPT La Dottrina Monroe era una dichiarazione di politica estera rilasciata dal presidente James Monroe nel 1823. Dichiarava che gli Stati Uniti non avrebbero interferito negli affari dei colonizzatori europei e che qualsiasi tentativo da parte delle potenze europee di colonizzare o interferire con stati indipendenti nelle Americhe avrebbe essere visto come una minaccia per gli Stati Uniti. La buona notizia è che OpenAI è consapevole delle preoccupazioni espresse dagli educatori e ha pubblicato Considerazioni per insegnanti su ChatGPT . Inoltre, sono attualmente disponibili strumenti per rilevare se il testo è stato generato dall'intelligenza artificiale. Classificatore di testo AI OpenAI Demo del rivelatore di output su OpenAI GPT-2 GPTZeroX di Edward Tian (Università di Princeton) DetectGPT della Stanford University Potresti voler utilizzare tutti e quattro gli strumenti per rilevare se il testo è stato generato dall'intelligenza artificiale poiché nessuno di questi strumenti è accurato al 100%. Ma prima di vedere tutti i siti o software che puoi usare per capire se un testo è stato scritto da un umano o no vediamo cosa può portare fare compiti con l' IA. Come rilevare testo generato da Intelligenze Artificiali IA? Ci sono diverse tecniche per rilevare il testo generato da un'IA, come l'utilizzo di software di controllo del plagio IA ( Che vedremo tra poco ) o l'analisi delle proprietà linguistiche del testo. Ad esempio, il software di controllo del plagio può identificare se il testo presenta somiglianze con altre fonti presenti in rete. D'altro canto, l'analisi delle proprietà linguistiche del testo può aiutare a individuare tracce di linguaggio innaturali che sono tipiche della scrittura generata da un'IA. In entrambi i casi, è importante utilizzare queste tecniche con cautela e considerare anche altri fattori, come lo stile unico di scrittura di uno studente, prima di giungere a conclusioni definitive. Conseguenze per gli studenti che utilizzano l'IA L'utilizzo di ChatGPT o di qualsiasi altra forma di intelligenza artificiale per completare i compiti scolastici può avere conseguenze negative per gli studenti. In primo luogo, la mancanza di sviluppo delle competenze di scrittura autentiche può rendere gli studenti meno preparati per il mondo del lavoro. In secondo luogo, se gli studenti vengono scoperti a utilizzare l'intelligenza artificiale per completare i compiti, possono essere sanzionati o anche espulsi. Questo può avere un impatto negativo sulla loro carriera scolastica e professionale. Prevenire l'uso improprio dell'intelligenza artificiale Gli insegnanti possono prevenire l'uso improprio dell'intelligenza artificiale adottando alcune misure. Ad esempio, possono incoraggiare lo sviluppo di competenze di scrittura autentiche attraverso l'assegnazione di compiti creativi e originali. Inoltre, possono utilizzare tecnologie di rilevamento del plagio per individuare eventuali casi di utilizzo improprio dell'intelligenza artificiale. E noi vi daremo tutti gli strumenti! NON UNO SOLO! Come rilevare testo generato da IA : tool 1 Classificatore di testo AI OpenAI OpenAI ha rilasciato AI Text Classifier il 31 gennaio 2023. AI Text Classifier è un modello GPT ottimizzato che prevede quanto è probabile che un pezzo di testo sia stato generato dall'intelligenza artificiale da una varietà di fonti, come ChatGPT. Puoi accedere a AI Text Classifier navigando su https://platform.openai.com/ai-text-classifier e accedendo al sito Web utilizzando il tuo account OpenAI ChatGPT. Per dimostrare lo strumento, ho copiato e incollato il saggio sopra e un po' di più, poiché richiede più di 1.000 caratteri, come mostrato di seguito: Lo strumento ha determinato che questo testo è stato probabilmente generato dall'intelligenza artificiale. Anche se sconsigliano d'immettere il testo direttamente in italiano noi ci abbiamo provato e funziona abbastanza bene. Come rilevare testo generato da IA : tool 2 Demo del rivelatore di output su OpenAI GPT-2 Lo strumento di OpenAI è ospitato su Hugging Face e si chiama GPT-2 Output Detector Demo che è stato sviluppato da OpenAI (vedi i dettagli qui => https://huggingface.co/roberta-base-openai-detector ). Puoi accedere alla demo del rilevatore di output GPT-2 navigando su https://huggingface.co/openai-detector . Per dimostrare lo strumento, ho copiato e incollato il saggio sopra, come mostrato di seguito: Lo strumento ha determinato che esiste una probabilità del 99,61% che questo testo sia stato generato utilizzando OpenAI GPT. Come rilevare testo generato da IA : tool 3 GPTZeroX Edward Tian (Princeton) ha aggiornato uno strumento a GPTZeroX ( http://gptzero.me/ ) il 29 gennaio 2023; precedentemente rilasciato il 2 gennaio 2023 come GPTZero. Lo strumento cerca sia "perplessità" che "esplosione". La perplessità misura la probabilità che ogni parola venga suggerita da un bot; un essere umano sarebbe più casuale. Burstiness misura i picchi nella perplessità di ogni frase. Un bot avrà probabilmente un grado di perplessità simile da frase a frase, ma è probabile che un essere umano scriva con punte, forse una frase lunga e complessa seguita da una più breve. Puoi accedere a GPTZeroX navigando su http://gptzero.me/ . Per dimostrare lo strumento, ho copiato e incollato il saggio sopra e un po' di più come mostrato di seguito: Lo strumento ha determinato che questo testo è stato probabilmente generato dall'intelligenza artificiale. Inoltre, GPTZeroX fornisce sia Perplexity Score che Burstiness Score. Come rilevare testo generato da IA : tool 4 DetectGPT La Stanford University ha rilasciato DetectGPT ( https://detectgpt.ericmitchell.ai/ ) il 31 gennaio 2023. DetectGPT è un metodo generico per utilizzare un modello linguistico per rilevare le proprie generazioni; tuttavia, questa prova di concetto rileva solo se una particolare parte di testo proviene da GPT-2 . I rilevamenti su campioni di altri modelli possono essere particolarmente inaffidabili. Potremmo aggiungere modelli più grandi come GPT-J (6B), GPT-NeoX (20B) o GPT-3 (175B) in futuro; eseguiamo valutazioni con questi e altri modelli nel nostro documento per il sito Web DetectGPT. Puoi accedere a DetectGPT navigando su https://detectgpt.ericmitchell.ai/ . Per dimostrare lo strumento, ho copiato e incollato il saggio sopra e un po' di più come mostrato di seguito: Tieni presente che ho dovuto mantenere il testo sotto le 200 parole, in modo da non surriscaldare le loro GPU per sito web. Lo strumento ha determinato che è probabile che questo testo provenga da GPT-2. Inoltre, DetectGPT fornisce testi perturbati. Altri strumenti per rilevare l'output di chat gpt Esistono altri due strumenti per rilevare se il testo è stato generato dall'intelligenza artificiale, che non ho provato: Rilevatore di contenuto AI di Writer Content at Scale AI Content Detection Vai a provare tutti e quattro gli strumenti! Si prega di notare che questi strumenti, come tutto in AI, hanno un'alta probabilità di rilevare l'output di testo generato dall'IA, ma non al 100% come attribuito da George EP Box "Tutti i modelli sono sbagliati, ma alcuni sono utili". Risorse per rilevare l'output di testi generati dall' IA compresa CHAT GPT Di seguito è riportato un elenco delle risorse utilizzate o a cui si fa riferimento in questo tutorial: Considerazioni dell'educatore per ChatGPT Classificatore di testo AI Hugging Face Demo del rilevatore di uscita GPT-2 Dettagli sul rilevatore di uscita GPT-2 GptZeroX OpenAI chatGPT DetectGPT Rilevamento delle generazioni GPT-2 con DetectGPT

Apprendimento approfondito per il rilevamento di oggetti Le tecniche di deep learning si sono dimostrate Di seguito sono riportati alcuni degli approcci di deep learning comunemente utilizzati per il rilevamento ImageAI contiene un'implementazione Python di quasi tutti gli algoritmi di apprendimento profondo all'avanguardia

Grazie all'utilizzo di algoritmi complessi, le reti neurali possono essere addestrate per riconoscere Grazie a modelli di deep learning, le reti neurali possono apprendere a comprendere il linguaggio umano Questi algoritmi sono alla base di piattaforme di streaming, e-commerce e social media, aiutando gli I sistemi di raccomandazione basati su reti neurali utilizzano modelli avanzati di machine learning per di ottimizzazione, logica fuzzy o algoritmi genetici.

Non so tu ne eri sei a conoscenza ma esistono algoritmi che emulano il funzionamento del neurone biologico The Perceptron, a Perceiving and Recognizing Automaton All'interno del quale andava a spiegare, una algoritmo

Collatz è… un ristoratore DOLO_MITICO, a detta sua… anche perché non è facile gestire un rifugio in alta montagna… dove il tempo varia anche più volte al giorno… e questo è un fattore importante per chi deve prevedere quanti clienti si fermeranno a mangiare … il mio amico Collatz, sin da piccolo ha dimostrato di avere una gran passione per la matematica e, da quando ha scoperto che gli elaboratori sono in grado di fare delle previsioni, perché si è imbattuto nel sito di intelligenzaartificialeitalia.net si è messo in mente di sfruttare il suo PC, anche per cercare di gestire anticipatamente ordini e personale. Già da qualche tempo aveva visto che nel web c’erano dei diagrammi che indicavano ad esempio l’andamento della pandemia, come questo: o similmente qualcosa che riguardava il numero dei passeggeri che, nel tempo avevano deciso di imbarcarsi con una determinata flotta, come quest’altro: oppure, qualche diagramma che riportava l’andamento dei titoli in borsa, come quest’ultimo: Fu così che si mise a riportare, giorno per giorno, il numero di clienti che dall’inizio della stagione, erano andati al suo “ristorante”, che in realtà rimaneva sempre un rifugio di montagna in balia del tempo… e annotando su di un file del tipo “Seq_work.csv” i dati, ottenne un grafico come questo: Così, si rese conto che era veramente difficile fare delle previsioni, ma decise comunque di proseguire nel suo intento, quello di addestrare una rete neurale, nella versione LSTM (Long-Short Term Memory), come aveva visto fare visitando il sito: intelligenzaartificialeitalia.net , utilizzando però python e pytorch. al posto di keras. Armato di buona volontà installò il software occorrente sul suo PC, mi sembra abbia utilizzato una GUI che si chiama VisualStudio Code, e che gli abbia fornito in seguito, l’estensione per il linguaggio python. Mi disse anche che aveva generato uno spazio di memoria particolare, appositamente per inserirci dentro tutto l’occorrente, utilizzando il modulo “venv”, di pyhton che, mi disse, è un modo efficace per ottenere ambienti python virtuali sui quali lavorare in santa pace!. Per fare questo, mi disse che nel suo PC, aveva installato una versione di Linux “Ubuntu” in quanto lo riteneva adeguato allo scopo. Mi informò anche che python aveva diverse librerie e moduli, che si rendevano necessari per lavorare sui modelli di intelligenza artificiale, e che si dovevano installare anche queste librerie., come indicato dal sito intelligenzaartificialeitalia.net Poi incominciò a descrivermi il software che aveva scritto per l’occasione, per prima cosa bisognava importare le librerie contenenti il necessario per portare a termine il progetto: #!/usr/bin/python3# import numpy as np import torch import torch.nn as nn from sklearn.preprocessing import MinMaxScaler import pandas as pd import matplotlib.pyplot as plt In particolare mi disse che il modulo “numpy”, è una libreria per il trattamento di vettori e matrici e che ovviamente contiene molte funzioni matematiche, molto utili per il trattamento dei dati numerici, mi disse che il modulo “pandas” non è una malattia autoimmune, ma una libreria per il trattamento dei dati scritti in modo tabellare e che in questo caso la avrebbe utilizzata per leggere i suo file “Seq_work.csv”, aggiunse che, per dare una forma grafica ai dati riportati avrebbe utilizzato le funzionlità di “matplotlib”. Aggiunse poi, che per questo esperimento pensava di effettuare una “normalizzazione” dei dati tra un valore minimo e un massimo, che però al riguardo, gli rimanevano forti perplessità, ma, strizzandomi l’occhio, mi disse sottovoce, tentar non nuoce e quindi, che per fare le dovute trasformazioni – riparametrazioni dei dati grezzi, avrebbe usato il modulo “sklearn.preprocessing”. Infine, disse che per questo esperimento avrebbe utilizzato una libreria famosa (scoperta in Facesbook) che si chiamava Torch, ma che non aveva nulla a che fare con i citomegalovirus, ma con array di numeri rettangolari multidimensionali omogenei, che denominava “tensori”, e che con questa libreria si potevano costruire delle reti neurali, proprio quelle che avrebbe utilizzato per l’elaborazione di previsione che a lui interessava. Per prima cosa, disse, bisogna caricare i dati, che aveva scritto in formato “.csv”(acronimo di comma-separated values), nel file “DataSeeq.csv” e per fare questo veniva appunto utilizzato il modulo “pandas”: #acquisizione dati pd.read_csv("DataSeq.csv") #salvare i dati dentro una variabile dataset = pd.read_csv("DataSeq.csv") mi disse che, per sua curiosità personale, voleva vedere a schermo almeno una idea del formato dei dati caricati con pandas nella variabile dataset. E per fare questo bastavano due linee di programma: print ("*****************") print(dataset.head()) print(dataset.shape) print('***********') Se tutto fosse andato a buon fine si dovrebbe ottenere un risultato simile a questo: come si vede l’output è un file ordinato che contiene 200 sequenze per 4 colonne: le sequenze sono le registrazioni dei dati relativi al numero dei clienti (n_cycle) e suddivisi ulteriormente in ( numero di clienti maschili: n_alpha e numero di clienti femminili: n_beta). Si noti la deformazione professionale di Collatz nella nomenclatura dei dati…. Per il momento tralasciamo i valori di n_alpha e n_beta, che magari potranno essere utilizzati in un secondo momento per giocare con una applicazione successiva di predizione…. In qualsiasi caso, potremmo identificare la tipologia dei dati riportati nelle colonne facendo stampare l’oggetto colonne con l’istruzione: print(dataset.columns) a cui corrisponderà un output del tipo: Index(['n_sequence', 'n_cycle', 'n_alpha', 'n_beta'], dtype='object') La libreria PyTorch “predilige” i dati di tipo “float”(in inglese floating point) o numerazione a virgola mobile, e quindi si dovrà eseguire una prima trasformazione con l’istruzione: all_data = dataset['n_cycle'].values.astype(float) assegnando alla variabile “all_data”, tutto il pacchetto contenuto in dataset, relativo a “n_cycle”, che per Collatz, sarebbe il numero di clienti che hanno usufruito delle prestazioni culinarie del “ristorante”, giorno per giorno, nei primi “200 giorni” dalla data di apertura stagionale, qualcosa di simile a questo: [ 3. 1. 7. 2. 5. 8. 16. 3. 19. 6. 14. 9. 9. 17. 17. 4. 12. 20. 20. 7. 7. 15. 15. 10. 23. 10. 111. 18. 18. 18. 106. 5. 26. 13. 13. 21. 21. 21. 34. 8. 109. 8. 29. 16. 16. 16. 104. 11. 24. 24. 24. 11. 11. 112. 112. 19. 32. 19. 32. 19. 19. 107. 107. 6. 27. 27. 27. 14. 14. 14. 102. 22. 115. 22. 14. 22. 22. 35. 35. 9. 22. 110. 110. 9. 9. 30. 30. 17. 30. 17. 92. 17. 17. 105. 105. 12. 118. 25. 25. 25. 25. 25. 87. 12. 38. 12. 100. 113. 113. 113. 69. 20. 12. 33. 33. 20. 20. 33. 33. 20. 95. 20. 46. 108. 108. 108. 46. 7. 121. 28. 28. 28. 28. 28. 41. 15. 90. 15. 41. 15. 15. 103. 103. 23. 116. 116. 116. 23. 23. 15. 15. 23. 36. 23. 85. 36. 36. 36. 54. 10. 98. 23. 23. 111. 111. 111. 67. 10. 49. 10. 124. 31. 31. 31. 80. 18. 31. 31. 31. 18. 18. 93. 93. 18. 44. 18. 44. 106. 106. 106. 44. 13. 119. 119. 119. 26. 26. 26. 119. 26.] se si utilizzasse una istruzione tipo questa: print(all_data) Ora, Collatz mi disse, per verificare l’affidabilità di predizione del modello che andremo a testare, una cosa da fare, molto importante, è fargli fare allenamento su un numero sufficiente di dati, che chiameremo “train_data” e poi testare il modello su un set di dati conosciuti, che chiameremo “test_data”. Dopo averci pensato sopra un po’, affermò che, visto che avevamo a disposizione 200 sequenze, avremmo potuto utilizzarne la gran parte per allenare il modello e fare il test su un numero piccolo di sequenze, e visto che si trattava di dati ottenuti con una metodologia temporale, considerando i tempi di approvvigionamento delle materie prime e del preavviso ai dipendenti, aveva deciso di utilizzare le prime 185 sequenze per allenare il modello e le ultime per fare il test. Per fare questo, disse bastavano poche istruzioni, le seguenti: #configurazione train data e test data test_data_size = 15 train_data = all_data[:-test_data_size] test_data = all_data[-test_data_size:] print ('--- len train and test data ---') print(len(train_data)) print(len(test_data)) print('-----test data ------') print(test_data) e da quanto sopra viene ottenuto un output come questo: --- len train and test data --- 185 15 -----test data ------ [ 18. 44. 106. 106. 106. 44. 13. 119. 119. 119. 26. 26. 26. 119. 26.] A questo punto, per fare in modo di ottenere dei dati normalizzati, sulla parte dei dati utilizzata per l’allenamento: il train_data, appunto, centrandoli in questo caso, sullo zero, ed ottenendo quindi dei valori compresi tra -1 e 1, si sarebbe usato il modulo “sklearn.preprocessing” , con la seguente modalità : #normalizzazione dati scaler = MinMaxScaler(feature_range=(-1, 1)) train_data_normalized = scaler.fit_transform(train_data .reshape(-1, 1)) print('--- stampa esempio dati normalizzati ---') print(train_data_normalized[:5]) print(train_data_normalized[-5:]) ottenendo un output per le prime cinque sequenze che dovrebbe risultare simile a questo: --- stampa esempio dati normalizzati --- [[-0.96747967] [-1. ] [-0.90243902] [-0.98373984] [-0.93495935]] mentre per le ultime sequenze, l’output sarà: [[-0.72357724] [ 0.49593496] [ 0.49593496] [-0.72357724] [-0.30081301]] ed è forse per questo motivo che il mio amico Collatz, mi espresse la sua perplessità! (si riferiva probabilmente al fatto che nella ultima sequenza comparivano dei numeri negativi...) In qualsiasi caso, decise di continuare con l’esperimento, e di passare i dati al tesnore di PyTotch per il train_data normalizzato, con le seguenti istruzioni, che ne riportavano anche il risultato, se non altro per vedere la differenza di gestione degli oggetti: # passaggio a tnsore per train data train_data_normalized = torch.FloatTensor(train_data_normalized).view(-1) print('-----torch.FloatTensor--------') print (train_data_normalized) print('---------------------') l’output in questo caso dovrebbe essere questo: -----torch.FloatTensor-------- tensor([-0.9675, -1.0000, -0.9024, -0.9837, -0.9350, -0.8862, -0.7561, -0.9675, -0.7073, -0.9187, -0.7886, -0.8699, -0.8699, -0.7398, -0.7398, -0.9512, -0.8211, -0.6911, -0.6911, -0.9024, -0.9024, -0.7724, -0.7724, -0.8537, -0.6423, -0.8537, 0.7886, -0.7236, -0.7236, -0.7236, 0.7073, -0.9350, -0.5935, -0.8049, -0.8049, -0.6748, -0.6748, -0.6748, -0.4634, -0.8862, 0.7561, -0.8862, -0.5447, -0.7561, -0.7561, -0.7561, 0.6748, -0.8374, -0.6260, -0.6260, -0.6260, -0.8374, -0.8374, 0.8049, 0.8049, -0.7073, -0.4959, -0.7073, -0.4959, -0.7073, -0.7073, 0.7236, 0.7236, -0.9187, -0.5772, -0.5772, -0.5772, -0.7886, -0.7886, -0.7886, 0.6423, -0.6585, 0.8537, -0.6585, -0.7886, -0.6585, -0.6585, -0.4472, -0.4472, -0.8699, -0.6585, 0.7724, 0.7724, -0.8699, -0.8699, -0.5285, -0.5285, -0.7398, -0.5285, -0.7398, 0.4797, -0.7398, -0.7398, 0.6911, 0.6911, -0.8211, 0.9024, -0.6098, -0.6098, -0.6098, -0.6098, -0.6098, 0.3984, -0.8211, -0.3984, -0.8211, 0.6098, 0.8211, 0.8211, 0.8211, 0.1057, -0.6911, -0.8211, -0.4797, -0.4797, -0.6911, -0.6911, -0.4797, -0.4797, -0.6911, 0.5285, -0.6911, -0.2683, 0.7398, 0.7398, 0.7398, -0.2683, -0.9024, 0.9512, -0.5610, -0.5610, -0.5610, -0.5610, -0.5610, -0.3496, -0.7724, 0.4472, -0.7724, -0.3496, -0.7724, -0.7724, 0.6585, 0.6585, -0.6423, 0.8699, 0.8699, 0.8699, -0.6423, -0.6423, -0.7724, -0.7724, -0.6423, -0.4309, -0.6423, 0.3659, -0.4309, -0.4309, -0.4309, -0.1382, -0.8537, 0.5772, -0.6423, -0.6423, 0.7886, 0.7886, 0.7886, 0.0732, -0.8537, -0.2195, -0.8537, 1.0000, -0.5122, -0.5122, -0.5122, 0.2846, -0.7236, -0.5122, -0.5122, -0.5122, -0.7236, -0.7236, 0.4959, 0.4959, -0.7236, -0.3008]) --------------------- che, come si denota, gli elementi della “lista”, contenuta nella “tupla”, vengono troncati alla quarta cifra dopo la virgola, rispetto a quelli normalizzati in precedenza che avevano otto decimali. Collatz, mi disse che c’era un altro passaggio delicato per far effettuare l’allenamento alla macchina sul train_data, ma siccome era solo un esperimento, aveva deciso di dividere il blocco dei dati di training in modo simile alla quantità delle sequenze di test, cioè in blocchi da 15 sequenze. Per fare questo mi disse, utilizzerò una particolarità di elaborazione dei dati di python la “def”, con la quale ingloberò delle istruzioni che saranno in grado di elaborare l’operazione di suddivisione dei dati desiderata: # divisione tuple di numeri train_window = 15 # gestore di sequenza def create_inout_sequences(input_data, tw): inout_seq = [] L = len(input_data) for i in range(L-tw): train_seq = input_data[i:i+tw] train_label = input_data[i+tw:i+tw+1] inout_seq.append((train_seq ,train_label)) return inout_seq train_inout_seq = create_inout_sequences(train_data_normalized, train_window) print('*** tuple di inout sequence esempio (2) *******') print(train_inout_seq[:2]) print('*****************') Per prima cosa, dimensionò la variabile train_window a 15 (il valore a cui far corrispondere la lunghezza delle tuple) e posi scrisse le istruzioni per la costruzione della funzione “create_inout_sequences”, che prende i dati dalla istruzione train_inout_seq = create_inout_sequences(train_data_normalized, train_window) dove passerà i dati alla funzione in questo modo: input_data = train_data_normalized e tw = train_window) producendo un output di esempio le prime due: *** tuple di inout sequence esempio (2) ******* [(tensor([-0.9675, -1.0000, -0.9024, -0.9837, -0.9350, -0.8862, -0.7561, -0.9675, -0.7073, -0.9187, -0.7886, -0.8699, -0.8699, -0.7398, -0.7398]), tensor([-0.9512])), (tensor([-1.0000, -0.9024, -0.9837, -0.9350, -0.8862, -0.7561, -0.9675, -0.7073, -0.9187, -0.7886, -0.8699, -0.8699, -0.7398, -0.7398, -0.9512]), tensor([-0.8211]))] ***************** dove, mi fece notare, che il sedicesimo elemento rappresentava l’etichetta della prima tupla, mentre la seconda tupla inizia dal secondo elemento, termina al sedicesimo e la sua etichetta è il diciasettesimo… e cosi via… Questa cosa mi ha fatto meditare! Poi, con un grande sorriso, Collatz mi disse “E adesso facciamo un lavoro di Classe!”. E mi fece leggere le seguenti istruzioni: class LSTM(nn.Module): def __init__(self, input_size=1, hidden_layer_size=100, output_size=1): super().__init__() self.hidden_layer_size = hidden_layer_size self.lstm = nn.LSTM(input_size, hidden_layer_size) self.linear = nn.Linear(hidden_layer_size, output_size) self.hidden_cell = (torch.zeros(1,1,self.hidden_layer_size), torch.zeros(1,1,self.hidden_layer_size)) def forward(self, input_seq): lstm_out, self.hidden_cell = self.lstm(input_seq.view(len(input_seq) ,1, -1), self.hidden_cell) predictions = self.linear(lstm_out.view(len(input_seq), -1)) return predictions[-1] al ché, li per li, dissi soltanto “WOW”… e pensai… la cosa si fa complicata! Specialmente dopo aver letto qualche riga dal sito della documentazione di pytorch: https://pytorch.org/docs/stable/generated/torch.nn.LSTM.html Ero rimasto particolarmente sbalordito da cosa potesse significare la seguente concettualizzazione: Comunque, intuitivamente, pensai: c’è in primo layer che riceve un dato alla volta, lo trasferisce ad un layer composto da 100 neuroni, il quale a sua volta elabora i dati e il risultato lo trasferisce ad un layer di output che ha un solo elemento che conterrà di volta in volta il risultato ottimizzato in relazione a delle sequenze di calcolo elaborate ricorsivamente in relazione ad uno scostamento di confronto tra il valore ottenuto e il valore di controllo. Ma il mio amico Collatz, rincarò la dose, dicendomi, adesso che abbiamo lo scheletro del cervello, mettiamoci dentro le idee e mi fece leggere le seguenti istruzioni: model = LSTM() loss_function = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) #------ print('----- modello ----') print(model) Mi disse, Python è un linguaggio che genera oggetti e LSTM è soltanto uno degli oggetti possibili che si possono generare con PyTorch, che in questo caso lo chiameremo semplicemente ”model”. Ora, mi chiese Collatz, che cosa dovrà fare il “model”? Io ci pensai un po’ e poi risposi, dovrà “imparare” in qualche modo a selezionare i dati più simili al “target”! Ovvero, visto che il risultato corretto di ogni operazione nel modello è già predeterminato, confrontiamo questo dato con le operazioni che la rete neurale mi fornisce come risultato “temporale”, ne identifichiamo in qualche modo l’errore e di volta in volta andiamo a correggere il “tiro”. In altri termini, mi disse Collatz, utilizzeremo una serie di formule che, da una parte andranno a calcolare lo scostamento statistico dal target, per esempio utilizzando una funzione che si potrebbe definire “perdita di entropia incrociata”, e dall’altra, riporteremo in ingresso un valore di correzione tramite ad esempio una riparametrazione sigmoidea! Io lo guardai e gli dissi… “Ecco… si!”. Lui sorrise e mi disse: proprio quello che è condensato in quelle di righe di programma di configurazione del “model”, che se vai a vedere l’output è semplicemente descritto così: ----- modello ---- LSTM( (lstm): LSTM(1, 100) (linear): Linear(in_features=100, out_features=1, bias=True) Apperò, dissi io, alla faccia della sintesi! E chiesi cosa significa il termine “bias”? Collaz mi rispose: quello è un modo che viene fornito alla rete neurale per “farsi un opinione”! Lo guardai, sorrisi e gli dissi: anche l’intelligenza artificiale allora si basa su dei “pregiudizi”! Si, si, rispose lui, ma facciamolo lavorare! E mi fece leggere le seguenti righe di programma: # fase di addestramento epochs = 150 for i in range(epochs): for seq, labels in train_inout_seq: optimizer.zero_grad() model.hidden_cell = (torch.zeros(1, 1, model.hidden_layer_size), torch.zeros(1, 1, model.hidden_layer_size)) y_pred = model(seq) single_loss = loss_function(y_pred, labels) single_loss.backward() optimizer.step() if i%25 == 1: print(f'epoch: {i:3} loss: {single_loss.item():10.8f}') print ('°°°°°°°°°°°°°°°°°') print(f'epoch: {i:3} loss: {single_loss.item():10.10f}') print('°°°°°°°°°°°°°°°°°°°') Spiegandomi a grandi linee che voleva cercare di far fare la procedura di allenamento per un numero limitato di sequenze, tanto per provare, limitandola a 150. Quindi per il numero di cicli prefissato, verrà preimpostato il gradiente a zero e verrà generato un tensore che conterrà dei valori scalari in relazione al calcolo dello scostamento per tutte le sequenze di “epochs” e per tutti i valori della tupla in esame, il risultato sarà riposto in una variabile e utilizzato ottimizzandolo, per la “back propagation”. Per farci un idea, mi disse Collatz, si dovrebbe ottenere un risultato simile a questo ogni 25 sequenze: epoch: 1 loss: 0.00829106 epoch: 26 loss: 0.00000873 epoch: 51 loss: 0.01431556 epoch: 76 loss: 0.02613759 epoch: 101 loss: 0.02043977 epoch: 126 loss: 0.00130326 (nota che la stampa dei dati di loss è limitata a 8 decimali) in pratica, per ogni ciclo, l’output dovrebbe essere una cosa analoga questa (l’ultimo risultato riportato con dieci cifre significative dopo la virgola): °°°°°°°°°°°°°°°°° epoch: 149 loss: 0.0008416197 °°°°°°°°°°°°°°°°°°° Ora, mi disse Collatz, la nostra rete dovrebbe avere una opinione sull’andamento dei dati e a questo punto possiamo passare al test di predizione: #-------------- fut_pred = 15 test_inputs = train_data_normalized[-train_window:].tolist() print(test_inputs) #----------------------- Per prima cosa forniamo la dimensione del test (le ultimi quindici variabili), prendiamone i dati normalizzati e vediamo a cosa corrispondono: [1.0, -0.5121951103210449, -0.5121951103210449, -0.5121951103210449, 0.28455284237861633, -0.7235772609710693, -0.5121951103210449, -0.5121951103210449, -0.5121951103210449, -0.7235772609710693, -0.7235772609710693, 0.49593496322631836, 0.49593496322631836, -0.7235772609710693, -0.3008130192756653] Questa lista contiene appunto i dati normalizzati da passare alla rete neurale addestrata per effettuare le previsioni, e il processo avverrà con la seguente modalità: model.eval() for i in range(fut_pred): seq = torch.FloatTensor(test_inputs[-train_window:]) with torch.no_grad(): model.hidden = (torch.zeros(1, 1, model.hidden_layer_size), torch.zeros(1, 1, model.hidden_layer_size)) test_inputs.append(model(seq).item()) #------------ print('--- test input ---') print(test_inputs[fut_pred:]) #-------------------- Verrà definito, nel “dominio dei nomi” il modello di valutazione e tramite un ciclo “for” operante nella lunghezza delle sequenze determinate dalla variabile “fut_pred”, All'interno del ciclo for questi 15 elementi verranno utilizzati per generare il valori di previsione sul primo elemento del set di test, ovvero l'elemento numero 185, Il valore di previsione verrà quindi aggiunto a test_imputs, mediante la funzione “append” . Durante la seconda iterazione, di nuovo gli ultimi 15 elementi verranno utilizzati come input e verrà effettuata una nuova previsione che verrà quindi nuovamente aggiunta a test_inputs e cosi via, il ciclo for verrà eseguito per 15 volte, alla fine del ciclo il “test_inputs”, conterrà 15 elementi normalizzati: --- test input --- [-0.5246923565864563, -0.5111703276634216, -0.6970333456993103, -0.46873635053634644, 0.34659910202026367, 0.36807361245155334, -0.5615038275718689, 0.14165163040161133, -0.3299140930175781, -0.17069603502750397, -0.24251092970371246, -0.20503830909729004, -0.02129334583878517, -0.48219528794288635, 0.041329968720674515] Questi valori, andranno dunque riportati alla configurazione originaria, mediante l’istruzione complementare a quella di normalizzazione: #-------------------- actual_predictions = scaler.inverse_transform(np.array(test_inputs[train_window:] ).reshape(-1, 1)) print ('***** ACTUAL PREDICTIONS') print(actual_predictions) #-------------------------- che darà un risultato simile a questo: ***** ACTUAL PREDICTIONS [[30.23142007] [31.06302485] [19.63244924] [33.67271444] [83.81584477] [85.13652717] [27.9675146 ] [71.21157527] [42.21028328] [52.00219385] [47.58557782] [49.89014399] [61.19045923] [32.84498979] [65.04179308]] Ovviamene il risultato non sarà riportato in numeri interi, ma poco importa (se si volessero riportare i valori in numeri interi c’è una apposita istruzione di python…) A questo punto a Collatz gli si illuminarono gli occhi e disse: finalmente adesso possiamo far disegnare i grafi con le elaborazioni fatte con il modulo di “matplotlib”, aggiunse una ultima istruzione di programma per configurare gli output, e mi fece leggere queste ultime righe in python: prima di stampare i grafici: x = np.arange(185, 200, 1) # grafi dati #-------vista particolare per previsione -------- plt.title('final sequences vs predictions') plt.ylabel('final cycles') plt.grid(True) plt.autoscale(axis='x', tight=True) plt.plot(dataset['n_cycle'][-train_window:]) plt.plot(x,actual_predictions) plt.legend() plt.savefig("Seq_predict.png") plt.show() Scegliemmo di visualizzare il confronto tra i dati del set di test e quelli delle previsioni ottenendo alcuni esempi: ottenuto con una configurazione impostata: fig_size = plt.rcParams["figure.figsize"] fig_size[0] = 15 fig_size[1] = 5 plt.rcParams["figure.figsize"] = fig_size ottenuto senza la configurazione impostata, con la configurazione delle ultime righe del programma. Fu allora che io e Collatz ci guardammo negli occhi e con una risata dicemmo: Se questi sono i risultati, allora è meglio prevedere sempre che i clienti abbiano tanta fame, onde programmare correttamente gli acquisti della materia prima e avvisare il personale che a volte ci sarà del super lavoro…. Oppure dovremmo ripensare meglio i criteri con cui abbiamo istruito la nostra rete neurale! p.s. Ringrazio il mio amico “matematico” Umberto Cibien che ha destato la mia curiosità per la : “Congettura di Collatz” https://umbertocibien.org/math/2021/01/28/la-congettura-di-collatz/ Vuoi Scaricare il progetto Gratis ? Accedi o registrati al portale Clicca qui e scarica il progetto Grazie mille per la lettura

Interpretabilità: Questo concetto riguarda la possibilità di comprendere il modello di machine learning Tecnologie e algoritmi utilizzati Per garantire l'IA spiegabile, vengono utilizzate diverse tecnologie e algoritmi, tra cui l'interpretazione degli algoritmi di machine learning, l'approccio basato su regole Per garantire l’IA spiegabile, vengono utilizzate diverse tecnologie e algoritmi: Interpretazione degli algoritmi di machine learning: Questi strumenti analizzano come il modello prende decisioni, identificando

Queste competenze ti permetteranno di comprendere e sviluppare algoritmi di machine learning. 2. e deep learning Sviluppare competenze in scienza e analisi dei dati Acquisisci esperienza pratica con Padroneggiare i concetti di machine learning e deep learning Il machine learning (ML) e il deep learning Approfondisci il deep learning: Impara a costruire reti neurali, comprese le reti neurali convoluzionali Ecco alcune tendenze chiave: Apprendimento Automatico e Deep Learning: Queste tecnologie stanno migliorando