diff --git a/translations/it/6-NLP/3-Translation-Sentiment/README.md b/translations/it/6-NLP/3-Translation-Sentiment/README.md deleted file mode 100644 index c7bcc162b..000000000 --- a/translations/it/6-NLP/3-Translation-Sentiment/README.md +++ /dev/null @@ -1,190 +0,0 @@ -# Traduzione e analisi del sentimento con ML - -Nelle lezioni precedenti hai imparato come costruire un bot di base usando `TextBlob`, una libreria che incorpora ML dietro le quinte per eseguire compiti NLP di base come l'estrazione di frasi nominali. Un'altra sfida importante nella linguistica computazionale è la _traduzione_ accurata di una frase da una lingua parlata o scritta a un'altra. - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/35/) - -La traduzione è un problema molto complesso aggravato dal fatto che esistono migliaia di lingue, ognuna con regole grammaticali molto diverse. Un approccio consiste nel convertire le regole grammaticali formali di una lingua, come l'inglese, in una struttura non dipendente dalla lingua, e poi tradurla riconvertendola in un'altra lingua. Questo approccio prevede i seguenti passaggi: - -1. **Identificazione**. Identificare o etichettare le parole nella lingua di input come nomi, verbi ecc. -2. **Creare la traduzione**. Produrre una traduzione diretta di ogni parola nel formato della lingua di destinazione. - -### Frase di esempio, Inglese a Irlandese - -In 'Inglese', la frase _I feel happy_ è composta da tre parole nell'ordine: - -- **soggetto** (I) -- **verbo** (feel) -- **aggettivo** (happy) - -Tuttavia, nella lingua 'Irlandese', la stessa frase ha una struttura grammaticale molto diversa - le emozioni come "*happy*" o "*sad*" sono espresse come se fossero *su di te*. - -La frase inglese `I feel happy` in irlandese sarebbe `Tá athas orm`. Una traduzione *letterale* sarebbe `Happy is upon me`. - -Un parlante irlandese che traduce in inglese direbbe `I feel happy`, non `Happy is upon me`, perché comprende il significato della frase, anche se le parole e la struttura della frase sono diverse. - -L'ordine formale per la frase in irlandese è: - -- **verbo** (Tá o is) -- **aggettivo** (athas, o happy) -- **soggetto** (orm, o upon me) - -## Traduzione - -Un programma di traduzione ingenuo potrebbe tradurre solo le parole, ignorando la struttura della frase. - -✅ Se hai imparato una seconda (o terza o più) lingua da adulto, potresti aver iniziato pensando nella tua lingua madre, traducendo un concetto parola per parola nella tua testa nella seconda lingua, e poi pronunciando la tua traduzione. Questo è simile a ciò che fanno i programmi di traduzione ingenua. È importante superare questa fase per raggiungere la fluidità! - -La traduzione ingenua porta a cattive (e talvolta esilaranti) traduzioni errate: `I feel happy` traduce letteralmente a `Mise bhraitheann athas` in irlandese. Questo significa (letteralmente) `me feel happy` e non è una frase irlandese valida. Anche se l'inglese e l'irlandese sono lingue parlate su due isole vicine, sono lingue molto diverse con strutture grammaticali diverse. - -> Puoi guardare alcuni video sulle tradizioni linguistiche irlandesi come [questo](https://www.youtube.com/watch?v=mRIaLSdRMMs) - -### Approcci di machine learning - -Finora, hai imparato l'approccio delle regole formali per l'elaborazione del linguaggio naturale. Un altro approccio è ignorare il significato delle parole, e _invece usare il machine learning per rilevare modelli_. Questo può funzionare nella traduzione se hai molti testi (un *corpus*) o testi (*corpora*) sia nella lingua di origine che in quella di destinazione. - -Ad esempio, considera il caso di *Orgoglio e Pregiudizio*, un noto romanzo inglese scritto da Jane Austen nel 1813. Se consulti il libro in inglese e una traduzione umana del libro in *francese*, potresti rilevare frasi in una lingua che sono tradotte _idiomaticamente_ nell'altra. Lo farai tra un minuto. - -Ad esempio, quando una frase inglese come `I have no money` viene tradotta letteralmente in francese, potrebbe diventare `Je n'ai pas de monnaie`. "Monnaie" è un falso amico francese insidioso, poiché 'money' e 'monnaie' non sono sinonimi. Una traduzione migliore che un umano potrebbe fare sarebbe `Je n'ai pas d'argent`, perché trasmette meglio il significato che non hai soldi (piuttosto che 'spiccioli' che è il significato di 'monnaie'). - -![monnaie](../../../../translated_images/monnaie.606c5fa8369d5c3b3031ef0713e2069485c87985dd475cd9056bdf4c76c1f4b8.it.png) - -> Immagine di [Jen Looper](https://twitter.com/jenlooper) - -Se un modello ML ha abbastanza traduzioni umane su cui costruire un modello, può migliorare l'accuratezza delle traduzioni identificando modelli comuni nei testi che sono stati precedentemente tradotti da esperti parlanti umani di entrambe le lingue. - -### Esercizio - traduzione - -Puoi usare `TextBlob` per tradurre frasi. Prova la famosa prima riga di **Orgoglio e Pregiudizio**: - -```python -from textblob import TextBlob - -blob = TextBlob( - "It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife!" -) -print(blob.translate(to="fr")) - -``` - -`TextBlob` fa un buon lavoro nella traduzione: "C'est une vérité universellement reconnue, qu'un homme célibataire en possession d'une bonne fortune doit avoir besoin d'une femme!". - -Si può sostenere che la traduzione di TextBlob sia molto più precisa, in effetti, rispetto alla traduzione francese del libro del 1932 di V. Leconte e Ch. Pressoir: - -"C'est une vérité universelle qu'un célibataire pourvu d'une belle fortune doit avoir envie de se marier, et, si peu que l'on sache de son sentiment à cet égard, lorsqu'il arrive dans une nouvelle résidence, cette idée est si bien fixée dans l'esprit de ses voisins qu'ils le considèrent sur-le-champ comme la propriété légitime de l'une ou l'autre de leurs filles." - -In questo caso, la traduzione informata da ML fa un lavoro migliore rispetto al traduttore umano che mette inutilmente parole in bocca all'autore originale per 'chiarezza'. - -> Cosa sta succedendo qui? e perché TextBlob è così bravo nella traduzione? Beh, dietro le quinte, sta usando Google translate, un'IA sofisticata in grado di analizzare milioni di frasi per prevedere le stringhe migliori per il compito da svolgere. Non c'è niente di manuale qui e hai bisogno di una connessione internet per usare `blob.translate`. - -✅ Try some more sentences. Which is better, ML or human translation? In which cases? - -## Sentiment analysis - -Another area where machine learning can work very well is sentiment analysis. A non-ML approach to sentiment is to identify words and phrases which are 'positive' and 'negative'. Then, given a new piece of text, calculate the total value of the positive, negative and neutral words to identify the overall sentiment. - -This approach is easily tricked as you may have seen in the Marvin task - the sentence `Great, that was a wonderful waste of time, I'm glad we are lost on this dark road` è una frase sarcastica e di sentimento negativo, ma l'algoritmo semplice rileva 'great', 'wonderful', 'glad' come positivi e 'waste', 'lost' e 'dark' come negativi. Il sentimento complessivo è influenzato da queste parole contrastanti. - -✅ Fermati un attimo e pensa a come trasmettiamo il sarcasmo come parlanti umani. L'inflessione del tono gioca un ruolo importante. Prova a dire la frase "Beh, quel film era fantastico" in modi diversi per scoprire come la tua voce trasmette il significato. - -### Approcci ML - -L'approccio ML consisterebbe nel raccogliere manualmente corpi di testo negativi e positivi - tweet, recensioni di film o qualsiasi cosa in cui l'umano abbia dato un punteggio *e* un'opinione scritta. Poi le tecniche NLP possono essere applicate alle opinioni e ai punteggi, in modo che emergano modelli (ad esempio, le recensioni positive dei film tendono ad avere la frase 'degno di un Oscar' più delle recensioni negative dei film, o le recensioni positive dei ristoranti dicono 'gourmet' molto più di 'disgustoso'). - -> ⚖️ **Esempio**: Se lavorassi nell'ufficio di un politico e ci fosse una nuova legge in discussione, i cittadini potrebbero scrivere all'ufficio con email a favore o contro la particolare nuova legge. Diciamo che ti venga assegnato il compito di leggere le email e ordinarle in 2 pile, *a favore* e *contro*. Se ci fossero molte email, potresti essere sopraffatto dal tentativo di leggerle tutte. Non sarebbe bello se un bot potesse leggerle tutte per te, capirle e dirti in quale pila appartiene ogni email? -> -> Un modo per ottenere ciò è usare il Machine Learning. Addestreresti il modello con una porzione delle email *contro* e una porzione delle email *a favore*. Il modello tenderebbe ad associare frasi e parole con il lato contro e il lato a favore, *ma non comprenderebbe nessuno dei contenuti*, solo che certe parole e modelli erano più probabilmente presenti in un'email *contro* o *a favore*. Potresti testarlo con alcune email che non avevi usato per addestrare il modello, e vedere se arrivava alla stessa conclusione di te. Poi, una volta che fossi soddisfatto dell'accuratezza del modello, potresti elaborare le email future senza dover leggere ciascuna. - -✅ Questo processo ti sembra simile ai processi che hai usato nelle lezioni precedenti? - -## Esercizio - frasi sentimentali - -Il sentimento è misurato con una *polarità* da -1 a 1, dove -1 è il sentimento più negativo e 1 è il più positivo. Il sentimento è anche misurato con un punteggio da 0 a 1 per oggettività (0) e soggettività (1). - -Dai un'altra occhiata a *Orgoglio e Pregiudizio* di Jane Austen. Il testo è disponibile qui su [Project Gutenberg](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm). Il campione sotto mostra un breve programma che analizza il sentimento delle prime e ultime frasi del libro e mostra la polarità del sentimento e il punteggio di soggettività/oggettività. - -Dovresti usare la libreria `TextBlob` (descritta sopra) per determinare `sentiment` (non devi scrivere il tuo calcolatore di sentimenti) nel seguente compito. - -```python -from textblob import TextBlob - -quote1 = """It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want of a wife.""" - -quote2 = """Darcy, as well as Elizabeth, really loved them; and they were both ever sensible of the warmest gratitude towards the persons who, by bringing her into Derbyshire, had been the means of uniting them.""" - -sentiment1 = TextBlob(quote1).sentiment -sentiment2 = TextBlob(quote2).sentiment - -print(quote1 + " has a sentiment of " + str(sentiment1)) -print(quote2 + " has a sentiment of " + str(sentiment2)) -``` - -Vedi il seguente output: - -```output -It is a truth universally acknowledged, that a single man in possession of a good fortune, must be in want # of a wife. has a sentiment of Sentiment(polarity=0.20952380952380953, subjectivity=0.27142857142857146) - -Darcy, as well as Elizabeth, really loved them; and they were - both ever sensible of the warmest gratitude towards the persons - who, by bringing her into Derbyshire, had been the means of - uniting them. has a sentiment of Sentiment(polarity=0.7, subjectivity=0.8) -``` - -## Sfida - controlla la polarità del sentimento - -Il tuo compito è determinare, usando la polarità del sentimento, se *Orgoglio e Pregiudizio* ha più frasi assolutamente positive che negative. Per questo compito, puoi assumere che un punteggio di polarità di 1 o -1 sia rispettivamente assolutamente positivo o negativo. - -**Passaggi:** - -1. Scarica una [copia di Orgoglio e Pregiudizio](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) da Project Gutenberg come file .txt. Rimuovi i metadati all'inizio e alla fine del file, lasciando solo il testo originale -2. Apri il file in Python ed estrai i contenuti come una stringa -3. Crea un TextBlob usando la stringa del libro -4. Analizza ogni frase del libro in un ciclo - 1. Se la polarità è 1 o -1, memorizza la frase in un array o lista di messaggi positivi o negativi -5. Alla fine, stampa tutte le frasi positive e negative (separatamente) e il numero di ciascuna. - -Ecco un esempio di [soluzione](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/3-Translation-Sentiment/solution/notebook.ipynb). - -✅ Verifica delle conoscenze - -1. Il sentimento si basa sulle parole usate nella frase, ma il codice *comprende* le parole? -2. Pensi che la polarità del sentimento sia accurata, o in altre parole, sei *d'accordo* con i punteggi? - 1. In particolare, sei d'accordo o in disaccordo con la polarità assolutamente **positiva** delle seguenti frasi? - * “Che padre eccellente avete, ragazze!” disse lei, quando la porta fu chiusa. - * “La tua esaminazione del signor Darcy è finita, suppongo,” disse Miss Bingley; “e prego qual è il risultato?” “Sono perfettamente convinto che il signor Darcy non ha alcun difetto. - * Come accadono meravigliosamente queste cose! - * Ho la più grande avversione al mondo per quel genere di cose. - * Charlotte è un'eccellente amministratrice, oserei dire. - * “Questo è davvero delizioso! - * Sono così felice! - * La tua idea dei pony è deliziosa. - 2. Le prossime 3 frasi sono state valutate con un sentimento assolutamente positivo, ma a una lettura attenta, non sono frasi positive. Perché l'analisi del sentimento ha pensato che fossero frasi positive? - * Sarò felice, quando la sua permanenza a Netherfield sarà finita!” “Vorrei poter dire qualcosa per confortarti,” rispose Elizabeth; “ma è completamente fuori dal mio potere. - * Se solo potessi vederti felice! - * Il nostro disagio, mia cara Lizzy, è molto grande. - 3. Sei d'accordo o in disaccordo con la polarità assolutamente **negativa** delle seguenti frasi? - - Tutti sono disgustati dal suo orgoglio. - - “Vorrei sapere come si comporta tra gli estranei.” “Allora sentirai, ma preparati a qualcosa di molto terribile. - - La pausa fu per i sentimenti di Elizabeth terribile. - - Sarebbe terribile! - -✅ Qualsiasi appassionato di Jane Austen capirà che spesso usa i suoi libri per criticare gli aspetti più ridicoli della società della Reggenza inglese. Elizabeth Bennett, il personaggio principale in *Orgoglio e Pregiudizio*, è una acuta osservatrice sociale (come l'autrice) e il suo linguaggio è spesso fortemente sfumato. Anche Mr. Darcy (l'interesse amoroso nella storia) nota l'uso giocoso e scherzoso del linguaggio di Elizabeth: "Ho avuto il piacere della tua conoscenza abbastanza a lungo per sapere che trovi grande divertimento nell'affermare occasionalmente opinioni che in realtà non sono le tue." - ---- - -## 🚀Sfida - -Puoi rendere Marvin ancora migliore estraendo altre caratteristiche dall'input dell'utente? - -## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/36/) - -## Revisione & Autoapprendimento - -Ci sono molti modi per estrarre il sentimento dal testo. Pensa alle applicazioni aziendali che potrebbero fare uso di questa tecnica. Pensa a come può andare storto. Leggi di più sui sistemi sofisticati pronti per l'impresa che analizzano il sentimento come [Azure Text Analysis](https://docs.microsoft.com/azure/cognitive-services/Text-Analytics/how-tos/text-analytics-how-to-sentiment-analysis?tabs=version-3-1?WT.mc_id=academic-77952-leestott). Prova alcune delle frasi di Orgoglio e Pregiudizio sopra e vedi se riesce a rilevare le sfumature. - -## Compito - -[Licenza poetica](assignment.md) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/3-Translation-Sentiment/assignment.md b/translations/it/6-NLP/3-Translation-Sentiment/assignment.md deleted file mode 100644 index 921abff6e..000000000 --- a/translations/it/6-NLP/3-Translation-Sentiment/assignment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Licenza poetica - -## Istruzioni - -In [questo notebook](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency) puoi trovare oltre 500 poesie di Emily Dickinson precedentemente analizzate per sentiment utilizzando Azure text analytics. Utilizzando questo dataset, analizzalo utilizzando le tecniche descritte nella lezione. Il sentiment suggerito di una poesia corrisponde alla decisione del servizio Azure più sofisticato? Perché o perché no, secondo te? Qualcosa ti sorprende? - -## Griglia di valutazione - -| Criteri | Esemplare | Adeguato | Da migliorare | -| -------- | ----------------------------------------------------------------------- | ------------------------------------------------------ | ------------------------ | -| | Viene presentato un notebook con un'analisi solida di un campione dell'autore | Il notebook è incompleto o non esegue l'analisi | Non viene presentato nessun notebook | - -**Dichiarazione di esclusione di responsabilità**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di tenere presente che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/3-Translation-Sentiment/solution/Julia/README.md b/translations/it/6-NLP/3-Translation-Sentiment/solution/Julia/README.md deleted file mode 100644 index 572966368..000000000 --- a/translations/it/6-NLP/3-Translation-Sentiment/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/3-Translation-Sentiment/solution/R/README.md b/translations/it/6-NLP/3-Translation-Sentiment/solution/R/README.md deleted file mode 100644 index 646e38fab..000000000 --- a/translations/it/6-NLP/3-Translation-Sentiment/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzata basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali fraintendimenti o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/4-Hotel-Reviews-1/README.md b/translations/it/6-NLP/4-Hotel-Reviews-1/README.md deleted file mode 100644 index 74a65139b..000000000 --- a/translations/it/6-NLP/4-Hotel-Reviews-1/README.md +++ /dev/null @@ -1,294 +0,0 @@ -# Analisi del sentiment con recensioni di hotel - elaborazione dei dati - -In questa sezione utilizzerai le tecniche apprese nelle lezioni precedenti per fare un'analisi esplorativa dei dati di un grande dataset. Una volta che avrai una buona comprensione dell'utilità delle varie colonne, imparerai: - -- come rimuovere le colonne non necessarie -- come calcolare nuovi dati basati sulle colonne esistenti -- come salvare il dataset risultante per l'uso nella sfida finale - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/37/) - -### Introduzione - -Finora hai imparato come i dati testuali siano molto diversi dai dati numerici. Se il testo è stato scritto o parlato da un umano, può essere analizzato per trovare pattern e frequenze, sentimenti e significati. Questa lezione ti introduce a un dataset reale con una sfida reale: **[515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe)** e include una [licenza CC0: Public Domain](https://creativecommons.org/publicdomain/zero/1.0/). È stato estratto da Booking.com da fonti pubbliche. Il creatore del dataset è Jiashen Liu. - -### Preparazione - -Avrai bisogno di: - -* La capacità di eseguire notebook .ipynb usando Python 3 -* pandas -* NLTK, [che dovresti installare localmente](https://www.nltk.org/install.html) -* Il dataset disponibile su Kaggle [515K Hotel Reviews Data in Europe](https://www.kaggle.com/jiashenliu/515k-hotel-reviews-data-in-europe). È di circa 230 MB non compresso. Scaricalo nella cartella root `/data` associata a queste lezioni di NLP. - -## Analisi esplorativa dei dati - -Questa sfida presume che tu stia costruendo un bot di raccomandazione per hotel utilizzando l'analisi del sentiment e i punteggi delle recensioni degli ospiti. Il dataset che utilizzerai include recensioni di 1493 hotel diversi in 6 città. - -Utilizzando Python, un dataset di recensioni di hotel e l'analisi del sentiment di NLTK potresti scoprire: - -* Quali sono le parole e le frasi più frequentemente usate nelle recensioni? -* I *tag* ufficiali che descrivono un hotel correlano con i punteggi delle recensioni (ad esempio, ci sono più recensioni negative per un particolare hotel da parte di *Famiglie con bambini piccoli* rispetto a *Viaggiatori solitari*, forse indicando che è migliore per i *Viaggiatori solitari*)? -* I punteggi di sentiment di NLTK 'concordano' con il punteggio numerico del recensore dell'hotel? - -#### Dataset - -Esploriamo il dataset che hai scaricato e salvato localmente. Apri il file in un editor come VS Code o anche Excel. - -Le intestazioni nel dataset sono le seguenti: - -*Hotel_Address, Additional_Number_of_Scoring, Review_Date, Average_Score, Hotel_Name, Reviewer_Nationality, Negative_Review, Review_Total_Negative_Word_Counts, Total_Number_of_Reviews, Positive_Review, Review_Total_Positive_Word_Counts, Total_Number_of_Reviews_Reviewer_Has_Given, Reviewer_Score, Tags, days_since_review, lat, lng* - -Eccole raggruppate in un modo che potrebbe essere più facile da esaminare: -##### Colonne dell'hotel - -* `Hotel_Name`, `Hotel_Address`, `lat` (latitudine), `lng` (longitudine) - * Utilizzando *lat* e *lng* potresti tracciare una mappa con Python che mostra le posizioni degli hotel (forse codificate a colori per recensioni negative e positive) - * Hotel_Address non è ovviamente utile per noi, e probabilmente lo sostituiremo con un paese per una più facile ordinazione e ricerca - -**Colonne Meta-review dell'hotel** - -* `Average_Score` - * Secondo il creatore del dataset, questa colonna è il *Punteggio Medio dell'hotel, calcolato in base all'ultimo commento dell'ultimo anno*. Questo sembra un modo insolito di calcolare il punteggio, ma è il dato estratto, quindi per ora possiamo prenderlo per buono. - - ✅ In base alle altre colonne di questi dati, riesci a pensare a un altro modo per calcolare il punteggio medio? - -* `Total_Number_of_Reviews` - * Il numero totale di recensioni che questo hotel ha ricevuto - non è chiaro (senza scrivere del codice) se questo si riferisce alle recensioni nel dataset. -* `Additional_Number_of_Scoring` - * Questo significa che è stato dato un punteggio di recensione ma non è stata scritta alcuna recensione positiva o negativa dal recensore - -**Colonne della recensione** - -- `Reviewer_Score` - - Questo è un valore numerico con al massimo 1 decimale tra i valori minimi e massimi di 2.5 e 10 - - Non è spiegato perché 2.5 è il punteggio più basso possibile -- `Negative_Review` - - Se un recensore non ha scritto nulla, questo campo avrà "**No Negative**" - - Nota che un recensore può scrivere una recensione positiva nella colonna delle recensioni negative (ad esempio "non c'è niente di negativo in questo hotel") -- `Review_Total_Negative_Word_Counts` - - Maggiore è il conteggio delle parole negative, minore è il punteggio (senza controllare la sentimentalità) -- `Positive_Review` - - Se un recensore non ha scritto nulla, questo campo avrà "**No Positive**" - - Nota che un recensore può scrivere una recensione negativa nella colonna delle recensioni positive (ad esempio "non c'è niente di buono in questo hotel") -- `Review_Total_Positive_Word_Counts` - - Maggiore è il conteggio delle parole positive, maggiore è il punteggio (senza controllare la sentimentalità) -- `Review_Date` e `days_since_review` - - Si potrebbe applicare una misura di freschezza o stantio a una recensione (le recensioni più vecchie potrebbero non essere accurate come quelle più recenti perché la gestione dell'hotel è cambiata, sono state fatte ristrutturazioni, è stata aggiunta una piscina ecc.) -- `Tags` - - Questi sono brevi descrittori che un recensore può selezionare per descrivere il tipo di ospite che erano (ad esempio, solitario o famiglia), il tipo di stanza che avevano, la durata del soggiorno e come è stata inviata la recensione. - - Sfortunatamente, l'uso di questi tag è problematico, consulta la sezione qui sotto che discute la loro utilità - -**Colonne del recensore** - -- `Total_Number_of_Reviews_Reviewer_Has_Given` - - Questo potrebbe essere un fattore in un modello di raccomandazione, ad esempio, se potessi determinare che i recensori più prolifici con centinaia di recensioni erano più propensi a essere negativi piuttosto che positivi. Tuttavia, il recensore di una particolare recensione non è identificato con un codice univoco e quindi non può essere collegato a un set di recensioni. Ci sono 30 recensori con 100 o più recensioni, ma è difficile vedere come questo possa aiutare il modello di raccomandazione. -- `Reviewer_Nationality` - - Alcune persone potrebbero pensare che alcune nazionalità siano più propense a dare una recensione positiva o negativa a causa di una propensione nazionale. Fai attenzione a costruire tali opinioni aneddotiche nei tuoi modelli. Questi sono stereotipi nazionali (e talvolta razziali), e ogni recensore era un individuo che ha scritto una recensione basata sulla sua esperienza. Potrebbe essere stata filtrata attraverso molte lenti come i loro soggiorni precedenti in hotel, la distanza percorsa e il loro temperamento personale. Pensare che la loro nazionalità sia stata la ragione di un punteggio di recensione è difficile da giustificare. - -##### Esempi - -| Punteggio Medio | Numero Totale di Recensioni | Punteggio del Recensore | Recensione
Negativa | Recensione Positiva | Tag | -| -------------- | ---------------------- | ---------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | ----------------------------------------------------------------------------------------- | -| 7.8 | 1945 | 2.5 | Questo attualmente non è un hotel ma un cantiere sono stato terrorizzato fin dalle prime ore del mattino e per tutto il giorno con rumori di costruzione inaccettabili mentre riposavo dopo un lungo viaggio e lavoravo nella stanza le persone lavoravano tutto il giorno con martelli pneumatici nelle stanze adiacenti ho chiesto un cambio di stanza ma non c'era una stanza silenziosa disponibile per peggiorare le cose sono stato sovraccaricato ho effettuato il check-out la sera poiché dovevo partire molto presto e ho ricevuto una fattura appropriata un giorno dopo l'hotel ha effettuato un altro addebito senza il mio consenso in eccesso rispetto al prezzo prenotato è un posto terribile non punirti prenotando qui | Niente Posto terribile Stai lontano | Viaggio d'affari Coppia Camera Doppia Standard Soggiorno di 2 notti | - -Come puoi vedere, questo ospite non ha avuto un soggiorno felice in questo hotel. L'hotel ha un buon punteggio medio di 7.8 e 1945 recensioni, ma questo recensore gli ha dato 2.5 e ha scritto 115 parole su quanto negativa fosse la loro permanenza. Se non avessero scritto nulla nella colonna Positive_Review, potresti dedurre che non ci fosse nulla di positivo, ma ahimè hanno scritto 7 parole di avvertimento. Se contassimo solo le parole invece del significato o del sentiment delle parole, potremmo avere una visione distorta dell'intento del recensore. Stranamente, il loro punteggio di 2.5 è confuso, perché se quel soggiorno in hotel era così brutto, perché dare qualche punto? Investigando il dataset da vicino, vedrai che il punteggio più basso possibile è 2.5, non 0. Il punteggio più alto possibile è 10. - -##### Tag - -Come accennato sopra, a prima vista, l'idea di utilizzare `Tags` per categorizzare i dati ha senso. Sfortunatamente questi tag non sono standardizzati, il che significa che in un dato hotel, le opzioni potrebbero essere *Camera singola*, *Camera doppia*, e *Camera matrimoniale*, ma nel prossimo hotel, sono *Camera Singola Deluxe*, *Camera Queen Classica*, e *Camera King Executive*. Potrebbero essere le stesse cose, ma ci sono così tante variazioni che la scelta diventa: - -1. Tentare di cambiare tutti i termini a uno standard unico, il che è molto difficile, perché non è chiaro quale sarebbe il percorso di conversione in ogni caso (ad esempio, *Camera singola classica* si mappa a *Camera singola* ma *Camera Queen Superior con Vista Giardino o Città* è molto più difficile da mappare) - -1. Possiamo adottare un approccio NLP e misurare la frequenza di certi termini come *Solitario*, *Viaggiatore d'affari*, o *Famiglia con bambini piccoli* mentre si applicano a ciascun hotel, e considerarlo nel modello di raccomandazione - -I tag sono di solito (ma non sempre) un singolo campo contenente un elenco di 5 o 6 valori separati da virgole allineati a *Tipo di viaggio*, *Tipo di ospiti*, *Tipo di stanza*, *Numero di notti*, e *Tipo di dispositivo su cui è stata inviata la recensione*. Tuttavia, poiché alcuni recensori non riempiono ogni campo (potrebbero lasciarne uno vuoto), i valori non sono sempre nello stesso ordine. - -Come esempio, prendi *Tipo di gruppo*. Ci sono 1025 possibilità uniche in questo campo nella colonna `Tags`, e sfortunatamente solo alcune di esse si riferiscono a un gruppo (alcune sono il tipo di stanza ecc.). Se filtri solo quelli che menzionano la famiglia, i risultati contengono molti tipi di *Camera famiglia*. Se includi il termine *con*, cioè conti i valori *Famiglia con*, i risultati sono migliori, con oltre 80.000 dei 515.000 risultati contenenti la frase "Famiglia con bambini piccoli" o "Famiglia con bambini più grandi". - -Questo significa che la colonna dei tag non è completamente inutile per noi, ma ci vorrà un po' di lavoro per renderla utile. - -##### Punteggio medio dell'hotel - -Ci sono un certo numero di stranezze o discrepanze con il dataset che non riesco a capire, ma sono illustrate qui in modo che tu ne sia consapevole quando costruisci i tuoi modelli. Se riesci a capirlo, faccelo sapere nella sezione di discussione! - -Il dataset ha le seguenti colonne relative al punteggio medio e al numero di recensioni: - -1. Hotel_Name -2. Additional_Number_of_Scoring -3. Average_Score -4. Total_Number_of_Reviews -5. Reviewer_Score - -L'hotel singolo con il maggior numero di recensioni in questo dataset è *Britannia International Hotel Canary Wharf* con 4789 recensioni su 515.000. Ma se guardiamo il valore `Total_Number_of_Reviews` per questo hotel, è 9086. Potresti dedurre che ci sono molti più punteggi senza recensioni, quindi forse dovremmo aggiungere il valore della colonna `Additional_Number_of_Scoring`. Quel valore è 2682, e aggiungendolo a 4789 otteniamo 7.471 che è ancora 1615 meno di `Total_Number_of_Reviews`. - -Se prendi le colonne `Average_Score`, potresti dedurre che è la media delle recensioni nel dataset, ma la descrizione da Kaggle è "*Punteggio Medio dell'hotel, calcolato in base all'ultimo commento dell'ultimo anno*". Questo non sembra molto utile, ma possiamo calcolare la nostra media basata sui punteggi delle recensioni nel dataset. Utilizzando lo stesso hotel come esempio, il punteggio medio dell'hotel è dato come 7.1 ma il punteggio calcolato (media del punteggio del recensore *nel* dataset) è 6.8. Questo è vicino, ma non lo stesso valore, e possiamo solo supporre che i punteggi dati nelle recensioni `Additional_Number_of_Scoring` abbiano aumentato la media a 7.1. Sfortunatamente, senza un modo per testare o provare tale affermazione, è difficile usare o fidarsi di `Average_Score`, `Additional_Number_of_Scoring` e `Total_Number_of_Reviews` quando si basano su, o si riferiscono a, dati che non abbiamo. - -Per complicare ulteriormente le cose, l'hotel con il secondo maggior numero di recensioni ha un punteggio medio calcolato di 8.12 e il dataset `Average_Score` è 8.1. È questa coincidenza corretta o è la discrepanza del primo hotel? - -Nel caso in cui questi hotel potrebbero essere un'eccezione, e che forse la maggior parte dei valori si allineano (ma alcuni no per qualche ragione), scriveremo un breve programma successivo per esplorare i valori nel dataset e determinare l'uso corretto (o non uso) dei valori. - -> 🚨 Una nota di cautela -> -> Quando lavori con questo dataset scriverai codice che calcola qualcosa dal testo senza dover leggere o analizzare il testo tu stesso. Questa è l'essenza dell'NLP, interpretare il significato o il sentiment senza dover farlo fare a un umano. Tuttavia, è possibile che tu legga alcune delle recensioni negative. Ti esorto a non farlo, perché non è necessario. Alcune di esse sono sciocche o irrilevanti recensioni negative di hotel, come "Il tempo non era buono", qualcosa al di fuori del controllo dell'hotel, o di chiunque. Ma c'è anche un lato oscuro in alcune recensioni. A volte le recensioni negative sono razziste, sessiste o discriminatorie per età. Questo è sfortunato ma prevedibile in un dataset estratto da un sito pubblico. Alcuni recensori lasciano recensioni che troveresti di cattivo gusto, scomode o sconvolgenti. Meglio lasciare che il codice misuri il sentiment piuttosto che leggerle tu stesso e rimanere sconvolto. Detto ciò, è una minoranza che scrive tali cose, ma esistono comunque. - -## Esercizio - Esplorazione dei dati -### Carica i dati - -Basta esaminare visivamente i dati, ora scriverai del codice e otterrai delle risposte! Questa sezione utilizza la libreria pandas. Il tuo primissimo compito è assicurarti di poter caricare e leggere i dati CSV. La libreria pandas ha un caricatore CSV veloce, e il risultato è posizionato in un dataframe, come nelle lezioni precedenti. Il CSV che stiamo caricando ha oltre mezzo milione di righe, ma solo 17 colonne. Pandas ti offre molti modi potenti per interagire con un dataframe, inclusa la possibilità di eseguire operazioni su ogni riga. - -Da qui in avanti in questa lezione, ci saranno frammenti di codice e alcune spiegazioni del codice e alcune discussioni su cosa significano i risultati. Usa il notebook _notebook.ipynb_ incluso per il tuo codice. - -Iniziamo con il caricamento del file di dati che utilizzerai: - -```python -# Load the hotel reviews from CSV -import pandas as pd -import time -# importing time so the start and end time can be used to calculate file loading time -print("Loading data file now, this could take a while depending on file size") -start = time.time() -# df is 'DataFrame' - make sure you downloaded the file to the data folder -df = pd.read_csv('../../data/Hotel_Reviews.csv') -end = time.time() -print("Loading took " + str(round(end - start, 2)) + " seconds") -``` - -Ora che i dati sono caricati, possiamo eseguire alcune operazioni su di essi. Tieni questo codice in cima al tuo programma per la prossima parte. - -## Esplora i dati - -In questo caso, i dati sono già *puliti*, il che significa che sono pronti per essere utilizzati e non contengono caratteri in altre lingue che potrebbero far inciampare gli algoritmi che si aspettano solo caratteri inglesi. - -✅ Potresti dover lavor -righe hanno valori della colonna `Positive_Review` di "No Positive" 9. Calcola e stampa quante righe hanno valori della colonna `Positive_Review` di "No Positive" **e** valori della colonna `Negative_Review` di "No Negative" ### Risposte al codice 1. Stampa la *forma* del data frame che hai appena caricato (la forma è il numero di righe e colonne) ```python - print("The shape of the data (rows, cols) is " + str(df.shape)) - > The shape of the data (rows, cols) is (515738, 17) - ``` 2. Calcola la frequenza delle nazionalità dei recensori: 1. Quanti valori distinti ci sono per la colonna `Reviewer_Nationality` e quali sono? 2. Qual è la nazionalità del recensore più comune nel dataset (stampa il paese e il numero di recensioni)? ```python - # value_counts() creates a Series object that has index and values in this case, the country and the frequency they occur in reviewer nationality - nationality_freq = df["Reviewer_Nationality"].value_counts() - print("There are " + str(nationality_freq.size) + " different nationalities") - # print first and last rows of the Series. Change to nationality_freq.to_string() to print all of the data - print(nationality_freq) - - There are 227 different nationalities - United Kingdom 245246 - United States of America 35437 - Australia 21686 - Ireland 14827 - United Arab Emirates 10235 - ... - Comoros 1 - Palau 1 - Northern Mariana Islands 1 - Cape Verde 1 - Guinea 1 - Name: Reviewer_Nationality, Length: 227, dtype: int64 - ``` 3. Quali sono le successive 10 nazionalità più frequentemente trovate e il loro conteggio di frequenza? ```python - print("The highest frequency reviewer nationality is " + str(nationality_freq.index[0]).strip() + " with " + str(nationality_freq[0]) + " reviews.") - # Notice there is a leading space on the values, strip() removes that for printing - # What is the top 10 most common nationalities and their frequencies? - print("The next 10 highest frequency reviewer nationalities are:") - print(nationality_freq[1:11].to_string()) - - The highest frequency reviewer nationality is United Kingdom with 245246 reviews. - The next 10 highest frequency reviewer nationalities are: - United States of America 35437 - Australia 21686 - Ireland 14827 - United Arab Emirates 10235 - Saudi Arabia 8951 - Netherlands 8772 - Switzerland 8678 - Germany 7941 - Canada 7894 - France 7296 - ``` 3. Qual è stato l'hotel più recensito per ciascuna delle prime 10 nazionalità dei recensori? ```python - # What was the most frequently reviewed hotel for the top 10 nationalities - # Normally with pandas you will avoid an explicit loop, but wanted to show creating a new dataframe using criteria (don't do this with large amounts of data because it could be very slow) - for nat in nationality_freq[:10].index: - # First, extract all the rows that match the criteria into a new dataframe - nat_df = df[df["Reviewer_Nationality"] == nat] - # Now get the hotel freq - freq = nat_df["Hotel_Name"].value_counts() - print("The most reviewed hotel for " + str(nat).strip() + " was " + str(freq.index[0]) + " with " + str(freq[0]) + " reviews.") - - The most reviewed hotel for United Kingdom was Britannia International Hotel Canary Wharf with 3833 reviews. - The most reviewed hotel for United States of America was Hotel Esther a with 423 reviews. - The most reviewed hotel for Australia was Park Plaza Westminster Bridge London with 167 reviews. - The most reviewed hotel for Ireland was Copthorne Tara Hotel London Kensington with 239 reviews. - The most reviewed hotel for United Arab Emirates was Millennium Hotel London Knightsbridge with 129 reviews. - The most reviewed hotel for Saudi Arabia was The Cumberland A Guoman Hotel with 142 reviews. - The most reviewed hotel for Netherlands was Jaz Amsterdam with 97 reviews. - The most reviewed hotel for Switzerland was Hotel Da Vinci with 97 reviews. - The most reviewed hotel for Germany was Hotel Da Vinci with 86 reviews. - The most reviewed hotel for Canada was St James Court A Taj Hotel London with 61 reviews. - ``` 4. Quante recensioni ci sono per hotel (conteggio di frequenza degli hotel) nel dataset? ```python - # First create a new dataframe based on the old one, removing the uneeded columns - hotel_freq_df = df.drop(["Hotel_Address", "Additional_Number_of_Scoring", "Review_Date", "Average_Score", "Reviewer_Nationality", "Negative_Review", "Review_Total_Negative_Word_Counts", "Positive_Review", "Review_Total_Positive_Word_Counts", "Total_Number_of_Reviews_Reviewer_Has_Given", "Reviewer_Score", "Tags", "days_since_review", "lat", "lng"], axis = 1) - - # Group the rows by Hotel_Name, count them and put the result in a new column Total_Reviews_Found - hotel_freq_df['Total_Reviews_Found'] = hotel_freq_df.groupby('Hotel_Name').transform('count') - - # Get rid of all the duplicated rows - hotel_freq_df = hotel_freq_df.drop_duplicates(subset = ["Hotel_Name"]) - display(hotel_freq_df) - ``` | Nome_Hotel | Numero_Totale_di_Recensioni | Recensioni_Trovate | | :----------------------------------------: | :---------------------: | :-----------------: | | Britannia International Hotel Canary Wharf | 9086 | 4789 | | Park Plaza Westminster Bridge London | 12158 | 4169 | | Copthorne Tara Hotel London Kensington | 7105 | 3578 | | ... | ... | ... | | Mercure Paris Porte d Orleans | 110 | 10 | | Hotel Wagner | 135 | 10 | | Hotel Gallitzinberg | 173 | 8 | Potresti notare che i risultati *contati nel dataset* non corrispondono al valore in `Total_Number_of_Reviews`. Non è chiaro se questo valore nel dataset rappresentasse il numero totale di recensioni che l'hotel aveva, ma non tutte sono state estratte, o qualche altro calcolo. `Total_Number_of_Reviews` non è utilizzato nel modello a causa di questa incertezza. 5. Sebbene ci sia una colonna `Average_Score` per ciascun hotel nel dataset, puoi anche calcolare un punteggio medio (ottenendo la media di tutti i punteggi dei recensori nel dataset per ciascun hotel). Aggiungi una nuova colonna al tuo dataframe con l'intestazione della colonna `Calc_Average_Score` che contiene quella media calcolata. Stampa le colonne `Hotel_Name`, `Average_Score` e `Calc_Average_Score`. ```python - # define a function that takes a row and performs some calculation with it - def get_difference_review_avg(row): - return row["Average_Score"] - row["Calc_Average_Score"] - - # 'mean' is mathematical word for 'average' - df['Calc_Average_Score'] = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1) - - # Add a new column with the difference between the two average scores - df["Average_Score_Difference"] = df.apply(get_difference_review_avg, axis = 1) - - # Create a df without all the duplicates of Hotel_Name (so only 1 row per hotel) - review_scores_df = df.drop_duplicates(subset = ["Hotel_Name"]) - - # Sort the dataframe to find the lowest and highest average score difference - review_scores_df = review_scores_df.sort_values(by=["Average_Score_Difference"]) - - display(review_scores_df[["Average_Score_Difference", "Average_Score", "Calc_Average_Score", "Hotel_Name"]]) - ``` Potresti anche chiederti del valore `Average_Score` e perché a volte è diverso dal punteggio medio calcolato. Poiché non possiamo sapere perché alcuni valori corrispondono, ma altri hanno una differenza, è più sicuro in questo caso utilizzare i punteggi delle recensioni che abbiamo per calcolare la media da soli. Detto questo, le differenze sono solitamente molto piccole, ecco gli hotel con la maggiore deviazione dalla media del dataset e la media calcolata: | Differenza_Punteggio_Medio | Punteggio_Medio | Calc_Average_Score | Nome_Hotel | | :----------------------: | :-----------: | :----------------: | ------------------------------------------: | | -0.8 | 7.7 | 8.5 | Best Western Hotel Astoria | | -0.7 | 8.8 | 9.5 | Hotel Stendhal Place Vend me Paris MGallery | | -0.7 | 7.5 | 8.2 | Mercure Paris Porte d Orleans | | -0.7 | 7.9 | 8.6 | Renaissance Paris Vendome Hotel | | -0.5 | 7.0 | 7.5 | Hotel Royal Elys es | | ... | ... | ... | ... | | 0.7 | 7.5 | 6.8 | Mercure Paris Op ra Faubourg Montmartre | | 0.8 | 7.1 | 6.3 | Holiday Inn Paris Montparnasse Pasteur | | 0.9 | 6.8 | 5.9 | Villa Eugenie | | 0.9 | 8.6 | 7.7 | MARQUIS Faubourg St Honor Relais Ch teaux | | 1.3 | 7.2 | 5.9 | Kube Hotel Ice Bar | Con solo 1 hotel che ha una differenza di punteggio superiore a 1, significa che probabilmente possiamo ignorare la differenza e utilizzare il punteggio medio calcolato. 6. Calcola e stampa quante righe hanno valori della colonna `Negative_Review` di "No Negative" 7. Calcola e stampa quante righe hanno valori della colonna `Positive_Review` di "No Positive" 8. Calcola e stampa quante righe hanno valori della colonna `Positive_Review` di "No Positive" **e** valori della colonna `Negative_Review` di "No Negative" ```python - # with lambdas: - start = time.time() - no_negative_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" else False , axis=1) - print("Number of No Negative reviews: " + str(len(no_negative_reviews[no_negative_reviews == True].index))) - - no_positive_reviews = df.apply(lambda x: True if x['Positive_Review'] == "No Positive" else False , axis=1) - print("Number of No Positive reviews: " + str(len(no_positive_reviews[no_positive_reviews == True].index))) - - both_no_reviews = df.apply(lambda x: True if x['Negative_Review'] == "No Negative" and x['Positive_Review'] == "No Positive" else False , axis=1) - print("Number of both No Negative and No Positive reviews: " + str(len(both_no_reviews[both_no_reviews == True].index))) - end = time.time() - print("Lambdas took " + str(round(end - start, 2)) + " seconds") - - Number of No Negative reviews: 127890 - Number of No Positive reviews: 35946 - Number of both No Negative and No Positive reviews: 127 - Lambdas took 9.64 seconds - ``` ## Un altro modo Un altro modo per contare gli elementi senza Lambdas, e utilizzare sum per contare le righe: ```python - # without lambdas (using a mixture of notations to show you can use both) - start = time.time() - no_negative_reviews = sum(df.Negative_Review == "No Negative") - print("Number of No Negative reviews: " + str(no_negative_reviews)) - - no_positive_reviews = sum(df["Positive_Review"] == "No Positive") - print("Number of No Positive reviews: " + str(no_positive_reviews)) - - both_no_reviews = sum((df.Negative_Review == "No Negative") & (df.Positive_Review == "No Positive")) - print("Number of both No Negative and No Positive reviews: " + str(both_no_reviews)) - - end = time.time() - print("Sum took " + str(round(end - start, 2)) + " seconds") - - Number of No Negative reviews: 127890 - Number of No Positive reviews: 35946 - Number of both No Negative and No Positive reviews: 127 - Sum took 0.19 seconds - ``` Potresti aver notato che ci sono 127 righe che hanno sia valori "No Negative" che "No Positive" per le colonne `Negative_Review` e `Positive_Review` rispettivamente. Ciò significa che il recensore ha dato all'hotel un punteggio numerico, ma ha rifiutato di scrivere una recensione positiva o negativa. Fortunatamente si tratta di una piccola quantità di righe (127 su 515738, ovvero lo 0,02%), quindi probabilmente non influenzerà il nostro modello o i risultati in una direzione particolare, ma potresti non aspettarti che un set di dati di recensioni abbia righe senza recensioni, quindi vale la pena esplorare i dati per scoprire righe come questa. Ora che hai esplorato il dataset, nella prossima lezione filtrerai i dati e aggiungerai un'analisi del sentiment. --- ## 🚀Sfida Questa lezione dimostra, come abbiamo visto nelle lezioni precedenti, quanto sia fondamentale comprendere i tuoi dati e le loro particolarità prima di eseguire operazioni su di essi. I dati basati su testo, in particolare, richiedono un'attenta analisi. Scava in vari set di dati ricchi di testo e vedi se riesci a scoprire aree che potrebbero introdurre bias o sentiment distorti in un modello. ## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/38/) ## Revisione e studio autonomo Segui [questo percorso di apprendimento su NLP](https://docs.microsoft.com/learn/paths/explore-natural-language-processing/?WT.mc_id=academic-77952-leestott) per scoprire strumenti da provare quando costruisci modelli basati su discorsi e testi. ## Compito [NLTK](assignment.md) - -**Dichiarazione di non responsabilità**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Pur cercando di garantire la massima accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali fraintendimenti o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/4-Hotel-Reviews-1/assignment.md b/translations/it/6-NLP/4-Hotel-Reviews-1/assignment.md deleted file mode 100644 index 7153e692d..000000000 --- a/translations/it/6-NLP/4-Hotel-Reviews-1/assignment.md +++ /dev/null @@ -1,8 +0,0 @@ -# NLTK - -## Istruzioni - -NLTK è una libreria ben nota per l'uso nella linguistica computazionale e nell'NLP. Approfitta di questa opportunità per leggere il '[libro NLTK](https://www.nltk.org/book/)' e provare i suoi esercizi. In questo compito non valutato, avrai l'opportunità di conoscere più a fondo questa libreria. - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Anche se ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md b/translations/it/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md deleted file mode 100644 index 11af8dcf2..000000000 --- a/translations/it/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzati basati su intelligenza artificiale. Sebbene ci sforziamo di garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/4-Hotel-Reviews-1/solution/R/README.md b/translations/it/6-NLP/4-Hotel-Reviews-1/solution/R/README.md deleted file mode 100644 index d3081994b..000000000 --- a/translations/it/6-NLP/4-Hotel-Reviews-1/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/5-Hotel-Reviews-2/README.md b/translations/it/6-NLP/5-Hotel-Reviews-2/README.md deleted file mode 100644 index 93ae56a0e..000000000 --- a/translations/it/6-NLP/5-Hotel-Reviews-2/README.md +++ /dev/null @@ -1,377 +0,0 @@ -# Analisi del sentiment con recensioni di hotel - -Ora che hai esplorato il dataset in dettaglio, è il momento di filtrare le colonne e poi utilizzare tecniche di NLP sul dataset per ottenere nuove informazioni sugli hotel. -## [Pre-lecture quiz](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/39/) - -### Operazioni di Filtraggio e Analisi del Sentiment - -Come avrai notato, il dataset presenta alcuni problemi. Alcune colonne sono piene di informazioni inutili, altre sembrano errate. Anche se fossero corrette, non è chiaro come siano state calcolate, e le risposte non possono essere verificate indipendentemente dai tuoi calcoli. - -## Esercizio: un po' più di elaborazione dei dati - -Pulisci i dati un po' di più. Aggiungi colonne che saranno utili in seguito, cambia i valori in altre colonne e elimina completamente alcune colonne. - -1. Elaborazione iniziale delle colonne - - 1. Elimina `lat` e `lng` - - 2. Sostituisci i valori di `Hotel_Address` con i seguenti valori (se l'indirizzo contiene il nome della città e del paese, cambialo con solo la città e il paese). - - Queste sono le uniche città e paesi nel dataset: - - Amsterdam, Netherlands - - Barcelona, Spain - - London, United Kingdom - - Milan, Italy - - Paris, France - - Vienna, Austria - - ```python - def replace_address(row): - if "Netherlands" in row["Hotel_Address"]: - return "Amsterdam, Netherlands" - elif "Barcelona" in row["Hotel_Address"]: - return "Barcelona, Spain" - elif "United Kingdom" in row["Hotel_Address"]: - return "London, United Kingdom" - elif "Milan" in row["Hotel_Address"]: - return "Milan, Italy" - elif "France" in row["Hotel_Address"]: - return "Paris, France" - elif "Vienna" in row["Hotel_Address"]: - return "Vienna, Austria" - - # Replace all the addresses with a shortened, more useful form - df["Hotel_Address"] = df.apply(replace_address, axis = 1) - # The sum of the value_counts() should add up to the total number of reviews - print(df["Hotel_Address"].value_counts()) - ``` - - Ora puoi interrogare i dati a livello di paese: - - ```python - display(df.groupby("Hotel_Address").agg({"Hotel_Name": "nunique"})) - ``` - - | Hotel_Address | Hotel_Name | - | :--------------------- | :--------: | - | Amsterdam, Netherlands | 105 | - | Barcelona, Spain | 211 | - | London, United Kingdom | 400 | - | Milan, Italy | 162 | - | Paris, France | 458 | - | Vienna, Austria | 158 | - -2. Processa le colonne Meta-review degli Hotel - - 1. Elimina `Additional_Number_of_Scoring` - - 1. Replace `Total_Number_of_Reviews` with the total number of reviews for that hotel that are actually in the dataset - - 1. Replace `Average_Score` con il nostro punteggio calcolato - - ```python - # Drop `Additional_Number_of_Scoring` - df.drop(["Additional_Number_of_Scoring"], axis = 1, inplace=True) - # Replace `Total_Number_of_Reviews` and `Average_Score` with our own calculated values - df.Total_Number_of_Reviews = df.groupby('Hotel_Name').transform('count') - df.Average_Score = round(df.groupby('Hotel_Name').Reviewer_Score.transform('mean'), 1) - ``` - -3. Processa le colonne delle recensioni - - 1. Elimina `Review_Total_Negative_Word_Counts`, `Review_Total_Positive_Word_Counts`, `Review_Date` and `days_since_review` - - 2. Keep `Reviewer_Score`, `Negative_Review`, and `Positive_Review` as they are, - - 3. Keep `Tags` for now - - - We'll be doing some additional filtering operations on the tags in the next section and then tags will be dropped - -4. Process reviewer columns - - 1. Drop `Total_Number_of_Reviews_Reviewer_Has_Given` - - 2. Keep `Reviewer_Nationality` - -### Tag columns - -The `Tag` column is problematic as it is a list (in text form) stored in the column. Unfortunately the order and number of sub sections in this column are not always the same. It's hard for a human to identify the correct phrases to be interested in, because there are 515,000 rows, and 1427 hotels, and each has slightly different options a reviewer could choose. This is where NLP shines. You can scan the text and find the most common phrases, and count them. - -Unfortunately, we are not interested in single words, but multi-word phrases (e.g. *Business trip*). Running a multi-word frequency distribution algorithm on that much data (6762646 words) could take an extraordinary amount of time, but without looking at the data, it would seem that is a necessary expense. This is where exploratory data analysis comes in useful, because you've seen a sample of the tags such as `[' Business trip ', ' Solo traveler ', ' Single Room ', ' Stayed 5 nights ', ' Submitted from a mobile device ']`, puoi iniziare a chiederti se è possibile ridurre notevolmente l'elaborazione che devi fare. Fortunatamente, è possibile - ma prima devi seguire alcuni passaggi per accertarti dei tag di interesse. - -### Filtraggio dei tag - -Ricorda che l'obiettivo del dataset è aggiungere sentiment e colonne che ti aiuteranno a scegliere il miglior hotel (per te stesso o magari per un cliente che ti chiede di creare un bot di raccomandazione di hotel). Devi chiederti se i tag sono utili o meno nel dataset finale. Ecco un'interpretazione (se avessi bisogno del dataset per altri motivi diversi, potrebbero restare/fuori dalla selezione): - -1. Il tipo di viaggio è rilevante e dovrebbe rimanere -2. Il tipo di gruppo di ospiti è importante e dovrebbe rimanere -3. Il tipo di stanza, suite o studio in cui l'ospite ha soggiornato è irrilevante (tutti gli hotel hanno fondamentalmente le stesse stanze) -4. Il dispositivo da cui è stata inviata la recensione è irrilevante -5. Il numero di notti di soggiorno del recensore *potrebbe* essere rilevante se attribuisci soggiorni più lunghi al fatto che gli sia piaciuto di più l'hotel, ma è un'ipotesi azzardata e probabilmente irrilevante - -In sintesi, **mantieni 2 tipi di tag e rimuovi gli altri**. - -Prima di tutto, non vuoi contare i tag finché non sono in un formato migliore, quindi significa rimuovere le parentesi quadre e le virgolette. Puoi farlo in diversi modi, ma vuoi il più veloce possibile poiché potrebbe richiedere molto tempo per elaborare molti dati. Fortunatamente, pandas ha un modo semplice per eseguire ciascuno di questi passaggi. - -```Python -# Remove opening and closing brackets -df.Tags = df.Tags.str.strip("[']") -# remove all quotes too -df.Tags = df.Tags.str.replace(" ', '", ",", regex = False) -``` - -Ogni tag diventa qualcosa come: `Business trip, Solo traveler, Single Room, Stayed 5 nights, Submitted from a mobile device`. - -Next we find a problem. Some reviews, or rows, have 5 columns, some 3, some 6. This is a result of how the dataset was created, and hard to fix. You want to get a frequency count of each phrase, but they are in different order in each review, so the count might be off, and a hotel might not get a tag assigned to it that it deserved. - -Instead you will use the different order to our advantage, because each tag is multi-word but also separated by a comma! The simplest way to do this is to create 6 temporary columns with each tag inserted in to the column corresponding to its order in the tag. You can then merge the 6 columns into one big column and run the `value_counts()` method on the resulting column. Printing that out, you'll see there was 2428 unique tags. Here is a small sample: - -| Tag | Count | -| ------------------------------ | ------ | -| Leisure trip | 417778 | -| Submitted from a mobile device | 307640 | -| Couple | 252294 | -| Stayed 1 night | 193645 | -| Stayed 2 nights | 133937 | -| Solo traveler | 108545 | -| Stayed 3 nights | 95821 | -| Business trip | 82939 | -| Group | 65392 | -| Family with young children | 61015 | -| Stayed 4 nights | 47817 | -| Double Room | 35207 | -| Standard Double Room | 32248 | -| Superior Double Room | 31393 | -| Family with older children | 26349 | -| Deluxe Double Room | 24823 | -| Double or Twin Room | 22393 | -| Stayed 5 nights | 20845 | -| Standard Double or Twin Room | 17483 | -| Classic Double Room | 16989 | -| Superior Double or Twin Room | 13570 | -| 2 rooms | 12393 | - -Some of the common tags like `Submitted from a mobile device` are of no use to us, so it might be a smart thing to remove them before counting phrase occurrence, but it is such a fast operation you can leave them in and ignore them. - -### Removing the length of stay tags - -Removing these tags is step 1, it reduces the total number of tags to be considered slightly. Note you do not remove them from the dataset, just choose to remove them from consideration as values to count/keep in the reviews dataset. - -| Length of stay | Count | -| ---------------- | ------ | -| Stayed 1 night | 193645 | -| Stayed 2 nights | 133937 | -| Stayed 3 nights | 95821 | -| Stayed 4 nights | 47817 | -| Stayed 5 nights | 20845 | -| Stayed 6 nights | 9776 | -| Stayed 7 nights | 7399 | -| Stayed 8 nights | 2502 | -| Stayed 9 nights | 1293 | -| ... | ... | - -There are a huge variety of rooms, suites, studios, apartments and so on. They all mean roughly the same thing and not relevant to you, so remove them from consideration. - -| Type of room | Count | -| ----------------------------- | ----- | -| Double Room | 35207 | -| Standard Double Room | 32248 | -| Superior Double Room | 31393 | -| Deluxe Double Room | 24823 | -| Double or Twin Room | 22393 | -| Standard Double or Twin Room | 17483 | -| Classic Double Room | 16989 | -| Superior Double or Twin Room | 13570 | - -Finally, and this is delightful (because it didn't take much processing at all), you will be left with the following *useful* tags: - -| Tag | Count | -| --------------------------------------------- | ------ | -| Leisure trip | 417778 | -| Couple | 252294 | -| Solo traveler | 108545 | -| Business trip | 82939 | -| Group (combined with Travellers with friends) | 67535 | -| Family with young children | 61015 | -| Family with older children | 26349 | -| With a pet | 1405 | - -You could argue that `Travellers with friends` is the same as `Group` more or less, and that would be fair to combine the two as above. The code for identifying the correct tags is [the Tags notebook](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb). - -The final step is to create new columns for each of these tags. Then, for every review row, if the `Tag` se la colonna corrisponde a una delle nuove colonne, aggiungi 1, altrimenti aggiungi 0. Il risultato finale sarà un conteggio di quanti recensori hanno scelto questo hotel (in aggregato) per, ad esempio, affari vs svago, o per portare un animale domestico, e queste sono informazioni utili quando si raccomanda un hotel. - -```python -# Process the Tags into new columns -# The file Hotel_Reviews_Tags.py, identifies the most important tags -# Leisure trip, Couple, Solo traveler, Business trip, Group combined with Travelers with friends, -# Family with young children, Family with older children, With a pet -df["Leisure_trip"] = df.Tags.apply(lambda tag: 1 if "Leisure trip" in tag else 0) -df["Couple"] = df.Tags.apply(lambda tag: 1 if "Couple" in tag else 0) -df["Solo_traveler"] = df.Tags.apply(lambda tag: 1 if "Solo traveler" in tag else 0) -df["Business_trip"] = df.Tags.apply(lambda tag: 1 if "Business trip" in tag else 0) -df["Group"] = df.Tags.apply(lambda tag: 1 if "Group" in tag or "Travelers with friends" in tag else 0) -df["Family_with_young_children"] = df.Tags.apply(lambda tag: 1 if "Family with young children" in tag else 0) -df["Family_with_older_children"] = df.Tags.apply(lambda tag: 1 if "Family with older children" in tag else 0) -df["With_a_pet"] = df.Tags.apply(lambda tag: 1 if "With a pet" in tag else 0) - -``` - -### Salva il tuo file - -Infine, salva il dataset come è ora con un nuovo nome. - -```python -df.drop(["Review_Total_Negative_Word_Counts", "Review_Total_Positive_Word_Counts", "days_since_review", "Total_Number_of_Reviews_Reviewer_Has_Given"], axis = 1, inplace=True) - -# Saving new data file with calculated columns -print("Saving results to Hotel_Reviews_Filtered.csv") -df.to_csv(r'../data/Hotel_Reviews_Filtered.csv', index = False) -``` - -## Operazioni di Analisi del Sentiment - -In questa sezione finale, applicherai l'analisi del sentiment alle colonne delle recensioni e salverai i risultati in un dataset. - -## Esercizio: carica e salva i dati filtrati - -Nota che ora stai caricando il dataset filtrato che è stato salvato nella sezione precedente, **non** il dataset originale. - -```python -import time -import pandas as pd -import nltk as nltk -from nltk.corpus import stopwords -from nltk.sentiment.vader import SentimentIntensityAnalyzer -nltk.download('vader_lexicon') - -# Load the filtered hotel reviews from CSV -df = pd.read_csv('../../data/Hotel_Reviews_Filtered.csv') - -# You code will be added here - - -# Finally remember to save the hotel reviews with new NLP data added -print("Saving results to Hotel_Reviews_NLP.csv") -df.to_csv(r'../data/Hotel_Reviews_NLP.csv', index = False) -``` - -### Rimozione delle stop words - -Se dovessi eseguire l'analisi del sentiment sulle colonne delle recensioni negative e positive, potrebbe richiedere molto tempo. Testato su un potente laptop di prova con CPU veloce, ha impiegato 12 - 14 minuti a seconda della libreria di sentiment utilizzata. È un tempo (relativamente) lungo, quindi vale la pena indagare se può essere velocizzato. - -Rimuovere le stop words, o parole comuni in inglese che non cambiano il sentiment di una frase, è il primo passo. Rimuovendole, l'analisi del sentiment dovrebbe essere più veloce, ma non meno accurata (poiché le stop words non influenzano il sentiment, ma rallentano l'analisi). - -La recensione negativa più lunga era di 395 parole, ma dopo aver rimosso le stop words, è di 195 parole. - -La rimozione delle stop words è anche un'operazione veloce, rimuovere le stop words da 2 colonne di recensioni su 515.000 righe ha impiegato 3,3 secondi sul dispositivo di prova. Potrebbe richiedere un po' più o meno tempo per te a seconda della velocità della CPU del tuo dispositivo, della RAM, se hai un SSD o meno, e di altri fattori. La relativa brevità dell'operazione significa che se migliora il tempo dell'analisi del sentiment, allora vale la pena farlo. - -```python -from nltk.corpus import stopwords - -# Load the hotel reviews from CSV -df = pd.read_csv("../../data/Hotel_Reviews_Filtered.csv") - -# Remove stop words - can be slow for a lot of text! -# Ryan Han (ryanxjhan on Kaggle) has a great post measuring performance of different stop words removal approaches -# https://www.kaggle.com/ryanxjhan/fast-stop-words-removal # using the approach that Ryan recommends -start = time.time() -cache = set(stopwords.words("english")) -def remove_stopwords(review): - text = " ".join([word for word in review.split() if word not in cache]) - return text - -# Remove the stop words from both columns -df.Negative_Review = df.Negative_Review.apply(remove_stopwords) -df.Positive_Review = df.Positive_Review.apply(remove_stopwords) -``` - -### Eseguire l'analisi del sentiment - -Ora dovresti calcolare l'analisi del sentiment per entrambe le colonne delle recensioni negative e positive, e memorizzare il risultato in 2 nuove colonne. Il test del sentiment sarà confrontarlo con il punteggio del recensore per la stessa recensione. Ad esempio, se il sentiment ritiene che la recensione negativa abbia un sentiment di 1 (sentiment estremamente positivo) e un sentiment della recensione positiva di 1, ma il recensore ha dato all'hotel il punteggio più basso possibile, allora o il testo della recensione non corrisponde al punteggio, oppure l'analizzatore di sentiment non è riuscito a riconoscere correttamente il sentiment. Dovresti aspettarti che alcuni punteggi di sentiment siano completamente sbagliati, e spesso sarà spiegabile, ad esempio la recensione potrebbe essere estremamente sarcastica "Ovviamente HO ADORATO dormire in una stanza senza riscaldamento" e l'analizzatore di sentiment pensa che sia un sentiment positivo, anche se un essere umano leggendo capirebbe che è sarcasmo. - -NLTK fornisce diversi analizzatori di sentiment con cui imparare, e puoi sostituirli e vedere se il sentiment è più o meno accurato. Qui viene utilizzata l'analisi del sentiment VADER. - -> Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014. - -```python -from nltk.sentiment.vader import SentimentIntensityAnalyzer - -# Create the vader sentiment analyser (there are others in NLTK you can try too) -vader_sentiment = SentimentIntensityAnalyzer() -# Hutto, C.J. & Gilbert, E.E. (2014). VADER: A Parsimonious Rule-based Model for Sentiment Analysis of Social Media Text. Eighth International Conference on Weblogs and Social Media (ICWSM-14). Ann Arbor, MI, June 2014. - -# There are 3 possibilities of input for a review: -# It could be "No Negative", in which case, return 0 -# It could be "No Positive", in which case, return 0 -# It could be a review, in which case calculate the sentiment -def calc_sentiment(review): - if review == "No Negative" or review == "No Positive": - return 0 - return vader_sentiment.polarity_scores(review)["compound"] -``` - -Più avanti nel tuo programma, quando sei pronto per calcolare il sentiment, puoi applicarlo a ogni recensione come segue: - -```python -# Add a negative sentiment and positive sentiment column -print("Calculating sentiment columns for both positive and negative reviews") -start = time.time() -df["Negative_Sentiment"] = df.Negative_Review.apply(calc_sentiment) -df["Positive_Sentiment"] = df.Positive_Review.apply(calc_sentiment) -end = time.time() -print("Calculating sentiment took " + str(round(end - start, 2)) + " seconds") -``` - -Questo richiede circa 120 secondi sul mio computer, ma varierà su ciascun computer. Se vuoi stampare i risultati e vedere se il sentiment corrisponde alla recensione: - -```python -df = df.sort_values(by=["Negative_Sentiment"], ascending=True) -print(df[["Negative_Review", "Negative_Sentiment"]]) -df = df.sort_values(by=["Positive_Sentiment"], ascending=True) -print(df[["Positive_Review", "Positive_Sentiment"]]) -``` - -L'ultima cosa da fare con il file prima di usarlo nella sfida è salvarlo! Dovresti anche considerare di riordinare tutte le tue nuove colonne in modo che siano facili da lavorare (per un essere umano, è un cambiamento cosmetico). - -```python -# Reorder the columns (This is cosmetic, but to make it easier to explore the data later) -df = df.reindex(["Hotel_Name", "Hotel_Address", "Total_Number_of_Reviews", "Average_Score", "Reviewer_Score", "Negative_Sentiment", "Positive_Sentiment", "Reviewer_Nationality", "Leisure_trip", "Couple", "Solo_traveler", "Business_trip", "Group", "Family_with_young_children", "Family_with_older_children", "With_a_pet", "Negative_Review", "Positive_Review"], axis=1) - -print("Saving results to Hotel_Reviews_NLP.csv") -df.to_csv(r"../data/Hotel_Reviews_NLP.csv", index = False) -``` - -Dovresti eseguire l'intero codice per [il notebook di analisi](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) (dopo aver eseguito [il tuo notebook di filtraggio](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) per generare il file Hotel_Reviews_Filtered.csv). - -Per riepilogare, i passaggi sono: - -1. Il file del dataset originale **Hotel_Reviews.csv** è stato esplorato nella lezione precedente con [il notebook di esplorazione](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/4-Hotel-Reviews-1/solution/notebook.ipynb) -2. Hotel_Reviews.csv è filtrato dal [notebook di filtraggio](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/1-notebook.ipynb) risultando in **Hotel_Reviews_Filtered.csv** -3. Hotel_Reviews_Filtered.csv è processato dal [notebook di analisi del sentiment](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/5-Hotel-Reviews-2/solution/3-notebook.ipynb) risultando in **Hotel_Reviews_NLP.csv** -4. Usa Hotel_Reviews_NLP.csv nella sfida NLP qui sotto - -### Conclusione - -Quando hai iniziato, avevi un dataset con colonne e dati ma non tutti potevano essere verificati o utilizzati. Hai esplorato i dati, filtrato ciò che non ti serve, convertito i tag in qualcosa di utile, calcolato le tue medie, aggiunto alcune colonne di sentiment e, si spera, imparato alcune cose interessanti sull'elaborazione del testo naturale. - -## [Post-lecture quiz](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/40/) - -## Sfida - -Ora che hai analizzato il tuo dataset per il sentiment, vedi se puoi utilizzare le strategie che hai imparato in questo curriculum (clustering, forse?) per determinare modelli attorno al sentiment. - -## Revisione & Studio Autonomo - -Segui [questo modulo di Learn](https://docs.microsoft.com/en-us/learn/modules/classify-user-feedback-with-the-text-analytics-api/?WT.mc_id=academic-77952-leestott) per saperne di più e utilizzare strumenti diversi per esplorare il sentiment nel testo. -## Compito - -[Prova un dataset diverso](assignment.md) - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/5-Hotel-Reviews-2/assignment.md b/translations/it/6-NLP/5-Hotel-Reviews-2/assignment.md deleted file mode 100644 index e725ffbaa..000000000 --- a/translations/it/6-NLP/5-Hotel-Reviews-2/assignment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Prova un dataset diverso - -## Istruzioni - -Ora che hai imparato a usare NLTK per assegnare sentimenti al testo, prova un dataset diverso. Probabilmente dovrai fare un po' di elaborazione dei dati, quindi crea un notebook e documenta il tuo processo di pensiero. Cosa scopri? - -## Rubrica - -| Criteri | Esemplare | Adeguato | Da migliorare | -| -------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------- | ---------------------- | -| | Viene presentato un notebook completo e un dataset con celle ben documentate che spiegano come viene assegnato il sentimento | Il notebook manca di buone spiegazioni | Il notebook è difettoso | - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md b/translations/it/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md deleted file mode 100644 index 0fccd2faa..000000000 --- a/translations/it/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/5-Hotel-Reviews-2/solution/R/README.md b/translations/it/6-NLP/5-Hotel-Reviews-2/solution/R/README.md deleted file mode 100644 index b1ba65971..000000000 --- a/translations/it/6-NLP/5-Hotel-Reviews-2/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Anche se ci sforziamo di garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/README.md b/translations/it/6-NLP/README.md deleted file mode 100644 index b409e9635..000000000 --- a/translations/it/6-NLP/README.md +++ /dev/null @@ -1,27 +0,0 @@ -# Introduzione all'elaborazione del linguaggio naturale - -L'elaborazione del linguaggio naturale (NLP) è la capacità di un programma informatico di comprendere il linguaggio umano così come viene parlato e scritto, noto come linguaggio naturale. È una componente dell'intelligenza artificiale (AI). L'NLP esiste da più di 50 anni e ha radici nel campo della linguistica. L'intero campo è indirizzato ad aiutare le macchine a comprendere e processare il linguaggio umano. Questo può essere poi utilizzato per svolgere compiti come il controllo ortografico o la traduzione automatica. Ha una varietà di applicazioni nel mondo reale in numerosi campi, tra cui la ricerca medica, i motori di ricerca e l'intelligenza aziendale. - -## Argomento regionale: lingue e letterature europee e hotel romantici d'Europa ❤️ - -In questa sezione del curriculum, verrai introdotto a uno degli usi più diffusi del machine learning: l'elaborazione del linguaggio naturale (NLP). Derivata dalla linguistica computazionale, questa categoria di intelligenza artificiale è il ponte tra gli esseri umani e le macchine tramite la comunicazione vocale o testuale. - -In queste lezioni impareremo le basi dell'NLP costruendo piccoli bot conversazionali per capire come il machine learning aiuta a rendere queste conversazioni sempre più 'intelligenti'. Viaggerai indietro nel tempo, chiacchierando con Elizabeth Bennett e Mr. Darcy dal classico romanzo di Jane Austen, **Orgoglio e Pregiudizio**, pubblicato nel 1813. Poi, approfondirai la tua conoscenza imparando l'analisi del sentiment tramite le recensioni degli hotel in Europa. - -![Libro e tè di Orgoglio e Pregiudizio](../../../translated_images/p&p.279f1c49ecd889419e4ce6206525e9aa30d32a976955cd24daa636c361c6391f.it.jpg) -> Foto di Elaine Howlin su Unsplash - -## Lezioni - -1. [Introduzione all'elaborazione del linguaggio naturale](1-Introduction-to-NLP/README.md) -2. [Compiti e tecniche comuni dell'NLP](2-Tasks/README.md) -3. [Traduzione e analisi del sentiment con il machine learning](3-Translation-Sentiment/README.md) -4. [Preparare i tuoi dati](4-Hotel-Reviews-1/README.md) -5. [NLTK per l'analisi del sentiment](5-Hotel-Reviews-2/README.md) - -## Crediti - -Queste lezioni sull'elaborazione del linguaggio naturale sono state scritte con ☕ da [Stephen Howell](https://twitter.com/Howell_MSFT) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Anche se ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda la traduzione umana professionale. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/6-NLP/data/README.md b/translations/it/6-NLP/data/README.md deleted file mode 100644 index d5833f295..000000000 --- a/translations/it/6-NLP/data/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci sforziamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/1-Introduction/README.md b/translations/it/7-TimeSeries/1-Introduction/README.md deleted file mode 100644 index fdcaeaba3..000000000 --- a/translations/it/7-TimeSeries/1-Introduction/README.md +++ /dev/null @@ -1,188 +0,0 @@ -# Introduzione alla previsione delle serie temporali - -![Riassunto delle serie temporali in uno sketchnote](../../../../translated_images/ml-timeseries.fb98d25f1013fc0c59090030080b5d1911ff336427bec31dbaf1ad08193812e9.it.png) - -> Sketchnote di [Tomomi Imura](https://www.twitter.com/girlie_mac) - -In questa lezione e nella successiva, imparerai un po' sulla previsione delle serie temporali, una parte interessante e preziosa del repertorio di uno scienziato di ML, che è un po' meno conosciuta rispetto ad altri argomenti. La previsione delle serie temporali è una sorta di 'sfera di cristallo': basandosi sulle prestazioni passate di una variabile come il prezzo, puoi prevederne il valore potenziale futuro. - -[![Introduzione alla previsione delle serie temporali](https://img.youtube.com/vi/cBojo1hsHiI/0.jpg)](https://youtu.be/cBojo1hsHiI "Introduzione alla previsione delle serie temporali") - -> 🎥 Clicca sull'immagine sopra per un video sulla previsione delle serie temporali - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/41/) - -È un campo utile e interessante con un reale valore per il business, dato che ha una diretta applicazione a problemi di prezzo, inventario e questioni della catena di approvvigionamento. Mentre le tecniche di deep learning hanno iniziato a essere utilizzate per ottenere maggiori intuizioni per prevedere meglio le prestazioni future, la previsione delle serie temporali rimane un campo fortemente informato dalle tecniche classiche di ML. - -> Il curriculum utile di serie temporali della Penn State può essere trovato [qui](https://online.stat.psu.edu/stat510/lesson/1) - -## Introduzione - -Supponiamo che tu gestisca una serie di parcometri intelligenti che forniscono dati su quanto spesso vengono utilizzati e per quanto tempo nel tempo. - -> E se potessi prevedere, basandoti sulle prestazioni passate del parcometro, il suo valore futuro secondo le leggi della domanda e dell'offerta? - -Prevedere accuratamente quando agire per raggiungere il tuo obiettivo è una sfida che potrebbe essere affrontata dalla previsione delle serie temporali. Non renderebbe felici le persone essere addebitate di più nei momenti di punta quando cercano un parcheggio, ma sarebbe un modo sicuro per generare entrate per pulire le strade! - -Esploriamo alcuni dei tipi di algoritmi delle serie temporali e iniziamo un notebook per pulire e preparare alcuni dati. I dati che analizzerai sono presi dalla competizione di previsione GEFCom2014. Consistono in 3 anni di valori orari di carico elettrico e temperatura tra il 2012 e il 2014. Dati i modelli storici di carico elettrico e temperatura, puoi prevedere i valori futuri del carico elettrico. - -In questo esempio, imparerai come prevedere un passo temporale avanti, utilizzando solo i dati storici del carico. Tuttavia, prima di iniziare, è utile capire cosa sta succedendo dietro le quinte. - -## Alcune definizioni - -Quando incontri il termine 'serie temporale' devi capire il suo uso in diversi contesti. - -🎓 **Serie temporale** - -In matematica, "una serie temporale è una serie di punti dati indicizzati (o elencati o tracciati) in ordine temporale. Più comunemente, una serie temporale è una sequenza presa in punti di tempo successivi equamente distanziati." Un esempio di serie temporale è il valore di chiusura giornaliero del [Dow Jones Industrial Average](https://wikipedia.org/wiki/Time_series). L'uso di tracciati di serie temporali e la modellazione statistica è frequentemente incontrato nell'elaborazione del segnale, previsione meteorologica, previsione dei terremoti e altri campi in cui si verificano eventi e i punti dati possono essere tracciati nel tempo. - -🎓 **Analisi delle serie temporali** - -L'analisi delle serie temporali è l'analisi dei dati di serie temporali sopra menzionati. I dati di serie temporali possono assumere forme distinte, incluso 'serie temporali interrotte' che rilevano modelli nell'evoluzione di una serie temporale prima e dopo un evento di interruzione. Il tipo di analisi necessario per la serie temporale dipende dalla natura dei dati. I dati di serie temporali stessi possono assumere la forma di serie di numeri o caratteri. - -L'analisi da eseguire utilizza una varietà di metodi, inclusi dominio della frequenza e dominio del tempo, lineare e non lineare, e altro. [Scopri di più](https://www.itl.nist.gov/div898/handbook/pmc/section4/pmc4.htm) sui molti modi per analizzare questo tipo di dati. - -🎓 **Previsione delle serie temporali** - -La previsione delle serie temporali è l'uso di un modello per prevedere valori futuri basati su modelli mostrati dai dati raccolti in precedenza come si sono verificati nel passato. Mentre è possibile utilizzare modelli di regressione per esplorare i dati di serie temporali, con indici temporali come variabili x su un grafico, tali dati sono meglio analizzati utilizzando tipi speciali di modelli. - -I dati di serie temporali sono un elenco di osservazioni ordinate, a differenza dei dati che possono essere analizzati tramite regressione lineare. Il più comune è ARIMA, un acronimo che sta per "Autoregressive Integrated Moving Average". - -I [modelli ARIMA](https://online.stat.psu.edu/stat510/lesson/1/1.1) "relazionano il valore presente di una serie ai valori passati e agli errori di previsione passati." Sono più appropriati per l'analisi dei dati nel dominio del tempo, dove i dati sono ordinati nel tempo. - -> Esistono diversi tipi di modelli ARIMA, che puoi imparare [qui](https://people.duke.edu/~rnau/411arim.htm) e che toccherai nella prossima lezione. - -Nella prossima lezione, costruirai un modello ARIMA utilizzando [Serie Temporali Univariate](https://itl.nist.gov/div898/handbook/pmc/section4/pmc44.htm), che si concentra su una variabile che cambia il suo valore nel tempo. Un esempio di questo tipo di dati è [questo dataset](https://itl.nist.gov/div898/handbook/pmc/section4/pmc4411.htm) che registra la concentrazione mensile di CO2 all'Osservatorio di Mauna Loa: - -| CO2 | YearMonth | Year | Month | -| :----: | :-------: | :---: | :---: | -| 330.62 | 1975.04 | 1975 | 1 | -| 331.40 | 1975.13 | 1975 | 2 | -| 331.87 | 1975.21 | 1975 | 3 | -| 333.18 | 1975.29 | 1975 | 4 | -| 333.92 | 1975.38 | 1975 | 5 | -| 333.43 | 1975.46 | 1975 | 6 | -| 331.85 | 1975.54 | 1975 | 7 | -| 330.01 | 1975.63 | 1975 | 8 | -| 328.51 | 1975.71 | 1975 | 9 | -| 328.41 | 1975.79 | 1975 | 10 | -| 329.25 | 1975.88 | 1975 | 11 | -| 330.97 | 1975.96 | 1975 | 12 | - -✅ Identifica la variabile che cambia nel tempo in questo dataset - -## Caratteristiche dei dati delle serie temporali da considerare - -Quando guardi i dati delle serie temporali, potresti notare che hanno [certe caratteristiche](https://online.stat.psu.edu/stat510/lesson/1/1.1) che devi prendere in considerazione e mitigare per comprendere meglio i loro modelli. Se consideri i dati delle serie temporali come potenzialmente fornendo un 'segnale' che vuoi analizzare, queste caratteristiche possono essere considerate 'rumore'. Spesso sarà necessario ridurre questo 'rumore' compensando alcune di queste caratteristiche utilizzando alcune tecniche statistiche. - -Ecco alcuni concetti che dovresti conoscere per poter lavorare con le serie temporali: - -🎓 **Trend** - -I trend sono definiti come aumenti e diminuzioni misurabili nel tempo. [Leggi di più](https://machinelearningmastery.com/time-series-trends-in-python). Nel contesto delle serie temporali, si tratta di come usare e, se necessario, rimuovere i trend dalla tua serie temporale. - -🎓 **[Stagionalità](https://machinelearningmastery.com/time-series-seasonality-with-python/)** - -La stagionalità è definita come fluttuazioni periodiche, come i picchi di vendita durante le festività, per esempio. [Dai un'occhiata](https://itl.nist.gov/div898/handbook/pmc/section4/pmc443.htm) a come diversi tipi di grafici mostrano la stagionalità nei dati. - -🎓 **Outliers** - -Gli outliers sono lontani dalla varianza standard dei dati. - -🎓 **Ciclo a lungo termine** - -Indipendentemente dalla stagionalità, i dati potrebbero mostrare un ciclo a lungo termine come una recessione economica che dura più di un anno. - -🎓 **Varianza costante** - -Nel tempo, alcuni dati mostrano fluttuazioni costanti, come l'uso di energia per giorno e notte. - -🎓 **Cambiamenti improvvisi** - -I dati potrebbero mostrare un cambiamento improvviso che potrebbe necessitare di ulteriori analisi. La chiusura improvvisa delle attività a causa del COVID, per esempio, ha causato cambiamenti nei dati. - -✅ Ecco un [esempio di grafico di serie temporali](https://www.kaggle.com/kashnitsky/topic-9-part-1-time-series-analysis-in-python) che mostra la spesa giornaliera in valuta di gioco nel corso di alcuni anni. Riesci a identificare alcune delle caratteristiche elencate sopra in questi dati? - -![Spesa in valuta di gioco](../../../../translated_images/currency.e7429812bfc8c6087b2d4c410faaa4aaa11b2fcaabf6f09549b8249c9fbdb641.it.png) - -## Esercizio - iniziare con i dati sull'uso dell'energia - -Iniziamo a creare un modello di serie temporali per prevedere l'uso futuro dell'energia dato l'uso passato. - -> I dati in questo esempio sono presi dalla competizione di previsione GEFCom2014. Consistono in 3 anni di valori orari di carico elettrico e temperatura tra il 2012 e il 2014. -> -> Tao Hong, Pierre Pinson, Shu Fan, Hamidreza Zareipour, Alberto Troccoli e Rob J. Hyndman, "Previsione probabilistica dell'energia: Competizione Globale di Previsione dell'Energia 2014 e oltre", International Journal of Forecasting, vol.32, no.3, pp 896-913, luglio-settembre, 2016. - -1. Nella cartella `working` di questa lezione, apri il file _notebook.ipynb_. Inizia aggiungendo le librerie che ti aiuteranno a caricare e visualizzare i dati - - ```python - import os - import matplotlib.pyplot as plt - from common.utils import load_data - %matplotlib inline - ``` - - Nota, stai usando i file dalla cartella `common` folder which set up your environment and handle downloading the data. - -2. Next, examine the data as a dataframe calling `load_data()` and `head()`: - - ```python - data_dir = './data' - energy = load_data(data_dir)[['load']] - energy.head() - ``` - - Puoi vedere che ci sono due colonne che rappresentano data e carico: - - | | carico | - | :-----------------: | :------: | - | 2012-01-01 00:00:00 | 2698.0 | - | 2012-01-01 01:00:00 | 2558.0 | - | 2012-01-01 02:00:00 | 2444.0 | - | 2012-01-01 03:00:00 | 2402.0 | - | 2012-01-01 04:00:00 | 2403.0 | - -3. Ora, traccia i dati chiamando `plot()`: - - ```python - energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![grafico dell'energia](../../../../translated_images/energy-plot.5fdac3f397a910bc6070602e9e45bea8860d4c239354813fa8fc3c9d556f5bad.it.png) - -4. Ora, traccia la prima settimana di luglio 2014, fornendola come input al modello `energy` in `[from date]: [to date]`: - - ```python - energy['2014-07-01':'2014-07-07'].plot(y='load', subplots=True, figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![luglio](../../../../translated_images/july-2014.9e1f7c318ec6d5b30b0d7e1e20be3643501f64a53f3d426d7c7d7b62addb335e.it.png) - - Un grafico bellissimo! Dai un'occhiata a questi grafici e vedi se riesci a determinare alcune delle caratteristiche elencate sopra. Cosa possiamo dedurre visualizzando i dati? - -Nella prossima lezione, creerai un modello ARIMA per creare alcune previsioni. - ---- - -## 🚀Sfida - -Fai un elenco di tutte le industrie e aree di indagine che puoi pensare che potrebbero beneficiare della previsione delle serie temporali. Riesci a pensare a un'applicazione di queste tecniche nelle arti? Nell'econometria? Nell'ecologia? Nel commercio al dettaglio? Nell'industria? Nella finanza? Dove altro? - -## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/42/) - -## Revisione e Autoapprendimento - -Anche se non li copriremo qui, le reti neurali sono talvolta utilizzate per migliorare i metodi classici di previsione delle serie temporali. Leggi di più su di esse [in questo articolo](https://medium.com/microsoftazure/neural-networks-for-forecasting-financial-and-economic-time-series-6aca370ff412) - -## Compito - -[Visualizza altre serie temporali](assignment.md) - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/1-Introduction/assignment.md b/translations/it/7-TimeSeries/1-Introduction/assignment.md deleted file mode 100644 index 5b93f96f8..000000000 --- a/translations/it/7-TimeSeries/1-Introduction/assignment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Visualizza altre Serie Temporali - -## Istruzioni - -Hai iniziato a conoscere il Time Series Forecasting esaminando il tipo di dati che richiede questa modellazione speciale. Hai visualizzato alcuni dati relativi all'energia. Ora, cerca altri dati che potrebbero beneficiare del Time Series Forecasting. Trova tre esempi (prova [Kaggle](https://kaggle.com) e [Azure Open Datasets](https://azure.microsoft.com/en-us/services/open-datasets/catalog/?WT.mc_id=academic-77952-leestott)) e crea un notebook per visualizzarli. Nota nel notebook qualsiasi caratteristica speciale che presentano (stagionalità, cambiamenti improvvisi o altre tendenze). - -## Rubrica - -| Criteri | Esemplare | Adeguato | Da Migliorare | -| -------- | ------------------------------------------------------ | ---------------------------------------------------- | ----------------------------------------------------------------------------------------- | -| | Tre dataset sono tracciati e spiegati in un notebook | Due dataset sono tracciati e spiegati in un notebook | Pochi dataset sono tracciati o spiegati in un notebook o i dati presentati sono insufficienti | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzati basati su intelligenza artificiale. Anche se ci sforziamo di garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/1-Introduction/solution/Julia/README.md b/translations/it/7-TimeSeries/1-Introduction/solution/Julia/README.md deleted file mode 100644 index cdfe4eab9..000000000 --- a/translations/it/7-TimeSeries/1-Introduction/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci sforziamo di garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/1-Introduction/solution/R/README.md b/translations/it/7-TimeSeries/1-Introduction/solution/R/README.md deleted file mode 100644 index cd23bc558..000000000 --- a/translations/it/7-TimeSeries/1-Introduction/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Anche se ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/2-ARIMA/README.md b/translations/it/7-TimeSeries/2-ARIMA/README.md deleted file mode 100644 index e9bebb7fc..000000000 --- a/translations/it/7-TimeSeries/2-ARIMA/README.md +++ /dev/null @@ -1,396 +0,0 @@ -# Previsione di serie temporali con ARIMA - -Nella lezione precedente, hai appreso un po' sulla previsione di serie temporali e hai caricato un dataset che mostra le fluttuazioni del carico elettrico nel tempo. - -[![Introduzione ad ARIMA](https://img.youtube.com/vi/IUSk-YDau10/0.jpg)](https://youtu.be/IUSk-YDau10 "Introduzione ad ARIMA") - -> 🎥 Clicca sull'immagine sopra per un video: Una breve introduzione ai modelli ARIMA. L'esempio è fatto in R, ma i concetti sono universali. - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/43/) - -## Introduzione - -In questa lezione, scoprirai un modo specifico per costruire modelli con [ARIMA: *A*uto*R*egressive *I*ntegrated *M*oving *A*verage](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average). I modelli ARIMA sono particolarmente adatti per adattarsi ai dati che mostrano [non-stazionarietà](https://wikipedia.org/wiki/Stationary_process). - -## Concetti generali - -Per poter lavorare con ARIMA, ci sono alcuni concetti che devi conoscere: - -- 🎓 **Stazionarietà**. In un contesto statistico, la stazionarietà si riferisce a dati la cui distribuzione non cambia quando viene spostata nel tempo. I dati non stazionari, invece, mostrano fluttuazioni dovute a tendenze che devono essere trasformate per essere analizzate. La stagionalità, per esempio, può introdurre fluttuazioni nei dati e può essere eliminata attraverso un processo di 'differenziazione stagionale'. - -- 🎓 **[Differenziazione](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average#Differencing)**. La differenziazione dei dati, ancora una volta in un contesto statistico, si riferisce al processo di trasformazione dei dati non stazionari per renderli stazionari rimuovendo la loro tendenza non costante. "La differenziazione rimuove i cambiamenti nel livello di una serie temporale, eliminando tendenza e stagionalità e stabilizzando di conseguenza la media della serie temporale." [Paper di Shixiong et al](https://arxiv.org/abs/1904.07632) - -## ARIMA nel contesto delle serie temporali - -Esaminiamo le parti di ARIMA per capire meglio come ci aiuta a modellare le serie temporali e a fare previsioni. - -- **AR - per AutoRegressivo**. I modelli autoregressivi, come suggerisce il nome, guardano 'indietro' nel tempo per analizzare i valori precedenti nei tuoi dati e fare ipotesi su di essi. Questi valori precedenti sono chiamati 'lag'. Un esempio potrebbe essere i dati che mostrano le vendite mensili di matite. Il totale delle vendite di ogni mese sarebbe considerato una 'variabile evolutiva' nel dataset. Questo modello è costruito come "la variabile evolutiva di interesse è regressa sui suoi stessi valori ritardati (cioè, precedenti)." [wikipedia](https://wikipedia.org/wiki/Autoregressive_integrated_moving_average) - -- **I - per Integrato**. A differenza dei modelli simili 'ARMA', la 'I' in ARIMA si riferisce al suo aspetto *[integrato](https://wikipedia.org/wiki/Order_of_integration)*. I dati sono 'integrati' quando vengono applicati passaggi di differenziazione per eliminare la non stazionarietà. - -- **MA - per Media Mobile**. L'aspetto della [media mobile](https://wikipedia.org/wiki/Moving-average_model) di questo modello si riferisce alla variabile di output che è determinata osservando i valori attuali e passati dei lag. - -In sintesi: ARIMA viene utilizzato per adattare un modello alla forma speciale dei dati di serie temporali nel modo più preciso possibile. - -## Esercizio - costruisci un modello ARIMA - -Apri la cartella [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/working) in questa lezione e trova il file [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/2-ARIMA/working/notebook.ipynb). - -1. Esegui il notebook per caricare la libreria `statsmodels` Python; avrai bisogno di questa per i modelli ARIMA. - -1. Carica le librerie necessarie - -1. Ora, carica altre librerie utili per la visualizzazione dei dati: - - ```python - import os - import warnings - import matplotlib.pyplot as plt - import numpy as np - import pandas as pd - import datetime as dt - import math - - from pandas.plotting import autocorrelation_plot - from statsmodels.tsa.statespace.sarimax import SARIMAX - from sklearn.preprocessing import MinMaxScaler - from common.utils import load_data, mape - from IPython.display import Image - - %matplotlib inline - pd.options.display.float_format = '{:,.2f}'.format - np.set_printoptions(precision=2) - warnings.filterwarnings("ignore") # specify to ignore warning messages - ``` - -1. Carica i dati dal file `/data/energy.csv` in un dataframe Pandas e dai un'occhiata: - - ```python - energy = load_data('./data')[['load']] - energy.head(10) - ``` - -1. Traccia tutti i dati energetici disponibili da gennaio 2012 a dicembre 2014. Non ci dovrebbero essere sorprese poiché abbiamo visto questi dati nella lezione precedente: - - ```python - energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - Ora, costruiamo un modello! - -### Crea dataset di addestramento e test - -Ora i tuoi dati sono caricati, quindi puoi separarli in set di addestramento e di test. Addestrerai il tuo modello sul set di addestramento. Come al solito, dopo che il modello ha terminato l'addestramento, valuterai la sua accuratezza utilizzando il set di test. Devi assicurarti che il set di test copra un periodo di tempo successivo rispetto al set di addestramento per garantire che il modello non acquisisca informazioni dai periodi futuri. - -1. Assegna un periodo di due mesi dal 1 settembre al 31 ottobre 2014 al set di addestramento. Il set di test includerà il periodo di due mesi dal 1 novembre al 31 dicembre 2014: - - ```python - train_start_dt = '2014-11-01 00:00:00' - test_start_dt = '2014-12-30 00:00:00' - ``` - - Poiché questi dati riflettono il consumo giornaliero di energia, c'è un forte schema stagionale, ma il consumo è più simile al consumo nei giorni più recenti. - -1. Visualizza le differenze: - - ```python - energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \ - .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \ - .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![dati di addestramento e test](../../../../translated_images/train-test.8928d14e5b91fc942f0ca9201b2d36c890ea7e98f7619fd94f75de3a4c2bacb9.it.png) - - Pertanto, utilizzare una finestra di tempo relativamente piccola per l'addestramento dei dati dovrebbe essere sufficiente. - - > Nota: Poiché la funzione che utilizziamo per adattare il modello ARIMA utilizza la validazione in-sample durante l'adattamento, ometteremo i dati di validazione. - -### Prepara i dati per l'addestramento - -Ora, devi preparare i dati per l'addestramento eseguendo il filtraggio e la scalatura dei tuoi dati. Filtra il tuo dataset per includere solo i periodi di tempo e le colonne di cui hai bisogno e scala i dati per assicurarti che siano proiettati nell'intervallo 0,1. - -1. Filtra il dataset originale per includere solo i periodi di tempo sopra menzionati per set e includendo solo la colonna 'load' necessaria più la data: - - ```python - train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']] - test = energy.copy()[energy.index >= test_start_dt][['load']] - - print('Training data shape: ', train.shape) - print('Test data shape: ', test.shape) - ``` - - Puoi vedere la forma dei dati: - - ```output - Training data shape: (1416, 1) - Test data shape: (48, 1) - ``` - -1. Scala i dati per essere nell'intervallo (0, 1). - - ```python - scaler = MinMaxScaler() - train['load'] = scaler.fit_transform(train) - train.head(10) - ``` - -1. Visualizza i dati originali vs. scalati: - - ```python - energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12) - train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12) - plt.show() - ``` - - ![originale](../../../../translated_images/original.b2b15efe0ce92b8745918f071dceec2231661bf49c8db6918e3ff4b3b0b183c2.it.png) - - > I dati originali - - ![scalati](../../../../translated_images/scaled.e35258ca5cd3d43f86d5175e584ba96b38d51501f234abf52e11f4fe2631e45f.it.png) - - > I dati scalati - -1. Ora che hai calibrato i dati scalati, puoi scalare i dati di test: - - ```python - test['load'] = scaler.transform(test) - test.head() - ``` - -### Implementa ARIMA - -È ora di implementare ARIMA! Ora utilizzerai la libreria `statsmodels` che hai installato in precedenza. - -Ora devi seguire diversi passaggi - - 1. Definisci il modello chiamando `SARIMAX()` and passing in the model parameters: p, d, and q parameters, and P, D, and Q parameters. - 2. Prepare the model for the training data by calling the fit() function. - 3. Make predictions calling the `forecast()` function and specifying the number of steps (the `horizon`) to forecast. - -> 🎓 What are all these parameters for? In an ARIMA model there are 3 parameters that are used to help model the major aspects of a time series: seasonality, trend, and noise. These parameters are: - -`p`: the parameter associated with the auto-regressive aspect of the model, which incorporates *past* values. -`d`: the parameter associated with the integrated part of the model, which affects the amount of *differencing* (🎓 remember differencing 👆?) to apply to a time series. -`q`: the parameter associated with the moving-average part of the model. - -> Note: If your data has a seasonal aspect - which this one does - , we use a seasonal ARIMA model (SARIMA). In that case you need to use another set of parameters: `P`, `D`, and `Q` which describe the same associations as `p`, `d`, and `q`, ma corrispondono ai componenti stagionali del modello. - -1. Inizia impostando il tuo valore di orizzonte preferito. Proviamo 3 ore: - - ```python - # Specify the number of steps to forecast ahead - HORIZON = 3 - print('Forecasting horizon:', HORIZON, 'hours') - ``` - - Selezionare i migliori valori per i parametri di un modello ARIMA può essere impegnativo poiché è in parte soggettivo e richiede tempo. Potresti considerare di utilizzare una libreria `auto_arima()` function from the [`pyramid`](https://alkaline-ml.com/pmdarima/0.9.0/modules/generated/pyramid.arima.auto_arima.html), - -1. Per ora prova alcune selezioni manuali per trovare un buon modello. - - ```python - order = (4, 1, 0) - seasonal_order = (1, 1, 0, 24) - - model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order) - results = model.fit() - - print(results.summary()) - ``` - - Viene stampata una tabella di risultati. - -Hai costruito il tuo primo modello! Ora dobbiamo trovare un modo per valutarlo. - -### Valuta il tuo modello - -Per valutare il tuo modello, puoi eseguire la cosiddetta validazione `walk forward`. In pratica, i modelli di serie temporali vengono ri-addestrati ogni volta che sono disponibili nuovi dati. Questo consente al modello di fare la migliore previsione a ogni passo temporale. - -Partendo dall'inizio della serie temporale utilizzando questa tecnica, addestra il modello sul set di dati di addestramento. Quindi fai una previsione sul passo temporale successivo. La previsione viene valutata rispetto al valore noto. Il set di addestramento viene quindi ampliato per includere il valore noto e il processo viene ripetuto. - -> Nota: Dovresti mantenere la finestra del set di addestramento fissa per un addestramento più efficiente in modo che ogni volta che aggiungi una nuova osservazione al set di addestramento, rimuovi l'osservazione dall'inizio del set. - -Questo processo fornisce una stima più robusta di come il modello si comporterà in pratica. Tuttavia, comporta il costo computazionale di creare tanti modelli. Questo è accettabile se i dati sono piccoli o se il modello è semplice, ma potrebbe essere un problema su larga scala. - -La validazione walk-forward è lo standard d'oro per la valutazione dei modelli di serie temporali ed è raccomandata per i tuoi progetti. - -1. Innanzitutto, crea un punto dati di test per ogni passo HORIZON. - - ```python - test_shifted = test.copy() - - for t in range(1, HORIZON+1): - test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H') - - test_shifted = test_shifted.dropna(how='any') - test_shifted.head(5) - ``` - - | | | load | load+1 | load+2 | - | ---------- | -------- | ---- | ------ | ------ | - | 2014-12-30 | 00:00:00 | 0.33 | 0.29 | 0.27 | - | 2014-12-30 | 01:00:00 | 0.29 | 0.27 | 0.27 | - | 2014-12-30 | 02:00:00 | 0.27 | 0.27 | 0.30 | - | 2014-12-30 | 03:00:00 | 0.27 | 0.30 | 0.41 | - | 2014-12-30 | 04:00:00 | 0.30 | 0.41 | 0.57 | - - I dati vengono spostati orizzontalmente in base al punto di orizzonte. - -1. Fai previsioni sui tuoi dati di test utilizzando questo approccio a finestra scorrevole in un ciclo della lunghezza dei dati di test: - - ```python - %%time - training_window = 720 # dedicate 30 days (720 hours) for training - - train_ts = train['load'] - test_ts = test_shifted - - history = [x for x in train_ts] - history = history[(-training_window):] - - predictions = list() - - order = (2, 1, 0) - seasonal_order = (1, 1, 0, 24) - - for t in range(test_ts.shape[0]): - model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order) - model_fit = model.fit() - yhat = model_fit.forecast(steps = HORIZON) - predictions.append(yhat) - obs = list(test_ts.iloc[t]) - # move the training window - history.append(obs[0]) - history.pop(0) - print(test_ts.index[t]) - print(t+1, ': predicted =', yhat, 'expected =', obs) - ``` - - Puoi osservare l'addestramento in corso: - - ```output - 2014-12-30 00:00:00 - 1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323] - - 2014-12-30 01:00:00 - 2 : predicted = [0.3 0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126] - - 2014-12-30 02:00:00 - 3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795] - ``` - -1. Confronta le previsioni con il carico effettivo: - - ```python - eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)]) - eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1] - eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h') - eval_df['actual'] = np.array(np.transpose(test_ts)).ravel() - eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']]) - eval_df.head() - ``` - - Output - | | | timestamp | h | prediction | actual | - | --- | ---------- | --------- | --- | ---------- | -------- | - | 0 | 2014-12-30 | 00:00:00 | t+1 | 3,008.74 | 3,023.00 | - | 1 | 2014-12-30 | 01:00:00 | t+1 | 2,955.53 | 2,935.00 | - | 2 | 2014-12-30 | 02:00:00 | t+1 | 2,900.17 | 2,899.00 | - | 3 | 2014-12-30 | 03:00:00 | t+1 | 2,917.69 | 2,886.00 | - | 4 | 2014-12-30 | 04:00:00 | t+1 | 2,946.99 | 2,963.00 | - - Osserva la previsione dei dati orari, rispetto al carico effettivo. Quanto è accurata questa previsione? - -### Verifica l'accuratezza del modello - -Verifica l'accuratezza del tuo modello testando il suo errore percentuale assoluto medio (MAPE) su tutte le previsioni. - -> **🧮 Mostrami i calcoli** -> -> ![MAPE](../../../../translated_images/mape.fd87bbaf4d346846df6af88b26bf6f0926bf9a5027816d5e23e1200866e3e8a4.it.png) -> -> [MAPE](https://www.linkedin.com/pulse/what-mape-mad-msd-time-series-allameh-statistics/) viene utilizzato per mostrare l'accuratezza della previsione come rapporto definito dalla formula sopra. La differenza tra actualt e predictedt viene divisa per actualt. "Il valore assoluto in questo calcolo viene sommato per ogni punto di previsione nel tempo e diviso per il numero di punti adattati n." [wikipedia](https://wikipedia.org/wiki/Mean_absolute_percentage_error) - -1. Esprimi l'equazione in codice: - - ```python - if(HORIZON > 1): - eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual'] - print(eval_df.groupby('h')['APE'].mean()) - ``` - -1. Calcola il MAPE di un singolo passo: - - ```python - print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%') - ``` - - MAPE della previsione di un passo: 0.5570581332313952 % - -1. Stampa il MAPE della previsione multi-passo: - - ```python - print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%') - ``` - - ```output - Multi-step forecast MAPE: 1.1460048657704118 % - ``` - - Un numero basso è il migliore: considera che una previsione con un MAPE di 10 è sbagliata del 10%. - -1. Ma come sempre, è più facile vedere questo tipo di misurazione dell'accuratezza visivamente, quindi tracciamolo: - - ```python - if(HORIZON == 1): - ## Plotting single step forecast - eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8)) - - else: - ## Plotting multi step forecast - plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']] - for t in range(1, HORIZON+1): - plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values - - fig = plt.figure(figsize=(15, 8)) - ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0) - ax = fig.add_subplot(111) - for t in range(1, HORIZON+1): - x = plot_df['timestamp'][(t-1):] - y = plot_df['t+'+str(t)][0:len(x)] - ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t)) - - ax.legend(loc='best') - - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![un modello di serie temporali](../../../../translated_images/accuracy.2c47fe1bf15f44b3656651c84d5e2ba9b37cd929cd2aa8ab6cc3073f50570f4e.it.png) - -🏆 Un grafico molto bello, che mostra un modello con buona accuratezza. Ben fatto! - ---- - -## 🚀Sfida - -Approfondisci i modi per testare l'accuratezza di un modello di serie temporali. Abbiamo trattato il MAPE in questa lezione, ma ci sono altri metodi che potresti usare? Ricercali e annotali. Un documento utile può essere trovato [qui](https://otexts.com/fpp2/accuracy.html) - -## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/44/) - -## Revisione & Autoapprendimento - -Questa lezione tocca solo le basi della previsione di serie temporali con ARIMA. Prenditi del tempo per approfondire la tua conoscenza esplorando [questo repository](https://microsoft.github.io/forecasting/) e i suoi vari tipi di modelli per imparare altri modi per costruire modelli di serie temporali. - -## Compito - -[Un nuovo modello ARIMA](assignment.md) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci sforziamo di ottenere accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/2-ARIMA/assignment.md b/translations/it/7-TimeSeries/2-ARIMA/assignment.md deleted file mode 100644 index 6c9d7f677..000000000 --- a/translations/it/7-TimeSeries/2-ARIMA/assignment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Un nuovo modello ARIMA - -## Istruzioni - -Ora che hai costruito un modello ARIMA, costruiscine uno nuovo con dati freschi (prova uno di [questi dataset di Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Annota il tuo lavoro in un notebook, visualizza i dati e il tuo modello, e testa la sua accuratezza utilizzando MAPE. - -## Rubrica - -| Criteri | Esemplare | Adeguato | Necessita Miglioramenti | -| -------- | ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- | ----------------------------------- | -| | Un notebook è presentato con un nuovo modello ARIMA costruito, testato e spiegato con visualizzazioni e accuratezza dichiarata. | Il notebook presentato non è annotato o contiene errori | Viene presentato un notebook incompleto | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali fraintendimenti o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/2-ARIMA/solution/Julia/README.md b/translations/it/7-TimeSeries/2-ARIMA/solution/Julia/README.md deleted file mode 100644 index b20a093c6..000000000 --- a/translations/it/7-TimeSeries/2-ARIMA/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci sforziamo di garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/2-ARIMA/solution/R/README.md b/translations/it/7-TimeSeries/2-ARIMA/solution/R/README.md deleted file mode 100644 index 9bc2be598..000000000 --- a/translations/it/7-TimeSeries/2-ARIMA/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzati basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/3-SVR/README.md b/translations/it/7-TimeSeries/3-SVR/README.md deleted file mode 100644 index f9095cd83..000000000 --- a/translations/it/7-TimeSeries/3-SVR/README.md +++ /dev/null @@ -1,389 +0,0 @@ -# Previsione di Serie Temporali con Support Vector Regressor - -Nella lezione precedente, hai imparato a utilizzare il modello ARIMA per fare previsioni su serie temporali. Ora vedrai il modello Support Vector Regressor, che è un modello di regressione usato per prevedere dati continui. - -## [Quiz Pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/51/) - -## Introduzione - -In questa lezione, scoprirai un modo specifico per costruire modelli con [**SVM**: **S**upport **V**ector **M**achine](https://en.wikipedia.org/wiki/Support-vector_machine) per la regressione, o **SVR: Support Vector Regressor**. - -### SVR nel contesto delle serie temporali [^1] - -Prima di comprendere l'importanza di SVR nella previsione delle serie temporali, ecco alcuni concetti importanti che devi conoscere: - -- **Regressione:** Tecnica di apprendimento supervisionato per prevedere valori continui da un insieme di input dato. L'idea è di adattare una curva (o linea) nello spazio delle caratteristiche che ha il maggior numero di punti dati. [Clicca qui](https://en.wikipedia.org/wiki/Regression_analysis) per maggiori informazioni. -- **Support Vector Machine (SVM):** Un tipo di modello di apprendimento supervisionato utilizzato per classificazione, regressione e rilevamento di anomalie. Il modello è un iperpiano nello spazio delle caratteristiche, che nel caso della classificazione agisce come un confine, e nel caso della regressione agisce come la linea di miglior adattamento. In SVM, una funzione Kernel viene generalmente utilizzata per trasformare il dataset in uno spazio con un numero maggiore di dimensioni, in modo che possano essere facilmente separabili. [Clicca qui](https://en.wikipedia.org/wiki/Support-vector_machine) per maggiori informazioni sulle SVM. -- **Support Vector Regressor (SVR):** Un tipo di SVM, per trovare la linea di miglior adattamento (che nel caso di SVM è un iperpiano) che ha il maggior numero di punti dati. - -### Perché SVR? [^1] - -Nell'ultima lezione hai imparato l'ARIMA, che è un metodo statistico lineare molto efficace per prevedere i dati delle serie temporali. Tuttavia, in molti casi, i dati delle serie temporali presentano *non-linearità*, che non possono essere mappate da modelli lineari. In questi casi, la capacità di SVM di considerare la non-linearità nei dati per compiti di regressione rende SVR efficace nella previsione delle serie temporali. - -## Esercizio - costruisci un modello SVR - -I primi passi per la preparazione dei dati sono gli stessi della lezione precedente su [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA). - -Apri la cartella [_/working_](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/3-SVR/working) in questa lezione e trova il file [_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/7-TimeSeries/3-SVR/working/notebook.ipynb).[^2] - -1. Esegui il notebook e importa le librerie necessarie: [^2] - - ```python - import sys - sys.path.append('../../') - ``` - - ```python - import os - import warnings - import matplotlib.pyplot as plt - import numpy as np - import pandas as pd - import datetime as dt - import math - - from sklearn.svm import SVR - from sklearn.preprocessing import MinMaxScaler - from common.utils import load_data, mape - ``` - -2. Carica i dati dal file `/data/energy.csv` in un dataframe Pandas e dai un'occhiata: [^2] - - ```python - energy = load_data('../../data')[['load']] - ``` - -3. Traccia tutti i dati energetici disponibili da gennaio 2012 a dicembre 2014: [^2] - - ```python - energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![dati completi](../../../../translated_images/full-data.a82ec9957e580e976f651a4fc38f280b9229c6efdbe3cfe7c60abaa9486d2cbe.it.png) - - Ora, costruiamo il nostro modello SVR. - -### Crea set di dati per l'addestramento e il test - -Ora i tuoi dati sono caricati, quindi puoi separarli in set di addestramento e test. Poi ridimensionerai i dati per creare un dataset basato sui passi temporali che sarà necessario per il SVR. Addestrerai il tuo modello sul set di addestramento. Dopo che il modello ha finito l'addestramento, valuterai la sua accuratezza sul set di addestramento, sul set di test e poi sull'intero dataset per vedere le prestazioni complessive. Devi assicurarti che il set di test copra un periodo successivo nel tempo rispetto al set di addestramento per garantire che il modello non acquisisca informazioni dai periodi futuri [^2] (una situazione nota come *Overfitting*). - -1. Assegna un periodo di due mesi dal 1 settembre al 31 ottobre 2014 al set di addestramento. Il set di test includerà il periodo di due mesi dal 1 novembre al 31 dicembre 2014: [^2] - - ```python - train_start_dt = '2014-11-01 00:00:00' - test_start_dt = '2014-12-30 00:00:00' - ``` - -2. Visualizza le differenze: [^2] - - ```python - energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \ - .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \ - .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12) - plt.xlabel('timestamp', fontsize=12) - plt.ylabel('load', fontsize=12) - plt.show() - ``` - - ![dati di addestramento e test](../../../../translated_images/train-test.ead0cecbfc341921d4875eccf25fed5eefbb860cdbb69cabcc2276c49e4b33e5.it.png) - - - -### Prepara i dati per l'addestramento - -Ora, devi preparare i dati per l'addestramento eseguendo il filtraggio e la scalatura dei dati. Filtra il tuo dataset per includere solo i periodi di tempo e le colonne necessarie, e scala i dati per garantire che siano proiettati nell'intervallo 0,1. - -1. Filtra il dataset originale per includere solo i periodi di tempo sopra menzionati per set e includendo solo la colonna necessaria 'load' più la data: [^2] - - ```python - train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']] - test = energy.copy()[energy.index >= test_start_dt][['load']] - - print('Training data shape: ', train.shape) - print('Test data shape: ', test.shape) - ``` - - ```output - Training data shape: (1416, 1) - Test data shape: (48, 1) - ``` - -2. Scala i dati di addestramento per essere nell'intervallo (0, 1): [^2] - - ```python - scaler = MinMaxScaler() - train['load'] = scaler.fit_transform(train) - ``` - -4. Ora, scala i dati di test: [^2] - - ```python - test['load'] = scaler.transform(test) - ``` - -### Crea dati con passi temporali [^1] - -Per il SVR, trasformi i dati di input in forma `[batch, timesteps]`. So, you reshape the existing `train_data` and `test_data` in modo che ci sia una nuova dimensione che si riferisce ai passi temporali. - -```python -# Converting to numpy arrays -train_data = train.values -test_data = test.values -``` - -Per questo esempio, prendiamo `timesteps = 5`. Quindi, gli input al modello sono i dati per i primi 4 passi temporali, e l'output sarà i dati per il 5° passo temporale. - -```python -timesteps=5 -``` - -Convertire i dati di addestramento in un tensore 2D utilizzando la comprensione delle liste nidificate: - -```python -train_data_timesteps=np.array([[j for j in train_data[i:i+timesteps]] for i in range(0,len(train_data)-timesteps+1)])[:,:,0] -train_data_timesteps.shape -``` - -```output -(1412, 5) -``` - -Convertire i dati di test in un tensore 2D: - -```python -test_data_timesteps=np.array([[j for j in test_data[i:i+timesteps]] for i in range(0,len(test_data)-timesteps+1)])[:,:,0] -test_data_timesteps.shape -``` - -```output -(44, 5) -``` - - Selezionare input e output dai dati di addestramento e test: - -```python -x_train, y_train = train_data_timesteps[:,:timesteps-1],train_data_timesteps[:,[timesteps-1]] -x_test, y_test = test_data_timesteps[:,:timesteps-1],test_data_timesteps[:,[timesteps-1]] - -print(x_train.shape, y_train.shape) -print(x_test.shape, y_test.shape) -``` - -```output -(1412, 4) (1412, 1) -(44, 4) (44, 1) -``` - -### Implementa SVR [^1] - -Ora, è il momento di implementare SVR. Per leggere di più su questa implementazione, puoi fare riferimento a [questa documentazione](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html). Per la nostra implementazione, seguiamo questi passaggi: - - 1. Definisci il modello chiamando `SVR()` and passing in the model hyperparameters: kernel, gamma, c and epsilon - 2. Prepare the model for the training data by calling the `fit()` function - 3. Make predictions calling the `predict()` function - -Ora creiamo un modello SVR. Qui usiamo il [kernel RBF](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel), e impostiamo gli iperparametri gamma, C ed epsilon rispettivamente a 0.5, 10 e 0.05. - -```python -model = SVR(kernel='rbf',gamma=0.5, C=10, epsilon = 0.05) -``` - -#### Adatta il modello ai dati di addestramento [^1] - -```python -model.fit(x_train, y_train[:,0]) -``` - -```output -SVR(C=10, cache_size=200, coef0=0.0, degree=3, epsilon=0.05, gamma=0.5, - kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False) -``` - -#### Fai previsioni con il modello [^1] - -```python -y_train_pred = model.predict(x_train).reshape(-1,1) -y_test_pred = model.predict(x_test).reshape(-1,1) - -print(y_train_pred.shape, y_test_pred.shape) -``` - -```output -(1412, 1) (44, 1) -``` - -Hai costruito il tuo SVR! Ora dobbiamo valutarlo. - -### Valuta il tuo modello [^1] - -Per la valutazione, prima scaleremo indietro i dati alla nostra scala originale. Poi, per verificare le prestazioni, tracceremo il grafico della serie temporale originale e prevista, e stamperemo anche il risultato MAPE. - -Scala l'output previsto e originale: - -```python -# Scaling the predictions -y_train_pred = scaler.inverse_transform(y_train_pred) -y_test_pred = scaler.inverse_transform(y_test_pred) - -print(len(y_train_pred), len(y_test_pred)) -``` - -```python -# Scaling the original values -y_train = scaler.inverse_transform(y_train) -y_test = scaler.inverse_transform(y_test) - -print(len(y_train), len(y_test)) -``` - -#### Verifica le prestazioni del modello sui dati di addestramento e di test [^1] - -Estrarremo i timestamp dal dataset per mostrarli sull'asse x del nostro grafico. Nota che stiamo utilizzando i primi ```timesteps-1``` valori come input per il primo output, quindi i timestamp per l'output inizieranno dopo. - -```python -train_timestamps = energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)].index[timesteps-1:] -test_timestamps = energy[test_start_dt:].index[timesteps-1:] - -print(len(train_timestamps), len(test_timestamps)) -``` - -```output -1412 44 -``` - -Traccia le previsioni per i dati di addestramento: - -```python -plt.figure(figsize=(25,6)) -plt.plot(train_timestamps, y_train, color = 'red', linewidth=2.0, alpha = 0.6) -plt.plot(train_timestamps, y_train_pred, color = 'blue', linewidth=0.8) -plt.legend(['Actual','Predicted']) -plt.xlabel('Timestamp') -plt.title("Training data prediction") -plt.show() -``` - -![previsione dati di addestramento](../../../../translated_images/train-data-predict.3c4ef4e78553104ffdd53d47a4c06414007947ea328e9261ddf48d3eafdefbbf.it.png) - -Stampa MAPE per i dati di addestramento - -```python -print('MAPE for training data: ', mape(y_train_pred, y_train)*100, '%') -``` - -```output -MAPE for training data: 1.7195710200875551 % -``` - -Traccia le previsioni per i dati di test - -```python -plt.figure(figsize=(10,3)) -plt.plot(test_timestamps, y_test, color = 'red', linewidth=2.0, alpha = 0.6) -plt.plot(test_timestamps, y_test_pred, color = 'blue', linewidth=0.8) -plt.legend(['Actual','Predicted']) -plt.xlabel('Timestamp') -plt.show() -``` - -![previsione dati di test](../../../../translated_images/test-data-predict.8afc47ee7e52874f514ebdda4a798647e9ecf44a97cc927c535246fcf7a28aa9.it.png) - -Stampa MAPE per i dati di test - -```python -print('MAPE for testing data: ', mape(y_test_pred, y_test)*100, '%') -``` - -```output -MAPE for testing data: 1.2623790187854018 % -``` - -🏆 Hai ottenuto un ottimo risultato sul dataset di test! - -### Verifica le prestazioni del modello sull'intero dataset [^1] - -```python -# Extracting load values as numpy array -data = energy.copy().values - -# Scaling -data = scaler.transform(data) - -# Transforming to 2D tensor as per model input requirement -data_timesteps=np.array([[j for j in data[i:i+timesteps]] for i in range(0,len(data)-timesteps+1)])[:,:,0] -print("Tensor shape: ", data_timesteps.shape) - -# Selecting inputs and outputs from data -X, Y = data_timesteps[:,:timesteps-1],data_timesteps[:,[timesteps-1]] -print("X shape: ", X.shape,"\nY shape: ", Y.shape) -``` - -```output -Tensor shape: (26300, 5) -X shape: (26300, 4) -Y shape: (26300, 1) -``` - -```python -# Make model predictions -Y_pred = model.predict(X).reshape(-1,1) - -# Inverse scale and reshape -Y_pred = scaler.inverse_transform(Y_pred) -Y = scaler.inverse_transform(Y) -``` - -```python -plt.figure(figsize=(30,8)) -plt.plot(Y, color = 'red', linewidth=2.0, alpha = 0.6) -plt.plot(Y_pred, color = 'blue', linewidth=0.8) -plt.legend(['Actual','Predicted']) -plt.xlabel('Timestamp') -plt.show() -``` - -![previsione dati completi](../../../../translated_images/full-data-predict.4f0fed16a131c8f3bcc57a3060039dc7f2f714a05b07b68c513e0fe7fb3d8964.it.png) - -```python -print('MAPE: ', mape(Y_pred, Y)*100, '%') -``` - -```output -MAPE: 2.0572089029888656 % -``` - - - -🏆 Grafici molto belli, che mostrano un modello con buona accuratezza. Ben fatto! - ---- - -## 🚀Sfida - -- Prova a modificare gli iperparametri (gamma, C, epsilon) durante la creazione del modello e valuta sui dati per vedere quale set di iperparametri dà i migliori risultati sui dati di test. Per saperne di più su questi iperparametri, puoi fare riferimento al documento [qui](https://scikit-learn.org/stable/modules/svm.html#parameters-of-the-rbf-kernel). -- Prova a usare diverse funzioni kernel per il modello e analizza le loro prestazioni sul dataset. Un documento utile può essere trovato [qui](https://scikit-learn.org/stable/modules/svm.html#kernel-functions). -- Prova a usare diversi valori per `timesteps` per far sì che il modello guardi indietro per fare la previsione. - -## [Quiz Post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/52/) - -## Revisione & Studio Autonomo - -Questa lezione era per introdurre l'applicazione di SVR per la previsione delle serie temporali. Per leggere di più su SVR, puoi fare riferimento a [questo blog](https://www.analyticsvidhya.com/blog/2020/03/support-vector-regression-tutorial-for-machine-learning/). Questa [documentazione su scikit-learn](https://scikit-learn.org/stable/modules/svm.html) fornisce una spiegazione più completa sulle SVM in generale, [SVR](https://scikit-learn.org/stable/modules/svm.html#regression) e anche altri dettagli di implementazione come le diverse [funzioni kernel](https://scikit-learn.org/stable/modules/svm.html#kernel-functions) che possono essere utilizzate, e i loro parametri. - -## Compito - -[Un nuovo modello SVR](assignment.md) - - - -## Crediti - - -[^1]: Il testo, il codice e l'output in questa sezione sono stati contribuiti da [@AnirbanMukherjeeXD](https://github.com/AnirbanMukherjeeXD) -[^2]: Il testo, il codice e l'output in questa sezione sono stati presi da [ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzata basati su intelligenza artificiale. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/3-SVR/assignment.md b/translations/it/7-TimeSeries/3-SVR/assignment.md deleted file mode 100644 index 2fa971bbe..000000000 --- a/translations/it/7-TimeSeries/3-SVR/assignment.md +++ /dev/null @@ -1,16 +0,0 @@ -# Un nuovo modello SVR - -## Istruzioni [^1] - -Ora che hai costruito un modello SVR, costruiscine uno nuovo con dati freschi (prova uno di [questi dataset da Duke](http://www2.stat.duke.edu/~mw/ts_data_sets.html)). Annota il tuo lavoro in un notebook, visualizza i dati e il tuo modello, e testa la sua accuratezza utilizzando grafici appropriati e MAPE. Prova anche a modificare i diversi iperparametri e a usare valori differenti per i timesteps. - -## Rubrica [^1] - -| Criteri | Esemplare | Adeguato | Da Migliorare | -| -------- | ------------------------------------------------------------ | --------------------------------------------------------- | ----------------------------------- | -| | Viene presentato un notebook con un modello SVR costruito, testato e spiegato con visualizzazioni e accuratezza dichiarata. | Il notebook presentato non è annotato o contiene errori. | Viene presentato un notebook incompleto. | - -[^1]: Il testo in questa sezione è basato sull'[assignment di ARIMA](https://github.com/microsoft/ML-For-Beginners/tree/main/7-TimeSeries/2-ARIMA/assignment.md) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/7-TimeSeries/README.md b/translations/it/7-TimeSeries/README.md deleted file mode 100644 index 9502c0c39..000000000 --- a/translations/it/7-TimeSeries/README.md +++ /dev/null @@ -1,26 +0,0 @@ -# Introduzione alla previsione delle serie temporali - -Cos'è la previsione delle serie temporali? Si tratta di prevedere eventi futuri analizzando le tendenze del passato. - -## Argomento regionale: consumo di elettricità nel mondo ✨ - -In queste due lezioni, verrà introdotta la previsione delle serie temporali, un'area del machine learning meno conosciuta ma estremamente preziosa per le applicazioni industriali e aziendali, tra gli altri campi. Sebbene le reti neurali possano essere utilizzate per migliorare l'utilità di questi modelli, li studieremo nel contesto del machine learning classico poiché i modelli aiutano a prevedere le prestazioni future basandosi sul passato. - -Il nostro focus regionale è il consumo di elettricità nel mondo, un dataset interessante per imparare a prevedere il consumo futuro di energia basandosi sui modelli di carico passati. Puoi vedere come questo tipo di previsione possa essere estremamente utile in un ambiente aziendale. - -![rete elettrica](../../../translated_images/electric-grid.0c21d5214db09ffae93c06a87ca2abbb9ba7475ef815129c5b423d7f9a7cf136.it.jpg) - -Foto di [Peddi Sai hrithik](https://unsplash.com/@shutter_log?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) di torri elettriche su una strada in Rajasthan su [Unsplash](https://unsplash.com/s/photos/electric-india?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) - -## Lezioni - -1. [Introduzione alla previsione delle serie temporali](1-Introduction/README.md) -2. [Costruzione di modelli ARIMA per serie temporali](2-ARIMA/README.md) -3. [Costruzione di un Support Vector Regressor per la previsione delle serie temporali](3-SVR/README.md) - -## Crediti - -"L'introduzione alla previsione delle serie temporali" è stata scritta con ⚡️ da [Francesca Lazzeri](https://twitter.com/frlazzeri) e [Jen Looper](https://twitter.com/jenlooper). I notebook sono apparsi per la prima volta online nel [repo Azure "Deep Learning For Time Series"](https://github.com/Azure/DeepLearningForTimeSeriesForecasting) originariamente scritto da Francesca Lazzeri. La lezione SVR è stata scritta da [Anirban Mukherjee](https://github.com/AnirbanMukherjeeXD) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzata basati su intelligenza artificiale. Sebbene ci sforziamo di garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/1-QLearning/README.md b/translations/it/8-Reinforcement/1-QLearning/README.md deleted file mode 100644 index e5b89fedd..000000000 --- a/translations/it/8-Reinforcement/1-QLearning/README.md +++ /dev/null @@ -1,319 +0,0 @@ -## Introduzione al Reinforcement Learning e al Q-Learning - -![Riassunto del reinforcement in machine learning in uno sketchnote](../../../../translated_images/ml-reinforcement.94024374d63348dbb3571c343ca7ddabef72adac0b8086d47164b769ba3a8a1d.it.png) -> Sketchnote di [Tomomi Imura](https://www.twitter.com/girlie_mac) - -Il reinforcement learning coinvolge tre concetti importanti: l'agente, alcuni stati e un insieme di azioni per ogni stato. Eseguendo un'azione in uno stato specificato, l'agente riceve una ricompensa. Immagina di nuovo il videogioco Super Mario. Sei Mario, sei in un livello del gioco, in piedi accanto a un dirupo. Sopra di te c'è una moneta. Essere Mario, in un livello del gioco, in una posizione specifica ... quello è il tuo stato. Muoversi di un passo a destra (un'azione) ti farà cadere nel vuoto, e ciò ti darebbe un punteggio numerico basso. Tuttavia, premendo il pulsante di salto otterresti un punto e rimarresti vivo. Questo è un risultato positivo e dovrebbe premiarti con un punteggio numerico positivo. - -Utilizzando il reinforcement learning e un simulatore (il gioco), puoi imparare a giocare per massimizzare la ricompensa che consiste nel rimanere vivo e segnare il maggior numero di punti possibile. - -[![Intro al Reinforcement Learning](https://img.youtube.com/vi/lDq_en8RNOo/0.jpg)](https://www.youtube.com/watch?v=lDq_en8RNOo) - -> 🎥 Clicca sull'immagine sopra per ascoltare Dmitry parlare del Reinforcement Learning - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/45/) - -## Prerequisiti e Setup - -In questa lezione, sperimenteremo un po' di codice in Python. Dovresti essere in grado di eseguire il codice del Jupyter Notebook di questa lezione, sia sul tuo computer che da qualche parte nel cloud. - -Puoi aprire [il notebook della lezione](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/notebook.ipynb) e seguire questa lezione per costruire. - -> **Nota:** Se stai aprendo questo codice dal cloud, devi anche recuperare il file [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), che viene utilizzato nel codice del notebook. Aggiungilo nella stessa directory del notebook. - -## Introduzione - -In questa lezione, esploreremo il mondo di **[Peter e il lupo](https://en.wikipedia.org/wiki/Peter_and_the_Wolf)**, ispirato a una fiaba musicale di un compositore russo, [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). Utilizzeremo il **Reinforcement Learning** per permettere a Peter di esplorare il suo ambiente, raccogliere gustose mele ed evitare di incontrare il lupo. - -Il **Reinforcement Learning** (RL) è una tecnica di apprendimento che ci permette di apprendere un comportamento ottimale di un **agente** in un certo **ambiente** eseguendo molti esperimenti. Un agente in questo ambiente dovrebbe avere un **obiettivo**, definito da una **funzione di ricompensa**. - -## L'ambiente - -Per semplicità, consideriamo il mondo di Peter come una scacchiera di dimensioni `width` x `height`, come questa: - -![L'Ambiente di Peter](../../../../translated_images/environment.40ba3cb66256c93fa7e92f6f7214e1d1f588aafa97d266c11d108c5c5d101b6c.it.png) - -Ogni cella in questa scacchiera può essere: - -* **terra**, su cui Peter e altre creature possono camminare. -* **acqua**, su cui ovviamente non si può camminare. -* un **albero** o **erba**, un luogo dove si può riposare. -* una **mela**, che rappresenta qualcosa che Peter sarebbe felice di trovare per nutrirsi. -* un **lupo**, che è pericoloso e dovrebbe essere evitato. - -C'è un modulo Python separato, [`rlboard.py`](https://github.com/microsoft/ML-For-Beginners/blob/main/8-Reinforcement/1-QLearning/rlboard.py), che contiene il codice per lavorare con questo ambiente. Poiché questo codice non è importante per comprendere i nostri concetti, importeremo il modulo e lo utilizzeremo per creare la scacchiera di esempio (blocco di codice 1): - -```python -from rlboard import * - -width, height = 8,8 -m = Board(width,height) -m.randomize(seed=13) -m.plot() -``` - -Questo codice dovrebbe stampare un'immagine dell'ambiente simile a quella sopra. - -## Azioni e politica - -Nel nostro esempio, l'obiettivo di Peter sarebbe trovare una mela, evitando il lupo e altri ostacoli. Per fare ciò, può essenzialmente camminare in giro fino a trovare una mela. - -Pertanto, in qualsiasi posizione, può scegliere tra una delle seguenti azioni: su, giù, sinistra e destra. - -Definiremo queste azioni come un dizionario e le mapperemo a coppie di cambiamenti di coordinate corrispondenti. Ad esempio, muoversi a destra (`R`) would correspond to a pair `(1,0)`. (blocco di codice 2): - -```python -actions = { "U" : (0,-1), "D" : (0,1), "L" : (-1,0), "R" : (1,0) } -action_idx = { a : i for i,a in enumerate(actions.keys()) } -``` - -Riassumendo, la strategia e l'obiettivo di questo scenario sono i seguenti: - -- **La strategia**, del nostro agente (Peter) è definita da una cosiddetta **politica**. Una politica è una funzione che restituisce l'azione in qualsiasi stato dato. Nel nostro caso, lo stato del problema è rappresentato dalla scacchiera, inclusa la posizione attuale del giocatore. - -- **L'obiettivo**, del reinforcement learning è alla fine imparare una buona politica che ci permetta di risolvere il problema in modo efficiente. Tuttavia, come base, consideriamo la politica più semplice chiamata **camminata casuale**. - -## Camminata casuale - -Per prima cosa risolviamo il nostro problema implementando una strategia di camminata casuale. Con la camminata casuale, sceglieremo casualmente la prossima azione tra le azioni consentite, fino a raggiungere la mela (blocco di codice 3). - -1. Implementa la camminata casuale con il codice seguente: - - ```python - def random_policy(m): - return random.choice(list(actions)) - - def walk(m,policy,start_position=None): - n = 0 # number of steps - # set initial position - if start_position: - m.human = start_position - else: - m.random_start() - while True: - if m.at() == Board.Cell.apple: - return n # success! - if m.at() in [Board.Cell.wolf, Board.Cell.water]: - return -1 # eaten by wolf or drowned - while True: - a = actions[policy(m)] - new_pos = m.move_pos(m.human,a) - if m.is_valid(new_pos) and m.at(new_pos)!=Board.Cell.water: - m.move(a) # do the actual move - break - n+=1 - - walk(m,random_policy) - ``` - - La chiamata a `walk` dovrebbe restituire la lunghezza del percorso corrispondente, che può variare da una esecuzione all'altra. - -1. Esegui l'esperimento di camminata un certo numero di volte (diciamo, 100) e stampa le statistiche risultanti (blocco di codice 4): - - ```python - def print_statistics(policy): - s,w,n = 0,0,0 - for _ in range(100): - z = walk(m,policy) - if z<0: - w+=1 - else: - s += z - n += 1 - print(f"Average path length = {s/n}, eaten by wolf: {w} times") - - print_statistics(random_policy) - ``` - - Nota che la lunghezza media di un percorso è intorno ai 30-40 passi, che è piuttosto elevata, dato che la distanza media alla mela più vicina è di circa 5-6 passi. - - Puoi anche vedere come appare il movimento di Peter durante la camminata casuale: - - ![Camminata Casuale di Peter](../../../../8-Reinforcement/1-QLearning/images/random_walk.gif) - -## Funzione di ricompensa - -Per rendere la nostra politica più intelligente, dobbiamo capire quali mosse sono "migliori" delle altre. Per fare ciò, dobbiamo definire il nostro obiettivo. - -L'obiettivo può essere definito in termini di una **funzione di ricompensa**, che restituirà un valore di punteggio per ogni stato. Più alto è il numero, migliore è la funzione di ricompensa. (blocco di codice 5) - -```python -move_reward = -0.1 -goal_reward = 10 -end_reward = -10 - -def reward(m,pos=None): - pos = pos or m.human - if not m.is_valid(pos): - return end_reward - x = m.at(pos) - if x==Board.Cell.water or x == Board.Cell.wolf: - return end_reward - if x==Board.Cell.apple: - return goal_reward - return move_reward -``` - -Una cosa interessante delle funzioni di ricompensa è che nella maggior parte dei casi, *ci viene data una ricompensa sostanziale solo alla fine del gioco*. Questo significa che il nostro algoritmo dovrebbe in qualche modo ricordare i "buoni" passi che portano a una ricompensa positiva alla fine e aumentare la loro importanza. Allo stesso modo, tutte le mosse che portano a risultati negativi dovrebbero essere scoraggiate. - -## Q-Learning - -Un algoritmo di cui discuteremo qui è chiamato **Q-Learning**. In questo algoritmo, la politica è definita da una funzione (o una struttura dati) chiamata **Q-Table**. Registra la "bontà" di ciascuna delle azioni in uno stato dato. - -Si chiama Q-Table perché spesso è conveniente rappresentarla come una tabella, o array multidimensionale. Poiché la nostra scacchiera ha dimensioni `width` x `height`, possiamo rappresentare la Q-Table utilizzando un array numpy con forma `width` x `height` x `len(actions)`: (blocco di codice 6) - -```python -Q = np.ones((width,height,len(actions)),dtype=np.float)*1.0/len(actions) -``` - -Nota che inizializziamo tutti i valori della Q-Table con un valore uguale, nel nostro caso - 0.25. Questo corrisponde alla politica della "camminata casuale", perché tutte le mosse in ogni stato sono ugualmente buone. Possiamo passare la Q-Table al `plot` function in order to visualize the table on the board: `m.plot(Q)`. - -![Peter's Environment](../../../../translated_images/env_init.04e8f26d2d60089e128f21d22e5fef57d580e559f0d5937b06c689e5e7cdd438.it.png) - -In the center of each cell there is an "arrow" that indicates the preferred direction of movement. Since all directions are equal, a dot is displayed. - -Now we need to run the simulation, explore our environment, and learn a better distribution of Q-Table values, which will allow us to find the path to the apple much faster. - -## Essence of Q-Learning: Bellman Equation - -Once we start moving, each action will have a corresponding reward, i.e. we can theoretically select the next action based on the highest immediate reward. However, in most states, the move will not achieve our goal of reaching the apple, and thus we cannot immediately decide which direction is better. - -> Remember that it is not the immediate result that matters, but rather the final result, which we will obtain at the end of the simulation. - -In order to account for this delayed reward, we need to use the principles of **[dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming)**, which allow us to think about out problem recursively. - -Suppose we are now at the state *s*, and we want to move to the next state *s'*. By doing so, we will receive the immediate reward *r(s,a)*, defined by the reward function, plus some future reward. If we suppose that our Q-Table correctly reflects the "attractiveness" of each action, then at state *s'* we will chose an action *a* that corresponds to maximum value of *Q(s',a')*. Thus, the best possible future reward we could get at state *s* will be defined as `max`a'*Q(s',a')* (maximum here is computed over all possible actions *a'* at state *s'*). - -This gives the **Bellman formula** for calculating the value of the Q-Table at state *s*, given action *a*: - - - -Here γ is the so-called **discount factor** that determines to which extent you should prefer the current reward over the future reward and vice versa. - -## Learning Algorithm - -Given the equation above, we can now write pseudo-code for our learning algorithm: - -* Initialize Q-Table Q with equal numbers for all states and actions -* Set learning rate α ← 1 -* Repeat simulation many times - 1. Start at random position - 1. Repeat - 1. Select an action *a* at state *s* - 2. Execute action by moving to a new state *s'* - 3. If we encounter end-of-game condition, or total reward is too small - exit simulation - 4. Compute reward *r* at the new state - 5. Update Q-Function according to Bellman equation: *Q(s,a)* ← *(1-α)Q(s,a)+α(r+γ maxa'Q(s',a'))* - 6. *s* ← *s'* - 7. Update the total reward and decrease α. - -## Exploit vs. explore - -In the algorithm above, we did not specify how exactly we should choose an action at step 2.1. If we are choosing the action randomly, we will randomly **explore** the environment, and we are quite likely to die often as well as explore areas where we would not normally go. An alternative approach would be to **exploit** the Q-Table values that we already know, and thus to choose the best action (with higher Q-Table value) at state *s*. This, however, will prevent us from exploring other states, and it's likely we might not find the optimal solution. - -Thus, the best approach is to strike a balance between exploration and exploitation. This can be done by choosing the action at state *s* with probabilities proportional to values in the Q-Table. In the beginning, when Q-Table values are all the same, it would correspond to a random selection, but as we learn more about our environment, we would be more likely to follow the optimal route while allowing the agent to choose the unexplored path once in a while. - -## Python implementation - -We are now ready to implement the learning algorithm. Before we do that, we also need some function that will convert arbitrary numbers in the Q-Table into a vector of probabilities for corresponding actions. - -1. Create a function `probs()`: - - ```python - def probs(v,eps=1e-4): - v = v-v.min()+eps - v = v/v.sum() - return v - ``` - - Aggiungiamo alcuni `eps` al vettore originale per evitare la divisione per 0 nel caso iniziale, quando tutti i componenti del vettore sono identici. - -Esegui l'algoritmo di apprendimento attraverso 5000 esperimenti, chiamati anche **epoche**: (blocco di codice 8) -```python - for epoch in range(5000): - - # Pick initial point - m.random_start() - - # Start travelling - n=0 - cum_reward = 0 - while True: - x,y = m.human - v = probs(Q[x,y]) - a = random.choices(list(actions),weights=v)[0] - dpos = actions[a] - m.move(dpos,check_correctness=False) # we allow player to move outside the board, which terminates episode - r = reward(m) - cum_reward += r - if r==end_reward or cum_reward < -1000: - lpath.append(n) - break - alpha = np.exp(-n / 10e5) - gamma = 0.5 - ai = action_idx[a] - Q[x,y,ai] = (1 - alpha) * Q[x,y,ai] + alpha * (r + gamma * Q[x+dpos[0], y+dpos[1]].max()) - n+=1 -``` - -Dopo aver eseguito questo algoritmo, la Q-Table dovrebbe essere aggiornata con valori che definiscono l'attrattività delle diverse azioni a ogni passo. Possiamo provare a visualizzare la Q-Table tracciando un vettore in ogni cella che indicherà la direzione desiderata del movimento. Per semplicità, disegniamo un piccolo cerchio invece della punta di una freccia. - -## Verifica della politica - -Poiché la Q-Table elenca l'"attrattività" di ciascuna azione in ogni stato, è abbastanza facile utilizzarla per definire la navigazione efficiente nel nostro mondo. Nel caso più semplice, possiamo selezionare l'azione corrispondente al valore Q-Table più alto: (blocco di codice 9) - -```python -def qpolicy_strict(m): - x,y = m.human - v = probs(Q[x,y]) - a = list(actions)[np.argmax(v)] - return a - -walk(m,qpolicy_strict) -``` - -> Se provi il codice sopra diverse volte, potresti notare che a volte si "blocca" e devi premere il pulsante STOP nel notebook per interromperlo. Questo accade perché potrebbero esserci situazioni in cui due stati "puntano" l'uno all'altro in termini di valore Q ottimale, nel qual caso l'agente finisce per muoversi tra quegli stati indefinitamente. - -## 🚀Sfida - -> **Compito 1:** Modifica il `walk` function to limit the maximum length of path by a certain number of steps (say, 100), and watch the code above return this value from time to time. - -> **Task 2:** Modify the `walk` function so that it does not go back to the places where it has already been previously. This will prevent `walk` from looping, however, the agent can still end up being "trapped" in a location from which it is unable to escape. - -## Navigation - -A better navigation policy would be the one that we used during training, which combines exploitation and exploration. In this policy, we will select each action with a certain probability, proportional to the values in the Q-Table. This strategy may still result in the agent returning back to a position it has already explored, but, as you can see from the code below, it results in a very short average path to the desired location (remember that `print_statistics` esegue la simulazione 100 volte): (blocco di codice 10) - -```python -def qpolicy(m): - x,y = m.human - v = probs(Q[x,y]) - a = random.choices(list(actions),weights=v)[0] - return a - -print_statistics(qpolicy) -``` - -Dopo aver eseguito questo codice, dovresti ottenere una lunghezza media del percorso molto più piccola rispetto a prima, nell'intervallo di 3-6. - -## Indagare il processo di apprendimento - -Come abbiamo menzionato, il processo di apprendimento è un equilibrio tra esplorazione e esplorazione della conoscenza acquisita sulla struttura dello spazio dei problemi. Abbiamo visto che i risultati dell'apprendimento (la capacità di aiutare un agente a trovare un percorso breve verso l'obiettivo) sono migliorati, ma è anche interessante osservare come si comporta la lunghezza media del percorso durante il processo di apprendimento: - -Le lezioni possono essere riassunte come: - -- **Aumento della lunghezza media del percorso**. Quello che vediamo qui è che all'inizio, la lunghezza media del percorso aumenta. Questo è probabilmente dovuto al fatto che quando non sappiamo nulla sull'ambiente, è probabile che ci imbattiamo in stati negativi, acqua o lupo. Man mano che impariamo di più e iniziamo a utilizzare questa conoscenza, possiamo esplorare l'ambiente per più tempo, ma non sappiamo ancora bene dove si trovano le mele. - -- **Diminuzione della lunghezza del percorso, man mano che impariamo di più**. Una volta che impariamo abbastanza, diventa più facile per l'agente raggiungere l'obiettivo, e la lunghezza del percorso inizia a diminuire. Tuttavia, siamo ancora aperti all'esplorazione, quindi spesso ci allontaniamo dal percorso migliore e esploriamo nuove opzioni, rendendo il percorso più lungo del necessario. - -- **Aumento improvviso della lunghezza**. Quello che osserviamo anche su questo grafico è che a un certo punto, la lunghezza è aumentata improvvisamente. Questo indica la natura stocastica del processo, e che a un certo punto possiamo "rovinare" i coefficienti della Q-Table sovrascrivendoli con nuovi valori. Questo dovrebbe idealmente essere minimizzato riducendo il tasso di apprendimento (ad esempio, verso la fine dell'addestramento, regoliamo i valori della Q-Table solo di un piccolo valore). - -In generale, è importante ricordare che il successo e la qualità del processo di apprendimento dipendono significativamente dai parametri, come il tasso di apprendimento, la decadenza del tasso di apprendimento e il fattore di sconto. Questi sono spesso chiamati **iperparametri**, per distinguerli dai **parametri**, che ottimizziamo durante l'addestramento (ad esempio, i coefficienti della Q-Table). Il processo di trovare i migliori valori degli iperparametri è chiamato **ottimizzazione degli iperparametri**, e merita un argomento a parte. - -## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/46/) - -## Compito -[Un Mondo Più Realistico](assignment.md) - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/1-QLearning/assignment.md b/translations/it/8-Reinforcement/1-QLearning/assignment.md deleted file mode 100644 index d91102cf7..000000000 --- a/translations/it/8-Reinforcement/1-QLearning/assignment.md +++ /dev/null @@ -1,30 +0,0 @@ -# Un Mondo Più Realistico - -Nella nostra situazione, Peter era in grado di muoversi quasi senza stancarsi o avere fame. In un mondo più realistico, deve sedersi e riposare di tanto in tanto, e anche nutrirsi. Rendiamo il nostro mondo più realistico, implementando le seguenti regole: - -1. Spostandosi da un luogo all'altro, Peter perde **energia** e guadagna un po' di **fatica**. -2. Peter può guadagnare più energia mangiando mele. -3. Peter può liberarsi della fatica riposando sotto l'albero o sull'erba (cioè camminando in una posizione della tavola con un albero o erba - campo verde) -4. Peter deve trovare e uccidere il lupo. -5. Per uccidere il lupo, Peter deve avere certi livelli di energia e fatica, altrimenti perde la battaglia. - -## Istruzioni - -Usa il [notebook.ipynb](../../../../8-Reinforcement/1-QLearning/notebook.ipynb) originale come punto di partenza per la tua soluzione. - -Modifica la funzione di ricompensa sopra secondo le regole del gioco, esegui l'algoritmo di apprendimento per rinforzo per imparare la migliore strategia per vincere il gioco, e confronta i risultati del cammino casuale con il tuo algoritmo in termini di numero di giochi vinti e persi. - -> **Note**: Nel tuo nuovo mondo, lo stato è più complesso, e oltre alla posizione umana include anche i livelli di fatica e energia. Puoi scegliere di rappresentare lo stato come una tupla (Board,energy,fatigue), o definire una classe per lo stato (puoi anche voler derivarla da `Board`), o anche modificare la classe originale `Board` all'interno di [rlboard.py](../../../../8-Reinforcement/1-QLearning/rlboard.py). - -Nella tua soluzione, per favore mantieni il codice responsabile della strategia del cammino casuale, e confronta i risultati del tuo algoritmo con il cammino casuale alla fine. - -> **Note**: Potrebbe essere necessario regolare gli iperparametri per farlo funzionare, specialmente il numero di epoche. Poiché il successo del gioco (combattere il lupo) è un evento raro, puoi aspettarti tempi di allenamento molto più lunghi. - -## Rubrica - -| Criteri | Esemplare | Adeguato | Bisogno di Miglioramento | -| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | -| | Un notebook è presentato con la definizione delle nuove regole del mondo, algoritmo Q-Learning e alcune spiegazioni testuali. Q-Learning è in grado di migliorare significativamente i risultati rispetto al cammino casuale. | Il notebook è presentato, Q-Learning è implementato e migliora i risultati rispetto al cammino casuale, ma non significativamente; o il notebook è scarsamente documentato e il codice non è ben strutturato | È stato fatto qualche tentativo di ridefinire le regole del mondo, ma l'algoritmo Q-Learning non funziona, o la funzione di ricompensa non è completamente definita | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/1-QLearning/solution/Julia/README.md b/translations/it/8-Reinforcement/1-QLearning/solution/Julia/README.md deleted file mode 100644 index 434620a63..000000000 --- a/translations/it/8-Reinforcement/1-QLearning/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/1-QLearning/solution/R/README.md b/translations/it/8-Reinforcement/1-QLearning/solution/R/README.md deleted file mode 100644 index dd36ee3d8..000000000 --- a/translations/it/8-Reinforcement/1-QLearning/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/2-Gym/README.md b/translations/it/8-Reinforcement/2-Gym/README.md deleted file mode 100644 index 49403b0c9..000000000 --- a/translations/it/8-Reinforcement/2-Gym/README.md +++ /dev/null @@ -1,342 +0,0 @@ -# CartPole Skating - -Il problema che abbiamo risolto nella lezione precedente potrebbe sembrare un problema giocattolo, non realmente applicabile a scenari di vita reale. Non è così, perché molti problemi del mondo reale condividono questo scenario - incluso giocare a scacchi o Go. Sono simili, perché abbiamo anche una scacchiera con regole date e uno **stato discreto**. - -## [Quiz Pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/47/) - -## Introduzione - -In questa lezione applicheremo gli stessi principi del Q-Learning a un problema con **stato continuo**, cioè uno stato che è dato da uno o più numeri reali. Ci occuperemo del seguente problema: - -> **Problema**: Se Peter vuole scappare dal lupo, deve essere in grado di muoversi più velocemente. Vedremo come Peter può imparare a pattinare, in particolare, a mantenere l'equilibrio, usando il Q-Learning. - -![La grande fuga!](../../../../translated_images/escape.18862db9930337e3fce23a9b6a76a06445f229dadea2268e12a6f0a1fde12115.it.png) - -> Peter e i suoi amici diventano creativi per scappare dal lupo! Immagine di [Jen Looper](https://twitter.com/jenlooper) - -Utilizzeremo una versione semplificata del mantenimento dell'equilibrio nota come problema **CartPole**. Nel mondo del cartpole, abbiamo uno slider orizzontale che può muoversi a sinistra o a destra, e l'obiettivo è mantenere in equilibrio un palo verticale sulla parte superiore dello slider. - -## Prerequisiti - -In questa lezione, utilizzeremo una libreria chiamata **OpenAI Gym** per simulare diversi **ambienti**. Puoi eseguire il codice di questa lezione localmente (ad esempio da Visual Studio Code), nel qual caso la simulazione si aprirà in una nuova finestra. Quando esegui il codice online, potresti dover apportare alcune modifiche al codice, come descritto [qui](https://towardsdatascience.com/rendering-openai-gym-envs-on-binder-and-google-colab-536f99391cc7). - -## OpenAI Gym - -Nella lezione precedente, le regole del gioco e lo stato erano dati dalla classe `Board` che abbiamo definito noi stessi. Qui utilizzeremo un **ambiente di simulazione** speciale, che simulerà la fisica dietro il palo in equilibrio. Uno degli ambienti di simulazione più popolari per l'addestramento degli algoritmi di apprendimento per rinforzo è chiamato [Gym](https://gym.openai.com/), che è mantenuto da [OpenAI](https://openai.com/). Utilizzando questo gym possiamo creare diversi **ambienti** da una simulazione di cartpole a giochi Atari. - -> **Nota**: Puoi vedere altri ambienti disponibili da OpenAI Gym [qui](https://gym.openai.com/envs/#classic_control). - -Prima, installiamo il gym e importiamo le librerie necessarie (blocco di codice 1): - -```python -import sys -!{sys.executable} -m pip install gym - -import gym -import matplotlib.pyplot as plt -import numpy as np -import random -``` - -## Esercizio - inizializzare un ambiente cartpole - -Per lavorare con un problema di equilibrio del cartpole, dobbiamo inizializzare l'ambiente corrispondente. Ogni ambiente è associato a: - -- **Observation space** che definisce la struttura delle informazioni che riceviamo dall'ambiente. Per il problema del cartpole, riceviamo la posizione del palo, la velocità e altri valori. - -- **Action space** che definisce le azioni possibili. Nel nostro caso lo spazio delle azioni è discreto e consiste in due azioni - **sinistra** e **destra**. (blocco di codice 2) - -1. Per inizializzare, digita il seguente codice: - - ```python - env = gym.make("CartPole-v1") - print(env.action_space) - print(env.observation_space) - print(env.action_space.sample()) - ``` - -Per vedere come funziona l'ambiente, eseguiamo una breve simulazione per 100 passi. Ad ogni passo, forniamo una delle azioni da intraprendere - in questa simulazione selezioniamo casualmente un'azione da `action_space`. - -1. Esegui il codice qui sotto e vedi a cosa porta. - - ✅ Ricorda che è preferibile eseguire questo codice su un'installazione locale di Python! (blocco di codice 3) - - ```python - env.reset() - - for i in range(100): - env.render() - env.step(env.action_space.sample()) - env.close() - ``` - - Dovresti vedere qualcosa di simile a questa immagine: - - ![cartpole senza equilibrio](../../../../8-Reinforcement/2-Gym/images/cartpole-nobalance.gif) - -1. Durante la simulazione, dobbiamo ottenere osservazioni per decidere come agire. Infatti, la funzione step restituisce le osservazioni attuali, una funzione di ricompensa e il flag done che indica se ha senso continuare la simulazione o meno: (blocco di codice 4) - - ```python - env.reset() - - done = False - while not done: - env.render() - obs, rew, done, info = env.step(env.action_space.sample()) - print(f"{obs} -> {rew}") - env.close() - ``` - - Finirai per vedere qualcosa di simile a questo nell'output del notebook: - - ```text - [ 0.03403272 -0.24301182 0.02669811 0.2895829 ] -> 1.0 - [ 0.02917248 -0.04828055 0.03248977 0.00543839] -> 1.0 - [ 0.02820687 0.14636075 0.03259854 -0.27681916] -> 1.0 - [ 0.03113408 0.34100283 0.02706215 -0.55904489] -> 1.0 - [ 0.03795414 0.53573468 0.01588125 -0.84308041] -> 1.0 - ... - [ 0.17299878 0.15868546 -0.20754175 -0.55975453] -> 1.0 - [ 0.17617249 0.35602306 -0.21873684 -0.90998894] -> 1.0 - ``` - - Il vettore di osservazione che viene restituito ad ogni passo della simulazione contiene i seguenti valori: - - Posizione del carrello - - Velocità del carrello - - Angolo del palo - - Velocità di rotazione del palo - -1. Ottieni il valore minimo e massimo di questi numeri: (blocco di codice 5) - - ```python - print(env.observation_space.low) - print(env.observation_space.high) - ``` - - Potresti anche notare che il valore della ricompensa ad ogni passo della simulazione è sempre 1. Questo perché il nostro obiettivo è sopravvivere il più a lungo possibile, cioè mantenere il palo in una posizione ragionevolmente verticale per il periodo di tempo più lungo possibile. - - ✅ In effetti, la simulazione del CartPole è considerata risolta se riusciamo a ottenere una ricompensa media di 195 su 100 prove consecutive. - -## Discretizzazione dello stato - -Nel Q-Learning, dobbiamo costruire una Q-Table che definisca cosa fare in ogni stato. Per poter fare questo, lo stato deve essere **discreto**, più precisamente, deve contenere un numero finito di valori discreti. Pertanto, dobbiamo in qualche modo **discretizzare** le nostre osservazioni, mappandole su un insieme finito di stati. - -Ci sono alcuni modi in cui possiamo farlo: - -- **Dividere in bin**. Se conosciamo l'intervallo di un certo valore, possiamo dividere questo intervallo in un numero di **bin**, e poi sostituire il valore con il numero del bin a cui appartiene. Questo può essere fatto usando il metodo numpy [`digitize`](https://numpy.org/doc/stable/reference/generated/numpy.digitize.html). In questo caso, conosceremo esattamente la dimensione dello stato, perché dipenderà dal numero di bin che selezioniamo per la digitalizzazione. - -✅ Possiamo usare l'interpolazione lineare per portare i valori a un intervallo finito (diciamo, da -20 a 20), e poi convertire i numeri in interi arrotondandoli. Questo ci dà un po' meno controllo sulla dimensione dello stato, soprattutto se non conosciamo gli intervalli esatti dei valori di input. Ad esempio, nel nostro caso 2 dei 4 valori non hanno limiti superiori/inferiori sui loro valori, il che può comportare un numero infinito di stati. - -Nel nostro esempio, utilizzeremo il secondo approccio. Come potresti notare più avanti, nonostante i limiti superiori/inferiori indefiniti, quei valori raramente assumono valori al di fuori di certi intervalli finiti, quindi quegli stati con valori estremi saranno molto rari. - -1. Ecco la funzione che prenderà l'osservazione dal nostro modello e produrrà una tupla di 4 valori interi: (blocco di codice 6) - - ```python - def discretize(x): - return tuple((x/np.array([0.25, 0.25, 0.01, 0.1])).astype(np.int)) - ``` - -1. Esploriamo anche un altro metodo di discretizzazione usando i bin: (blocco di codice 7) - - ```python - def create_bins(i,num): - return np.arange(num+1)*(i[1]-i[0])/num+i[0] - - print("Sample bins for interval (-5,5) with 10 bins\n",create_bins((-5,5),10)) - - ints = [(-5,5),(-2,2),(-0.5,0.5),(-2,2)] # intervals of values for each parameter - nbins = [20,20,10,10] # number of bins for each parameter - bins = [create_bins(ints[i],nbins[i]) for i in range(4)] - - def discretize_bins(x): - return tuple(np.digitize(x[i],bins[i]) for i in range(4)) - ``` - -1. Ora eseguiamo una breve simulazione e osserviamo quei valori discreti dell'ambiente. Sentiti libero di provare sia `discretize` and `discretize_bins` e vedere se c'è una differenza. - - ✅ discretize_bins restituisce il numero del bin, che è basato su 0. Quindi per i valori della variabile di input intorno a 0 restituisce il numero dal centro dell'intervallo (10). In discretize, non ci siamo preoccupati dell'intervallo dei valori di output, permettendo loro di essere negativi, quindi i valori dello stato non sono spostati, e 0 corrisponde a 0. (blocco di codice 8) - - ```python - env.reset() - - done = False - while not done: - #env.render() - obs, rew, done, info = env.step(env.action_space.sample()) - #print(discretize_bins(obs)) - print(discretize(obs)) - env.close() - ``` - - ✅ Decommenta la riga che inizia con env.render se vuoi vedere come l'ambiente viene eseguito. Altrimenti puoi eseguirlo in background, che è più veloce. Utilizzeremo questa esecuzione "invisibile" durante il nostro processo di Q-Learning. - -## La struttura della Q-Table - -Nella nostra lezione precedente, lo stato era una semplice coppia di numeri da 0 a 8, quindi era conveniente rappresentare la Q-Table con un tensore numpy con una forma di 8x8x2. Se usiamo la discretizzazione dei bin, la dimensione del nostro vettore di stato è anche conosciuta, quindi possiamo usare lo stesso approccio e rappresentare lo stato con un array di forma 20x20x10x10x2 (qui 2 è la dimensione dello spazio delle azioni, e le prime dimensioni corrispondono al numero di bin che abbiamo selezionato per ciascuno dei parametri nello spazio delle osservazioni). - -Tuttavia, a volte le dimensioni precise dello spazio delle osservazioni non sono conosciute. Nel caso della funzione `discretize`, potremmo non essere mai sicuri che il nostro stato rimanga entro certi limiti, perché alcuni dei valori originali non sono limitati. Pertanto, utilizzeremo un approccio leggermente diverso e rappresenteremo la Q-Table con un dizionario. - -1. Usa la coppia *(stato, azione)* come chiave del dizionario, e il valore corrisponderebbe al valore dell'entry della Q-Table. (blocco di codice 9) - - ```python - Q = {} - actions = (0,1) - - def qvalues(state): - return [Q.get((state,a),0) for a in actions] - ``` - - Qui definiamo anche una funzione `qvalues()`, che restituisce una lista di valori della Q-Table per un dato stato che corrisponde a tutte le azioni possibili. Se l'entry non è presente nella Q-Table, restituiremo 0 come valore predefinito. - -## Iniziamo il Q-Learning - -Ora siamo pronti a insegnare a Peter a mantenere l'equilibrio! - -1. Prima, impostiamo alcuni iperparametri: (blocco di codice 10) - - ```python - # hyperparameters - alpha = 0.3 - gamma = 0.9 - epsilon = 0.90 - ``` - - Qui, `alpha` is the **learning rate** that defines to which extent we should adjust the current values of Q-Table at each step. In the previous lesson we started with 1, and then decreased `alpha` to lower values during training. In this example we will keep it constant just for simplicity, and you can experiment with adjusting `alpha` values later. - - `gamma` is the **discount factor** that shows to which extent we should prioritize future reward over current reward. - - `epsilon` is the **exploration/exploitation factor** that determines whether we should prefer exploration to exploitation or vice versa. In our algorithm, we will in `epsilon` percent of the cases select the next action according to Q-Table values, and in the remaining number of cases we will execute a random action. This will allow us to explore areas of the search space that we have never seen before. - - ✅ In terms of balancing - choosing random action (exploration) would act as a random punch in the wrong direction, and the pole would have to learn how to recover the balance from those "mistakes" - -### Improve the algorithm - -We can also make two improvements to our algorithm from the previous lesson: - -- **Calculate average cumulative reward**, over a number of simulations. We will print the progress each 5000 iterations, and we will average out our cumulative reward over that period of time. It means that if we get more than 195 point - we can consider the problem solved, with even higher quality than required. - -- **Calculate maximum average cumulative result**, `Qmax`, and we will store the Q-Table corresponding to that result. When you run the training you will notice that sometimes the average cumulative result starts to drop, and we want to keep the values of Q-Table that correspond to the best model observed during training. - -1. Collect all cumulative rewards at each simulation at `rewards` per ulteriori grafici. (blocco di codice 11) - - ```python - def probs(v,eps=1e-4): - v = v-v.min()+eps - v = v/v.sum() - return v - - Qmax = 0 - cum_rewards = [] - rewards = [] - for epoch in range(100000): - obs = env.reset() - done = False - cum_reward=0 - # == do the simulation == - while not done: - s = discretize(obs) - if random.random() Qmax: - Qmax = np.average(cum_rewards) - Qbest = Q - cum_rewards=[] - ``` - -Quello che potresti notare da questi risultati: - -- **Vicino al nostro obiettivo**. Siamo molto vicini a raggiungere l'obiettivo di ottenere 195 ricompense cumulative su 100+ esecuzioni consecutive della simulazione, o potremmo averlo effettivamente raggiunto! Anche se otteniamo numeri più piccoli, non lo sappiamo ancora, perché facciamo una media su 5000 esecuzioni, e solo 100 esecuzioni sono richieste nei criteri formali. - -- **La ricompensa inizia a diminuire**. A volte la ricompensa inizia a diminuire, il che significa che possiamo "distruggere" i valori già appresi nella Q-Table con quelli che peggiorano la situazione. - -Questa osservazione è più chiaramente visibile se tracciamo il progresso dell'addestramento. - -## Tracciare il progresso dell'addestramento - -Durante l'addestramento, abbiamo raccolto il valore della ricompensa cumulativa a ciascuna delle iterazioni nel vettore `rewards`. Ecco come appare quando lo tracciamo contro il numero di iterazioni: - -```python -plt.plot(rewards) -``` - -![progresso grezzo](../../../../translated_images/train_progress_raw.2adfdf2daea09c596fc786fa347a23e9aceffe1b463e2257d20a9505794823ec.it.png) - -Da questo grafico, non è possibile dire nulla, perché a causa della natura del processo di addestramento stocastico la durata delle sessioni di addestramento varia notevolmente. Per dare più senso a questo grafico, possiamo calcolare la **media mobile** su una serie di esperimenti, diciamo 100. Questo può essere fatto comodamente usando `np.convolve`: (blocco di codice 12) - -```python -def running_average(x,window): - return np.convolve(x,np.ones(window)/window,mode='valid') - -plt.plot(running_average(rewards,100)) -``` - -![progresso dell'addestramento](../../../../translated_images/train_progress_runav.c71694a8fa9ab35935aff6f109e5ecdfdbdf1b0ae265da49479a81b5fae8f0aa.it.png) - -## Variazione degli iperparametri - -Per rendere l'apprendimento più stabile, ha senso regolare alcuni dei nostri iperparametri durante l'addestramento. In particolare: - -- **Per il tasso di apprendimento**, `alpha`, we may start with values close to 1, and then keep decreasing the parameter. With time, we will be getting good probability values in the Q-Table, and thus we should be adjusting them slightly, and not overwriting completely with new values. - -- **Increase epsilon**. We may want to increase the `epsilon` slowly, in order to explore less and exploit more. It probably makes sense to start with lower value of `epsilon`, e salire fino a quasi 1. - -> **Compito 1**: Gioca con i valori degli iperparametri e vedi se riesci a ottenere una ricompensa cumulativa più alta. Stai ottenendo sopra 195? - -> **Compito 2**: Per risolvere formalmente il problema, devi ottenere una ricompensa media di 195 su 100 esecuzioni consecutive. Misuralo durante l'addestramento e assicurati di aver risolto formalmente il problema! - -## Vedere il risultato in azione - -Sarebbe interessante vedere come si comporta il modello addestrato. Eseguiamo la simulazione e seguiamo la stessa strategia di selezione delle azioni durante l'addestramento, campionando secondo la distribuzione di probabilità nella Q-Table: (blocco di codice 13) - -```python -obs = env.reset() -done = False -while not done: - s = discretize(obs) - env.render() - v = probs(np.array(qvalues(s))) - a = random.choices(actions,weights=v)[0] - obs,_,done,_ = env.step(a) -env.close() -``` - -Dovresti vedere qualcosa di simile a questo: - -![un cartpole in equilibrio](../../../../8-Reinforcement/2-Gym/images/cartpole-balance.gif) - ---- - -## 🚀Sfida - -> **Compito 3**: Qui, abbiamo utilizzato la copia finale della Q-Table, che potrebbe non essere la migliore. Ricorda che abbiamo memorizzato la Q-Table con le migliori prestazioni in `Qbest` variable! Try the same example with the best-performing Q-Table by copying `Qbest` over to `Q` and see if you notice the difference. - -> **Task 4**: Here we were not selecting the best action on each step, but rather sampling with corresponding probability distribution. Would it make more sense to always select the best action, with the highest Q-Table value? This can be done by using `np.argmax` per trovare il numero dell'azione corrispondente al valore più alto della Q-Table. Implementa questa strategia e vedi se migliora l'equilibrio. - -## [Quiz Post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/48/) - -## Compito -[Addestra una Mountain Car](assignment.md) - -## Conclusione - -Abbiamo ora imparato come addestrare agenti per ottenere buoni risultati semplicemente fornendo loro una funzione di ricompensa che definisce lo stato desiderato del gioco e dando loro l'opportunità di esplorare intelligentemente lo spazio di ricerca. Abbiamo applicato con successo l'algoritmo Q-Learning nei casi di ambienti discreti e continui, ma con azioni discrete. - -È importante studiare anche situazioni in cui lo stato delle azioni è continuo e quando lo spazio delle osservazioni è molto più complesso, come l'immagine dello schermo di un gioco Atari. In questi problemi spesso dobbiamo usare tecniche di machine learning più potenti, come le reti neurali, per ottenere buoni risultati. Questi argomenti più avanzati sono l'oggetto del nostro prossimo corso avanzato di IA. - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/2-Gym/assignment.md b/translations/it/8-Reinforcement/2-Gym/assignment.md deleted file mode 100644 index 6b2691aa3..000000000 --- a/translations/it/8-Reinforcement/2-Gym/assignment.md +++ /dev/null @@ -1,43 +0,0 @@ -# Allenare l'Auto di Montagna - -[OpenAI Gym](http://gym.openai.com) è stato progettato in modo tale che tutti gli ambienti forniscano la stessa API - cioè gli stessi metodi `reset`, `step` e `render`, e le stesse astrazioni di **spazio delle azioni** e **spazio delle osservazioni**. Pertanto, dovrebbe essere possibile adattare gli stessi algoritmi di apprendimento per rinforzo a diversi ambienti con minime modifiche al codice. - -## Un Ambiente di Auto di Montagna - -L'[ambiente dell'Auto di Montagna](https://gym.openai.com/envs/MountainCar-v0/) contiene un'auto bloccata in una valle: -L'obiettivo è uscire dalla valle e catturare la bandiera, compiendo ad ogni passo una delle seguenti azioni: - -| Valore | Significato | -|---|---| -| 0 | Accelerare a sinistra | -| 1 | Non accelerare | -| 2 | Accelerare a destra | - -Il trucco principale di questo problema è, tuttavia, che il motore dell'auto non è abbastanza potente da scalare la montagna in un solo passaggio. Pertanto, l'unico modo per avere successo è guidare avanti e indietro per accumulare slancio. - -Lo spazio delle osservazioni consiste di soli due valori: - -| Num | Osservazione | Min | Max | -|-----|--------------|-----|-----| -| 0 | Posizione dell'Auto | -1.2| 0.6 | -| 1 | Velocità dell'Auto | -0.07 | 0.07 | - -Il sistema di ricompensa per l'auto di montagna è piuttosto complicato: - - * Una ricompensa di 0 viene assegnata se l'agente ha raggiunto la bandiera (posizione = 0.5) in cima alla montagna. - * Una ricompensa di -1 viene assegnata se la posizione dell'agente è inferiore a 0.5. - -L'episodio termina se la posizione dell'auto è superiore a 0.5, o se la durata dell'episodio è superiore a 200. -## Istruzioni - -Adatta il nostro algoritmo di apprendimento per rinforzo per risolvere il problema dell'auto di montagna. Inizia con il codice esistente nel [notebook.ipynb](../../../../8-Reinforcement/2-Gym/notebook.ipynb), sostituisci il nuovo ambiente, cambia le funzioni di discretizzazione dello stato e cerca di far allenare l'algoritmo esistente con minime modifiche al codice. Ottimizza il risultato regolando gli iperparametri. - -> **Nota**: È probabile che sia necessario regolare gli iperparametri per far convergere l'algoritmo. -## Rubrica - -| Criteri | Esemplare | Adeguato | Bisogno di Miglioramento | -| -------- | --------- | -------- | ----------------- | -| | L'algoritmo di Q-Learning è stato adattato con successo dall'esempio di CartPole, con minime modifiche al codice, ed è in grado di risolvere il problema di catturare la bandiera in meno di 200 passi. | È stato adottato un nuovo algoritmo di Q-Learning da Internet, ma è ben documentato; oppure l'algoritmo esistente è stato adottato, ma non raggiunge i risultati desiderati | Lo studente non è stato in grado di adottare con successo alcun algoritmo, ma ha fatto passi sostanziali verso la soluzione (implementazione della discretizzazione dello stato, struttura dati della Q-Table, ecc.) | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/2-Gym/solution/Julia/README.md b/translations/it/8-Reinforcement/2-Gym/solution/Julia/README.md deleted file mode 100644 index 36dcdb371..000000000 --- a/translations/it/8-Reinforcement/2-Gym/solution/Julia/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzata basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/2-Gym/solution/R/README.md b/translations/it/8-Reinforcement/2-Gym/solution/R/README.md deleted file mode 100644 index 0d01ffd48..000000000 --- a/translations/it/8-Reinforcement/2-Gym/solution/R/README.md +++ /dev/null @@ -1,4 +0,0 @@ - - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Pur cercando di garantire la massima accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/8-Reinforcement/README.md b/translations/it/8-Reinforcement/README.md deleted file mode 100644 index 6096b76c8..000000000 --- a/translations/it/8-Reinforcement/README.md +++ /dev/null @@ -1,56 +0,0 @@ -# Introduzione all'apprendimento per rinforzo - -L'apprendimento per rinforzo, RL, è considerato uno dei paradigmi fondamentali del machine learning, accanto all'apprendimento supervisionato e non supervisionato. L'RL riguarda le decisioni: prendere le decisioni giuste o almeno imparare da esse. - -Immagina di avere un ambiente simulato come il mercato azionario. Cosa succede se imponi una determinata regolamentazione? Ha un effetto positivo o negativo? Se succede qualcosa di negativo, devi prendere questo _rinforzo negativo_, imparare da esso e cambiare rotta. Se l'esito è positivo, devi costruire su quel _rinforzo positivo_. - -![peter e il lupo](../../../translated_images/peter.779730f9ba3a8a8d9290600dcf55f2e491c0640c785af7ac0d64f583c49b8864.it.png) - -> Peter e i suoi amici devono sfuggire al lupo affamato! Immagine di [Jen Looper](https://twitter.com/jenlooper) - -## Argomento regionale: Peter e il Lupo (Russia) - -[Peter e il Lupo](https://en.wikipedia.org/wiki/Peter_and_the_Wolf) è una fiaba musicale scritta dal compositore russo [Sergei Prokofiev](https://en.wikipedia.org/wiki/Sergei_Prokofiev). È una storia che parla del giovane pioniere Peter, che coraggiosamente esce di casa per inseguire il lupo nella radura della foresta. In questa sezione, addestreremo algoritmi di machine learning che aiuteranno Peter a: - -- **Esplorare** l'area circostante e costruire una mappa di navigazione ottimale -- **Imparare** a usare uno skateboard e a bilanciarsi su di esso, per muoversi più velocemente. - -[![Peter e il Lupo](https://img.youtube.com/vi/Fmi5zHg4QSM/0.jpg)](https://www.youtube.com/watch?v=Fmi5zHg4QSM) - -> 🎥 Clicca sull'immagine sopra per ascoltare Peter e il Lupo di Prokofiev - -## Apprendimento per rinforzo - -Nelle sezioni precedenti, hai visto due esempi di problemi di machine learning: - -- **Supervisionato**, dove abbiamo dataset che suggeriscono soluzioni campione al problema che vogliamo risolvere. [Classificazione](../4-Classification/README.md) e [regressione](../2-Regression/README.md) sono compiti di apprendimento supervisionato. -- **Non supervisionato**, in cui non abbiamo dati di addestramento etichettati. L'esempio principale di apprendimento non supervisionato è il [Clustering](../5-Clustering/README.md). - -In questa sezione, ti introdurremo a un nuovo tipo di problema di apprendimento che non richiede dati di addestramento etichettati. Esistono diversi tipi di tali problemi: - -- **[Apprendimento semi-supervisionato](https://wikipedia.org/wiki/Semi-supervised_learning)**, dove abbiamo molti dati non etichettati che possono essere utilizzati per pre-addestrare il modello. -- **[Apprendimento per rinforzo](https://wikipedia.org/wiki/Reinforcement_learning)**, in cui un agente impara a comportarsi eseguendo esperimenti in un ambiente simulato. - -### Esempio - gioco per computer - -Supponiamo di voler insegnare a un computer a giocare a un gioco, come gli scacchi o [Super Mario](https://wikipedia.org/wiki/Super_Mario). Per far giocare il computer, dobbiamo fargli prevedere quale mossa fare in ciascuno degli stati del gioco. Anche se potrebbe sembrare un problema di classificazione, non lo è - perché non abbiamo un dataset con stati e azioni corrispondenti. Anche se potremmo avere alcuni dati come partite di scacchi esistenti o registrazioni di giocatori che giocano a Super Mario, è probabile che quei dati non coprano sufficientemente un numero sufficiente di stati possibili. - -Invece di cercare dati di gioco esistenti, **l'Apprendimento per Rinforzo** (RL) si basa sull'idea di *far giocare il computer* molte volte e osservare il risultato. Pertanto, per applicare l'Apprendimento per Rinforzo, abbiamo bisogno di due cose: - -- **Un ambiente** e **un simulatore** che ci permettano di giocare molte volte. Questo simulatore definirebbe tutte le regole del gioco, nonché gli stati e le azioni possibili. - -- **Una funzione di ricompensa**, che ci dica quanto bene abbiamo fatto durante ogni mossa o partita. - -La principale differenza tra gli altri tipi di machine learning e l'RL è che nell'RL tipicamente non sappiamo se vinciamo o perdiamo fino a quando non finiamo il gioco. Pertanto, non possiamo dire se una certa mossa da sola sia buona o no - riceviamo una ricompensa solo alla fine del gioco. E il nostro obiettivo è progettare algoritmi che ci permettano di addestrare un modello in condizioni di incertezza. Impareremo un algoritmo di RL chiamato **Q-learning**. - -## Lezioni - -1. [Introduzione all'apprendimento per rinforzo e Q-Learning](1-QLearning/README.md) -2. [Utilizzo di un ambiente di simulazione gym](2-Gym/README.md) - -## Crediti - -"L'Introduzione all'Apprendimento per Rinforzo" è stata scritta con ♥️ da [Dmitry Soshnikov](http://soshnikov.com) - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzati basati su intelligenza artificiale. Sebbene ci sforziamo di garantire l'accuratezza, si prega di notare che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/9-Real-World/1-Applications/README.md b/translations/it/9-Real-World/1-Applications/README.md deleted file mode 100644 index 8785aa769..000000000 --- a/translations/it/9-Real-World/1-Applications/README.md +++ /dev/null @@ -1,149 +0,0 @@ -# Postscript: Machine learning nel mondo reale - -![Riepilogo del machine learning nel mondo reale in uno sketchnote](../../../../translated_images/ml-realworld.26ee2746716155771f8076598b6145e6533fe4a9e2e465ea745f46648cbf1b84.it.png) -> Sketchnote di [Tomomi Imura](https://www.twitter.com/girlie_mac) - -In questo curriculum, hai imparato molti modi per preparare i dati per l'addestramento e creare modelli di machine learning. Hai costruito una serie di modelli classici di regressione, clustering, classificazione, elaborazione del linguaggio naturale e serie temporali. Congratulazioni! Ora, potresti chiederti a cosa serve tutto questo... quali sono le applicazioni reali di questi modelli? - -Sebbene l'interesse dell'industria sia spesso rivolto all'AI, che di solito sfrutta il deep learning, ci sono ancora applicazioni preziose per i modelli classici di machine learning. Potresti persino usare alcune di queste applicazioni oggi stesso! In questa lezione, esplorerai come otto diversi settori e domini tematici utilizzano questi tipi di modelli per rendere le loro applicazioni più performanti, affidabili, intelligenti e preziose per gli utenti. - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/49/) - -## 💰 Finanza - -Il settore finanziario offre molte opportunità per il machine learning. Molti problemi in quest'area possono essere modellati e risolti utilizzando il ML. - -### Rilevamento delle frodi con carta di credito - -Abbiamo imparato riguardo al [k-means clustering](../../5-Clustering/2-K-Means/README.md) in precedenza nel corso, ma come può essere utilizzato per risolvere problemi legati alle frodi con carta di credito? - -Il k-means clustering è utile durante una tecnica di rilevamento delle frodi con carta di credito chiamata **rilevamento degli outlier**. Gli outlier, o deviazioni nelle osservazioni su un insieme di dati, possono dirci se una carta di credito viene utilizzata in modo normale o se sta accadendo qualcosa di insolito. Come mostrato nel documento collegato di seguito, puoi ordinare i dati delle carte di credito utilizzando un algoritmo di k-means clustering e assegnare ogni transazione a un cluster in base a quanto sembra essere un outlier. Poi, puoi valutare i cluster più rischiosi per distinguere tra transazioni fraudolente e legittime. -[Reference](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.680.1195&rep=rep1&type=pdf) - -### Gestione della ricchezza - -Nella gestione della ricchezza, un individuo o un'azienda gestisce investimenti per conto dei propri clienti. Il loro lavoro è sostenere e far crescere la ricchezza a lungo termine, quindi è essenziale scegliere investimenti che performano bene. - -Un modo per valutare come un particolare investimento performa è attraverso la regressione statistica. La [regressione lineare](../../2-Regression/1-Tools/README.md) è uno strumento prezioso per capire come un fondo performa rispetto a un benchmark. Possiamo anche dedurre se i risultati della regressione sono statisticamente significativi o quanto influenzerebbero gli investimenti di un cliente. Puoi anche espandere ulteriormente la tua analisi utilizzando la regressione multipla, dove possono essere considerati ulteriori fattori di rischio. Per un esempio di come questo funzionerebbe per un fondo specifico, dai un'occhiata al documento di seguito sulla valutazione delle performance del fondo utilizzando la regressione. -[Reference](http://www.brightwoodventures.com/evaluating-fund-performance-using-regression/) - -## 🎓 Educazione - -Il settore educativo è anche un'area molto interessante dove il ML può essere applicato. Ci sono problemi interessanti da affrontare come rilevare il cheating nei test o nei saggi o gestire il bias, intenzionale o meno, nel processo di correzione. - -### Prevedere il comportamento degli studenti - -[Coursera](https://coursera.com), un provider di corsi online aperti, ha un ottimo blog tecnico dove discutono molte decisioni ingegneristiche. In questo caso di studio, hanno tracciato una linea di regressione per cercare di esplorare una correlazione tra un basso punteggio NPS (Net Promoter Score) e la ritenzione o l'abbandono del corso. -[Reference](https://medium.com/coursera-engineering/controlled-regression-quantifying-the-impact-of-course-quality-on-learner-retention-31f956bd592a) - -### Mitigare il bias - -[Grammarly](https://grammarly.com), un assistente alla scrittura che controlla errori di ortografia e grammatica, utilizza sofisticati [sistemi di elaborazione del linguaggio naturale](../../6-NLP/README.md) nei suoi prodotti. Hanno pubblicato un interessante caso di studio nel loro blog tecnico su come hanno affrontato il bias di genere nel machine learning, di cui hai appreso nella nostra [lezione introduttiva sull'equità](../../1-Introduction/3-fairness/README.md). -[Reference](https://www.grammarly.com/blog/engineering/mitigating-gender-bias-in-autocorrect/) - -## 👜 Retail - -Il settore retail può sicuramente beneficiare dell'uso del ML, con tutto, dalla creazione di un miglior percorso cliente alla gestione ottimale dell'inventario. - -### Personalizzare il percorso cliente - -A Wayfair, un'azienda che vende articoli per la casa come mobili, aiutare i clienti a trovare i prodotti giusti per i loro gusti e bisogni è fondamentale. In questo articolo, gli ingegneri dell'azienda descrivono come utilizzano il ML e l'NLP per "far emergere i risultati giusti per i clienti". In particolare, il loro Query Intent Engine è stato costruito per utilizzare l'estrazione di entità, l'addestramento di classificatori, l'estrazione di risorse e opinioni e il tagging dei sentimenti nelle recensioni dei clienti. Questo è un classico caso d'uso di come l'NLP funziona nel retail online. -[Reference](https://www.aboutwayfair.com/tech-innovation/how-we-use-machine-learning-and-natural-language-processing-to-empower-search) - -### Gestione dell'inventario - -Aziende innovative e agili come [StitchFix](https://stitchfix.com), un servizio di box che spedisce abbigliamento ai consumatori, si affidano fortemente al ML per le raccomandazioni e la gestione dell'inventario. I loro team di styling lavorano insieme ai loro team di merchandising, infatti: "uno dei nostri data scientist ha sperimentato con un algoritmo genetico e lo ha applicato all'abbigliamento per prevedere quale sarebbe stato un capo di successo che non esiste oggi. Abbiamo portato questo al team di merchandising e ora possono usarlo come strumento." -[Reference](https://www.zdnet.com/article/how-stitch-fix-uses-machine-learning-to-master-the-science-of-styling/) - -## 🏥 Sanità - -Il settore sanitario può sfruttare il ML per ottimizzare le attività di ricerca e anche problemi logistici come la riammissione dei pazienti o la prevenzione della diffusione delle malattie. - -### Gestione delle sperimentazioni cliniche - -La tossicità nelle sperimentazioni cliniche è una preoccupazione importante per i produttori di farmaci. Quanto è tollerabile la tossicità? In questo studio, l'analisi di vari metodi di sperimentazione clinica ha portato allo sviluppo di un nuovo approccio per prevedere le probabilità di esiti delle sperimentazioni cliniche. In particolare, sono stati in grado di utilizzare la foresta casuale per produrre un [classificatore](../../4-Classification/README.md) in grado di distinguere tra gruppi di farmaci. -[Reference](https://www.sciencedirect.com/science/article/pii/S2451945616302914) - -### Gestione della riammissione ospedaliera - -L'assistenza ospedaliera è costosa, specialmente quando i pazienti devono essere riammessi. Questo documento discute di un'azienda che utilizza il ML per prevedere il potenziale di riammissione utilizzando algoritmi di [clustering](../../5-Clustering/README.md). Questi cluster aiutano gli analisti a "scoprire gruppi di riammissioni che possono condividere una causa comune". -[Reference](https://healthmanagement.org/c/healthmanagement/issuearticle/hospital-readmissions-and-machine-learning) - -### Gestione delle malattie - -La recente pandemia ha messo in luce i modi in cui il machine learning può aiutare a fermare la diffusione delle malattie. In questo articolo, riconoscerai l'uso di ARIMA, curve logistiche, regressione lineare e SARIMA. "Questo lavoro è un tentativo di calcolare il tasso di diffusione di questo virus e quindi di prevedere i decessi, le guarigioni e i casi confermati, in modo che possa aiutarci a prepararci meglio e sopravvivere." -[Reference](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7979218/) - -## 🌲 Ecologia e tecnologia verde - -La natura e l'ecologia consistono in molti sistemi sensibili dove l'interazione tra animali e natura è al centro dell'attenzione. È importante essere in grado di misurare accuratamente questi sistemi e agire in modo appropriato se succede qualcosa, come un incendio boschivo o una diminuzione della popolazione animale. - -### Gestione delle foreste - -Hai imparato riguardo al [Reinforcement Learning](../../8-Reinforcement/README.md) nelle lezioni precedenti. Può essere molto utile quando si cerca di prevedere i modelli in natura. In particolare, può essere utilizzato per monitorare problemi ecologici come gli incendi boschivi e la diffusione di specie invasive. In Canada, un gruppo di ricercatori ha utilizzato il Reinforcement Learning per costruire modelli di dinamiche degli incendi boschivi a partire dalle immagini satellitari. Utilizzando un innovativo "processo di diffusione spaziale (SSP)", hanno immaginato un incendio boschivo come "l'agente in qualsiasi cella nel paesaggio." "Il set di azioni che il fuoco può intraprendere da una posizione in qualsiasi momento include la diffusione verso nord, sud, est o ovest o non diffondersi. - -Questo approccio inverte la configurazione usuale del RL poiché le dinamiche del corrispondente Markov Decision Process (MDP) sono una funzione nota per la diffusione immediata degli incendi." Leggi di più sugli algoritmi classici utilizzati da questo gruppo al link di seguito. -[Reference](https://www.frontiersin.org/articles/10.3389/fict.2018.00006/full) - -### Rilevamento del movimento degli animali - -Sebbene il deep learning abbia creato una rivoluzione nel monitoraggio visivo dei movimenti degli animali (puoi costruire il tuo [tracciatore di orsi polari](https://docs.microsoft.com/learn/modules/build-ml-model-with-azure-stream-analytics/?WT.mc_id=academic-77952-leestott) qui), il ML classico ha ancora un ruolo in questo compito. - -I sensori per monitorare i movimenti degli animali da fattoria e l'IoT fanno uso di questo tipo di elaborazione visiva, ma le tecniche di ML più basilari sono utili per preprocessare i dati. Ad esempio, in questo documento, le posture delle pecore sono state monitorate e analizzate utilizzando vari algoritmi di classificazione. Potresti riconoscere la curva ROC a pagina 335. -[Reference](https://druckhaus-hofmann.de/gallery/31-wj-feb-2020.pdf) - -### ⚡️ Gestione dell'energia - -Nelle nostre lezioni sulla [previsione delle serie temporali](../../7-TimeSeries/README.md), abbiamo introdotto il concetto di parchimetri intelligenti per generare entrate per una città basandosi sulla comprensione della domanda e dell'offerta. Questo articolo discute in dettaglio come clustering, regressione e previsione delle serie temporali si combinano per aiutare a prevedere l'uso futuro dell'energia in Irlanda, basandosi sui misuratori intelligenti. -[Reference](https://www-cdn.knime.com/sites/default/files/inline-images/knime_bigdata_energy_timeseries_whitepaper.pdf) - -## 💼 Assicurazioni - -Il settore assicurativo è un altro settore che utilizza il ML per costruire e ottimizzare modelli finanziari e attuariali validi. - -### Gestione della volatilità - -MetLife, un fornitore di assicurazioni sulla vita, è trasparente nel modo in cui analizza e mitiga la volatilità nei suoi modelli finanziari. In questo articolo noterai visualizzazioni di classificazione binaria e ordinale. Scoprirai anche visualizzazioni di previsione. -[Reference](https://investments.metlife.com/content/dam/metlifecom/us/investments/insights/research-topics/macro-strategy/pdf/MetLifeInvestmentManagement_MachineLearnedRanking_070920.pdf) - -## 🎨 Arti, cultura e letteratura - -Nelle arti, ad esempio nel giornalismo, ci sono molti problemi interessanti. Rilevare le fake news è un enorme problema poiché è stato dimostrato che influenzano l'opinione delle persone e persino rovesciano le democrazie. Anche i musei possono beneficiare dell'uso del ML in tutto, dal trovare collegamenti tra artefatti alla pianificazione delle risorse. - -### Rilevamento delle fake news - -Rilevare le fake news è diventato un gioco del gatto e del topo nei media di oggi. In questo articolo, i ricercatori suggeriscono che un sistema che combina diverse tecniche di ML che abbiamo studiato può essere testato e il miglior modello implementato: "Questo sistema si basa sull'elaborazione del linguaggio naturale per estrarre caratteristiche dai dati e poi queste caratteristiche vengono utilizzate per l'addestramento di classificatori di machine learning come Naive Bayes, Support Vector Machine (SVM), Random Forest (RF), Stochastic Gradient Descent (SGD) e Logistic Regression (LR)." -[Reference](https://www.irjet.net/archives/V7/i6/IRJET-V7I6688.pdf) - -Questo articolo mostra come combinare diversi domini di ML può produrre risultati interessanti che possono aiutare a fermare la diffusione delle fake news e creare danni reali; in questo caso, l'impulso è stato la diffusione di voci sui trattamenti COVID che hanno incitato la violenza di massa. - -### ML nei musei - -I musei sono all'avanguardia di una rivoluzione AI in cui catalogare e digitalizzare collezioni e trovare collegamenti tra artefatti sta diventando più facile man mano che la tecnologia avanza. Progetti come [In Codice Ratio](https://www.sciencedirect.com/science/article/abs/pii/S0306457321001035#:~:text=1.,studies%20over%20large%20historical%20sources.) stanno aiutando a svelare i misteri delle collezioni inaccessibili come gli Archivi Vaticani. Ma anche l'aspetto commerciale dei musei beneficia dei modelli di ML. - -Ad esempio, l'Art Institute di Chicago ha costruito modelli per prevedere cosa interessa al pubblico e quando parteciperà alle esposizioni. L'obiettivo è creare esperienze di visita individualizzate e ottimizzate ogni volta che l'utente visita il museo. "Durante l'anno fiscale 2017, il modello ha previsto la partecipazione e le entrate con una precisione dell'1 percento, dice Andrew Simnick, vicepresidente senior all'Art Institute." -[Reference](https://www.chicagobusiness.com/article/20180518/ISSUE01/180519840/art-institute-of-chicago-uses-data-to-make-exhibit-choices) - -## 🏷 Marketing - -### Segmentazione dei clienti - -Le strategie di marketing più efficaci mirano ai clienti in modi diversi basati su vari raggruppamenti. In questo articolo, vengono discussi gli usi degli algoritmi di Clustering per supportare il marketing differenziato. Il marketing differenziato aiuta le aziende a migliorare il riconoscimento del marchio, raggiungere più clienti e guadagnare di più. -[Reference](https://ai.inqline.com/machine-learning-for-marketing-customer-segmentation/) - -## 🚀 Sfida - -Identificare un altro settore che beneficia di alcune delle tecniche che hai appreso in questo curriculum e scoprire come utilizza il ML. - -## [Quiz post-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/50/) - -## Revisione & Autoapprendimento - -Il team di data science di Wayfair ha diversi video interessanti su come utilizzano il ML nella loro azienda. Vale la pena [dare un'occhiata](https://www.youtube.com/channel/UCe2PjkQXqOuwkW1gw6Ameuw/videos)! - -## Compito - -[Una caccia al tesoro di ML](assignment.md) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/9-Real-World/1-Applications/assignment.md b/translations/it/9-Real-World/1-Applications/assignment.md deleted file mode 100644 index 479cbc032..000000000 --- a/translations/it/9-Real-World/1-Applications/assignment.md +++ /dev/null @@ -1,16 +0,0 @@ -# Una Caccia al Tesoro con il ML - -## Istruzioni - -In questa lezione, hai imparato molti casi d'uso reali risolti utilizzando il ML classico. Sebbene l'uso del deep learning, nuove tecniche e strumenti nell'IA, e l'uso delle reti neurali abbiano aiutato ad accelerare la produzione di strumenti per aiutare in questi settori, il ML classico utilizzando le tecniche in questo curriculum ha ancora un grande valore. - -In questo compito, immagina di partecipare a un hackathon. Usa ciò che hai imparato nel curriculum per proporre una soluzione utilizzando il ML classico per risolvere un problema in uno dei settori discussi in questa lezione. Crea una presentazione in cui discuti come implementerai la tua idea. Punti bonus se riesci a raccogliere dati di esempio e costruire un modello ML per supportare il tuo concetto! - -## Rubrica - -| Criteri | Esemplare | Adeguato | Da Migliorare | -| -------- | ------------------------------------------------------------------- | ------------------------------------------------- | ---------------------- | -| | Viene presentata una presentazione PowerPoint - bonus per la costruzione di un modello | Viene presentata una presentazione di base non innovativa | Il lavoro è incompleto | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Anche se ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/9-Real-World/2-Debugging-ML-Models/README.md b/translations/it/9-Real-World/2-Debugging-ML-Models/README.md deleted file mode 100644 index 972495162..000000000 --- a/translations/it/9-Real-World/2-Debugging-ML-Models/README.md +++ /dev/null @@ -1,130 +0,0 @@ -# Postscript: Debugging dei Modelli di Machine Learning utilizzando i componenti della dashboard Responsible AI - -## [Quiz pre-lezione](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/5/) - -## Introduzione - -Il machine learning ha un impatto significativo sulle nostre vite quotidiane. L'AI sta trovando spazio in alcuni dei sistemi più importanti che ci riguardano come individui e come società, dalla sanità, alla finanza, all'istruzione e all'occupazione. Ad esempio, sistemi e modelli sono coinvolti nelle decisioni quotidiane, come diagnosi sanitarie o rilevamento delle frodi. Di conseguenza, i progressi dell'AI e la sua adozione accelerata sono accompagnati da aspettative sociali in evoluzione e da una crescente regolamentazione. Continuamente vediamo aree in cui i sistemi di AI non soddisfano le aspettative; espongono nuove sfide; e i governi stanno iniziando a regolare le soluzioni AI. Pertanto, è importante che questi modelli siano analizzati per garantire risultati equi, affidabili, inclusivi, trasparenti e responsabili per tutti. - -In questo curriculum, esamineremo strumenti pratici che possono essere utilizzati per valutare se un modello presenta problemi di AI responsabile. Le tecniche tradizionali di debugging del machine learning tendono a basarsi su calcoli quantitativi come l'accuratezza aggregata o la perdita media dell'errore. Immagina cosa può succedere quando i dati che stai usando per costruire questi modelli mancano di determinate demografie, come razza, genere, visione politica, religione, o rappresentano in modo sproporzionato tali demografie. Cosa succede quando l'output del modello è interpretato per favorire una certa demografia? Questo può introdurre una sovra o sotto rappresentazione di questi gruppi di caratteristiche sensibili, risultando in problemi di equità, inclusività o affidabilità del modello. Un altro fattore è che i modelli di machine learning sono considerati scatole nere, il che rende difficile comprendere e spiegare cosa guida le predizioni di un modello. Tutte queste sono sfide che i data scientist e gli sviluppatori di AI affrontano quando non dispongono di strumenti adeguati per eseguire il debug e valutare l'equità o l'affidabilità di un modello. - -In questa lezione, imparerai a fare il debug dei tuoi modelli utilizzando: - -- **Analisi degli Errori**: identificare dove nella distribuzione dei dati il modello ha alti tassi di errore. -- **Panoramica del Modello**: eseguire un'analisi comparativa tra diversi gruppi di dati per scoprire disparità nelle metriche di performance del modello. -- **Analisi dei Dati**: investigare dove potrebbe esserci una sovra o sotto rappresentazione dei tuoi dati che può distorcere il modello a favore di una demografia rispetto a un'altra. -- **Importanza delle Caratteristiche**: comprendere quali caratteristiche stanno guidando le predizioni del modello a livello globale o locale. - -## Prerequisito - -Come prerequisito, ti invitiamo a rivedere [Strumenti di AI responsabile per sviluppatori](https://www.microsoft.com/ai/ai-lab-responsible-ai-dashboard) - -> ![Gif su Strumenti di AI Responsabile](../../../../9-Real-World/2-Debugging-ML-Models/images/rai-overview.gif) - -## Analisi degli Errori - -Le metriche di performance tradizionali utilizzate per misurare l'accuratezza dei modelli sono per lo più calcoli basati su predizioni corrette vs incorrette. Ad esempio, determinare che un modello è accurato l'89% delle volte con una perdita di errore di 0.001 può essere considerato una buona performance. Gli errori spesso non sono distribuiti uniformemente nel tuo dataset sottostante. Puoi ottenere un punteggio di accuratezza del modello dell'89% ma scoprire che ci sono diverse regioni dei tuoi dati per cui il modello fallisce il 42% delle volte. La conseguenza di questi schemi di fallimento con certi gruppi di dati può portare a problemi di equità o affidabilità. È essenziale comprendere le aree in cui il modello sta performando bene o meno. Le regioni di dati dove ci sono un alto numero di imprecisioni nel tuo modello potrebbero rivelarsi un'importante demografia di dati. - -![Analizza e fai il debug degli errori del modello](../../../../translated_images/ea-error-distribution.117452e1177c1dd84fab2369967a68bcde787c76c6ea7fdb92fcf15d1fce8206.it.png) - -Il componente di Analisi degli Errori sulla dashboard RAI illustra come il fallimento del modello è distribuito tra vari gruppi con una visualizzazione ad albero. Questo è utile per identificare caratteristiche o aree dove c'è un alto tasso di errore nel tuo dataset. Vedendo da dove provengono la maggior parte delle imprecisioni del modello, puoi iniziare a investigare la causa principale. Puoi anche creare gruppi di dati per eseguire analisi. Questi gruppi di dati aiutano nel processo di debugging per determinare perché la performance del modello è buona in un gruppo, ma errata in un altro. - -![Analisi degli Errori](../../../../translated_images/ea-error-cohort.6886209ea5d438c4daa8bfbf5ce3a7042586364dd3eccda4a4e3d05623ac702a.it.png) - -Gli indicatori visivi sulla mappa ad albero aiutano a localizzare più velocemente le aree problematiche. Ad esempio, più scura è la tonalità di rosso di un nodo dell'albero, più alto è il tasso di errore. - -La mappa di calore è un'altra funzionalità di visualizzazione che gli utenti possono utilizzare per investigare il tasso di errore utilizzando una o due caratteristiche per trovare un contributore agli errori del modello su un intero dataset o gruppi. - -![Mappa di Calore dell'Analisi degli Errori](../../../../translated_images/ea-heatmap.8d27185e28cee3830c85e1b2e9df9d2d5e5c8c940f41678efdb68753f2f7e56c.it.png) - -Usa l'analisi degli errori quando hai bisogno di: - -* Ottenere una comprensione profonda di come i fallimenti del modello sono distribuiti su un dataset e attraverso diverse dimensioni di input e caratteristiche. -* Scomporre le metriche di performance aggregate per scoprire automaticamente gruppi di dati errati per informare i tuoi passi di mitigazione mirati. - -## Panoramica del Modello - -Valutare la performance di un modello di machine learning richiede una comprensione olistica del suo comportamento. Questo può essere ottenuto esaminando più di una metrica come il tasso di errore, l'accuratezza, il richiamo, la precisione o MAE (Mean Absolute Error) per trovare disparità tra le metriche di performance. Una metrica di performance può sembrare ottima, ma le imprecisioni possono emergere in un'altra metrica. Inoltre, confrontare le metriche per disparità su tutto il dataset o gruppi aiuta a far luce su dove il modello sta performando bene o meno. Questo è particolarmente importante nel vedere la performance del modello tra caratteristiche sensibili vs insensibili (ad esempio, razza del paziente, genere o età) per scoprire potenziali ingiustizie che il modello potrebbe avere. Ad esempio, scoprire che il modello è più errato in un gruppo che ha caratteristiche sensibili può rivelare potenziali ingiustizie che il modello potrebbe avere. - -Il componente Panoramica del Modello della dashboard RAI aiuta non solo ad analizzare le metriche di performance della rappresentazione dei dati in un gruppo, ma dà agli utenti la possibilità di confrontare il comportamento del modello tra diversi gruppi. - -![Gruppi di dati - panoramica del modello nella dashboard RAI](../../../../translated_images/model-overview-dataset-cohorts.dfa463fb527a35a0afc01b7b012fc87bf2cad756763f3652bbd810cac5d6cf33.it.png) - -La funzionalità di analisi basata sulle caratteristiche del componente permette agli utenti di restringere i sottogruppi di dati all'interno di una particolare caratteristica per identificare anomalie a un livello granulare. Ad esempio, la dashboard ha un'intelligenza integrata per generare automaticamente gruppi per una caratteristica selezionata dall'utente (ad es., *"time_in_hospital < 3"* o *"time_in_hospital >= 7"*). Questo permette a un utente di isolare una particolare caratteristica da un gruppo di dati più grande per vedere se è un influenzatore chiave degli esiti errati del modello. - -![Gruppi di caratteristiche - panoramica del modello nella dashboard RAI](../../../../translated_images/model-overview-feature-cohorts.c5104d575ffd0c80b7ad8ede7703fab6166bfc6f9125dd395dcc4ace2f522f70.it.png) - -Il componente Panoramica del Modello supporta due classi di metriche di disparità: - -**Disparità nella performance del modello**: Questi set di metriche calcolano la disparità (differenza) nei valori della metrica di performance selezionata tra i sottogruppi di dati. Ecco alcuni esempi: - -* Disparità nel tasso di accuratezza -* Disparità nel tasso di errore -* Disparità nella precisione -* Disparità nel richiamo -* Disparità nell'errore assoluto medio (MAE) - -**Disparità nel tasso di selezione**: Questa metrica contiene la differenza nel tasso di selezione (predizione favorevole) tra i sottogruppi. Un esempio di questo è la disparità nei tassi di approvazione dei prestiti. Il tasso di selezione significa la frazione di punti dati in ogni classe classificata come 1 (nella classificazione binaria) o la distribuzione dei valori di predizione (nella regressione). - -## Analisi dei Dati - -> "Se torturi i dati abbastanza a lungo, confesseranno qualsiasi cosa" - Ronald Coase - -Questa affermazione suona estrema, ma è vero che i dati possono essere manipolati per supportare qualsiasi conclusione. Tale manipolazione può talvolta avvenire in modo non intenzionale. Come esseri umani, tutti abbiamo pregiudizi, ed è spesso difficile sapere consapevolmente quando stai introducendo pregiudizi nei dati. Garantire l'equità nell'AI e nel machine learning rimane una sfida complessa. - -I dati sono un enorme punto cieco per le metriche di performance tradizionali dei modelli. Puoi avere alti punteggi di accuratezza, ma questo non riflette sempre il pregiudizio sottostante che potrebbe essere nel tuo dataset. Ad esempio, se un dataset di dipendenti ha il 27% di donne in posizioni dirigenziali in un'azienda e il 73% di uomini allo stesso livello, un modello di pubblicità per il lavoro addestrato su questi dati potrebbe mirare principalmente a un pubblico maschile per posizioni di alto livello. Avere questo squilibrio nei dati ha distorto la predizione del modello a favore di un genere. Questo rivela un problema di equità dove c'è un pregiudizio di genere nel modello di AI. - -Il componente Analisi dei Dati sulla dashboard RAI aiuta a identificare aree dove c'è una sovra- e sotto-rappresentazione nel dataset. Aiuta gli utenti a diagnosticare la causa principale degli errori e dei problemi di equità introdotti da squilibri nei dati o dalla mancanza di rappresentazione di un particolare gruppo di dati. Questo dà agli utenti la possibilità di visualizzare i dataset in base agli esiti predetti e reali, ai gruppi di errori e alle caratteristiche specifiche. A volte scoprire un gruppo di dati sottorappresentato può anche rivelare che il modello non sta imparando bene, quindi le alte imprecisioni. Avere un modello che ha pregiudizi nei dati non è solo un problema di equità, ma mostra che il modello non è inclusivo o affidabile. - -![Componente Analisi dei Dati sulla Dashboard RAI](../../../../translated_images/dataanalysis-cover.8d6d0683a70a5c1e274e5a94b27a71137e3d0a3b707761d7170eb340dd07f11d.it.png) - -Usa l'analisi dei dati quando hai bisogno di: - -* Esplorare le statistiche del tuo dataset selezionando diversi filtri per suddividere i tuoi dati in diverse dimensioni (anche conosciute come gruppi). -* Comprendere la distribuzione del tuo dataset tra diversi gruppi e caratteristiche. -* Determinare se le tue scoperte relative all'equità, all'analisi degli errori e alla causalità (derivate da altri componenti della dashboard) sono il risultato della distribuzione del tuo dataset. -* Decidere in quali aree raccogliere più dati per mitigare gli errori che derivano da problemi di rappresentazione, rumore nelle etichette, rumore nelle caratteristiche, pregiudizi nelle etichette e fattori simili. - -## Interpretabilità del Modello - -I modelli di machine learning tendono a essere scatole nere. Comprendere quali caratteristiche chiave dei dati guidano la predizione di un modello può essere una sfida. È importante fornire trasparenza sul perché un modello fa una certa predizione. Ad esempio, se un sistema di AI predice che un paziente diabetico è a rischio di essere ricoverato di nuovo in ospedale entro 30 giorni, dovrebbe essere in grado di fornire dati di supporto che hanno portato alla sua predizione. Avere indicatori di dati di supporto porta trasparenza per aiutare i clinici o gli ospedali a prendere decisioni ben informate. Inoltre, essere in grado di spiegare perché un modello ha fatto una predizione per un singolo paziente permette di rispettare le normative sanitarie. Quando usi modelli di machine learning in modi che influenzano la vita delle persone, è cruciale comprendere e spiegare cosa influenza il comportamento di un modello. L'interpretabilità e la spiegabilità del modello aiutano a rispondere a domande in scenari come: - -* Debug del modello: Perché il mio modello ha commesso questo errore? Come posso migliorare il mio modello? -* Collaborazione uomo-AI: Come posso comprendere e fidarmi delle decisioni del modello? -* Conformità normativa: Il mio modello soddisfa i requisiti legali? - -Il componente Importanza delle Caratteristiche della dashboard RAI ti aiuta a fare il debug e ottenere una comprensione completa di come un modello fa le predizioni. È anche uno strumento utile per i professionisti del machine learning e i decisori per spiegare e mostrare evidenze delle caratteristiche che influenzano il comportamento del modello per la conformità normativa. Successivamente, gli utenti possono esplorare spiegazioni sia globali che locali per validare quali caratteristiche guidano la predizione di un modello. Le spiegazioni globali elencano le principali caratteristiche che hanno influenzato la predizione complessiva del modello. Le spiegazioni locali mostrano quali caratteristiche hanno portato alla predizione di un modello per un singolo caso. La possibilità di valutare spiegazioni locali è anche utile nel fare il debug o nell'audit di un caso specifico per comprendere e interpretare meglio perché un modello ha fatto una predizione accurata o inaccurata. - -![Componente Importanza delle Caratteristiche della dashboard RAI](../../../../translated_images/9-feature-importance.cd3193b4bba3fd4bccd415f566c2437fb3298c4824a3dabbcab15270d783606e.it.png) - -* Spiegazioni globali: Ad esempio, quali caratteristiche influenzano il comportamento complessivo di un modello di riammissione ospedaliera per il diabete? -* Spiegazioni locali: Ad esempio, perché un paziente diabetico di età superiore a 60 anni con precedenti ricoveri è stato predetto di essere ricoverato o non ricoverato entro 30 giorni? - -Nel processo di debug dell'esaminare la performance di un modello tra diversi gruppi, l'Importanza delle Caratteristiche mostra quale livello di impatto ha una caratteristica tra i gruppi. Aiuta a rivelare anomalie quando si confronta il livello di influenza che la caratteristica ha nel guidare le predizioni errate di un modello. Il componente Importanza delle Caratteristiche può mostrare quali valori in una caratteristica hanno influenzato positivamente o negativamente l'esito del modello. Ad esempio, se un modello ha fatto una predizione inaccurata, il componente ti dà la possibilità di approfondire e individuare quali caratteristiche o valori di caratteristiche hanno guidato la predizione. Questo livello di dettaglio aiuta non solo nel fare il debug ma fornisce trasparenza e responsabilità in situazioni di audit. Infine, il componente può aiutarti a identificare problemi di equità. Per illustrare, se una caratteristica sensibile come l'etnia o il genere è altamente influente nel guidare la predizione di un modello, questo potrebbe essere un segno di pregiudizio razziale o di genere nel modello. - -![Importanza delle caratteristiche](../../../../translated_images/9-features-influence.3ead3d3f68a84029f1e40d3eba82107445d3d3b6975d4682b23d8acc905da6d0.it.png) - -Usa l'interpretabilità quando hai bisogno di: - -* Determinare quanto siano affidabili le predizioni del tuo sistema AI comprendendo quali caratteristiche sono più importanti per le predizioni. -* Approcciare il debug del tuo modello comprendendolo prima e identificando se il modello sta usando caratteristiche sane o solo false correlazioni. -* Scoprire potenziali fonti di ingiustizia comprendendo se il modello sta basando le predizioni su caratteristiche sensibili o su caratteristiche altamente correlate con esse. -* Costruire fiducia nelle decisioni del tuo modello generando spiegazioni locali per illustrare i loro esiti. -* Completare un audit normativo di un sistema AI per validare i modelli e monitorare l'impatto delle decisioni del modello sugli esseri umani. - -## Conclusione - -Tutti i componenti della dashboard RAI sono strumenti pratici per aiutarti a costruire modelli di machine learning che siano meno dannosi e più affidabili per la società. Migliora la prevenzione delle minacce ai diritti umani; discriminare o escludere certi gruppi dalle opportunità di vita; e il rischio di lesioni fisiche o psicologiche. Aiuta anche a costruire fiducia nelle decisioni del tuo modello generando spiegazioni locali per illustrare i loro esiti. Alcuni dei potenziali danni possono essere classificati come: - -- **Allocazione**, se ad esempio un genere o un'etnia è favorita rispetto a un'altra. -- **Qualità del servizio**. Se addestri i dati per uno scenario specifico ma la realtà è molto più complessa, porta a un servizio di scarsa qualità. -- **Stereotipi**. Associare un dato gruppo a attributi preassegnati. -- **Denigrazione**. Criticare ingiustamente e etichettare qualcosa o qualcuno. -- **Sovra o sotto rappresentazione**. L'idea è che un certo gruppo non è visto in una certa professione, e qualsiasi servizio o funzione che continua a promuovere ciò sta contribuendo al danno. - -### Dashboard Azure RAI - -[Dashboard Azure RAI](https://learn.microsoft.com/en-us/azure/machine-learning/concept-responsible-ai-dashboard?WT.mc_id=aiml-90525-ruyakubu) è costruita su strumenti open-source sviluppati dalle principali istituzioni accademiche e organizzazioni, inclusa Microsoft, ed è fondamentale per i data scientist e gli - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatizzati basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatizzate possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/9-Real-World/2-Debugging-ML-Models/assignment.md b/translations/it/9-Real-World/2-Debugging-ML-Models/assignment.md deleted file mode 100644 index 9f524ce99..000000000 --- a/translations/it/9-Real-World/2-Debugging-ML-Models/assignment.md +++ /dev/null @@ -1,14 +0,0 @@ -# Esplora la dashboard di Responsible AI (RAI) - -## Istruzioni - -In questa lezione hai imparato a conoscere la dashboard RAI, una suite di componenti basata su strumenti "open-source" per aiutare i data scientist a eseguire analisi degli errori, esplorazione dei dati, valutazione dell'equità, interpretabilità del modello, valutazioni controfattuali/cosa-se e analisi causale sui sistemi di intelligenza artificiale. Per questo compito, esplora alcuni dei notebook di esempio della dashboard RAI [notebooks](https://github.com/Azure/RAI-vNext-Preview/tree/main/examples/notebooks) e riporta le tue scoperte in un documento o in una presentazione. - -## Rubrica - -| Criteri | Esemplare | Adeguato | Necessita Miglioramento | -| -------- | --------- | -------- | ----------------- | -| | Viene presentato un documento o una presentazione PowerPoint che discute i componenti della dashboard RAI, il notebook eseguito e le conclusioni tratte dall'esecuzione dello stesso | Viene presentato un documento senza conclusioni | Nessun documento viene presentato | - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione basati su intelligenza artificiale. Sebbene ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua madre dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/9-Real-World/README.md b/translations/it/9-Real-World/README.md deleted file mode 100644 index 83f22408b..000000000 --- a/translations/it/9-Real-World/README.md +++ /dev/null @@ -1,21 +0,0 @@ -# Postscript: Applicazioni reali del machine learning classico - -In questa sezione del curriculum, ti verranno presentate alcune applicazioni reali del ML classico. Abbiamo esplorato il web per trovare whitepaper e articoli sulle applicazioni che hanno utilizzato queste strategie, evitando il più possibile reti neurali, deep learning e AI. Scopri come il ML viene utilizzato nei sistemi aziendali, nelle applicazioni ecologiche, nella finanza, nelle arti e nella cultura, e molto altro. - -![chess](../../../translated_images/chess.e704a268781bdad85d1876b6c2295742fa0d856e7dcf3659147052df9d3db205.it.jpg) - -> Foto di Alexis Fauvet su Unsplash - -## Lezione - -1. [Applicazioni Reali del ML](1-Applications/README.md) -2. [Debugging dei Modelli di Machine Learning utilizzando componenti del dashboard di Responsible AI](2-Debugging-ML-Models/README.md) - -## Crediti - -"Applicazioni Reali" è stato scritto da un team di persone, tra cui [Jen Looper](https://twitter.com/jenlooper) e [Ornella Altunyan](https://twitter.com/ornelladotcom). - -"Debugging dei Modelli di Machine Learning utilizzando componenti del dashboard di Responsible AI" è stato scritto da [Ruth Yakubu](https://twitter.com/ruthieyakubu) - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/CODE_OF_CONDUCT.md b/translations/it/CODE_OF_CONDUCT.md deleted file mode 100644 index ce2690e68..000000000 --- a/translations/it/CODE_OF_CONDUCT.md +++ /dev/null @@ -1,12 +0,0 @@ -# Codice di Condotta Open Source di Microsoft - -Questo progetto ha adottato il [Codice di Condotta Open Source di Microsoft](https://opensource.microsoft.com/codeofconduct/). - -Risorse: - -- [Codice di Condotta Open Source di Microsoft](https://opensource.microsoft.com/codeofconduct/) -- [FAQ sul Codice di Condotta di Microsoft](https://opensource.microsoft.com/codeofconduct/faq/) -- Contatta [opencode@microsoft.com](mailto:opencode@microsoft.com) per domande o preoccupazioni - -**Disclaimer**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene ci impegniamo per garantire l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale umana. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/CONTRIBUTING.md b/translations/it/CONTRIBUTING.md deleted file mode 100644 index 1fb33e17f..000000000 --- a/translations/it/CONTRIBUTING.md +++ /dev/null @@ -1,14 +0,0 @@ -# Contribuire - -Questo progetto accoglie con favore contributi e suggerimenti. La maggior parte dei contributi richiede che tu accetti un Contributor License Agreement (CLA) dichiarando che hai il diritto di, e realmente concedi a noi i diritti di utilizzare il tuo contributo. Per i dettagli, visita https://cla.microsoft.com. - -> Importante: quando traduci il testo in questo repo, assicurati di non utilizzare la traduzione automatica. Verificheremo le traduzioni tramite la comunità, quindi offriti volontario solo per traduzioni in lingue in cui sei competente. - -Quando invii una pull request, un CLA-bot determinerà automaticamente se devi fornire un CLA e decorare il PR in modo appropriato (ad esempio, etichetta, commento). Segui semplicemente le istruzioni fornite dal bot. Dovrai farlo solo una volta per tutti i repository che utilizzano il nostro CLA. - -Questo progetto ha adottato il [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). -Per maggiori informazioni, consulta le [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) -o contatta [opencode@microsoft.com](mailto:opencode@microsoft.com) per qualsiasi domanda o commento aggiuntivo. - -**Avvertenza**: -Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci impegniamo per l'accuratezza, si prega di essere consapevoli che le traduzioni automatiche possono contenere errori o inesattezze. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda la traduzione umana professionale. Non siamo responsabili per eventuali fraintendimenti o interpretazioni errate derivanti dall'uso di questa traduzione. \ No newline at end of file diff --git a/translations/it/README.md b/translations/it/README.md deleted file mode 100644 index 57c19523b..000000000 --- a/translations/it/README.md +++ /dev/null @@ -1,155 +0,0 @@ -[![GitHub license](https://img.shields.io/github/license/microsoft/ML-For-Beginners.svg)](https://github.com/microsoft/ML-For-Beginners/blob/master/LICENSE) -[![GitHub contributors](https://img.shields.io/github/contributors/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/graphs/contributors/) -[![GitHub issues](https://img.shields.io/github/issues/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/issues/) -[![GitHub pull-requests](https://img.shields.io/github/issues-pr/microsoft/ML-For-Beginners.svg)](https://GitHub.com/microsoft/ML-For-Beginners/pulls/) -[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com) - -[![GitHub watchers](https://img.shields.io/github/watchers/microsoft/ML-For-Beginners.svg?style=social&label=Watch)](https://GitHub.com/microsoft/ML-For-Beginners/watchers/) -[![GitHub forks](https://img.shields.io/github/forks/microsoft/ML-For-Beginners.svg?style=social&label=Fork)](https://GitHub.com/microsoft/ML-For-Beginners/network/) -[![GitHub stars](https://img.shields.io/github/stars/microsoft/ML-For-Beginners.svg?style=social&label=Star)](https://GitHub.com/microsoft/ML-For-Beginners/stargazers/) - -[![](https://dcbadge.vercel.app/api/server/ByRwuEEgH4)](https://discord.gg/zxKYvhSnVp?WT.mc_id=academic-000002-leestott) - -# Machine Learning for Beginners - Un Curriculum - -> 🌍 Viaggia per il mondo mentre esploriamo il Machine Learning attraverso le culture del mondo 🌍 - -Gli Advocates di Microsoft sono lieti di offrire un curriculum di 12 settimane e 26 lezioni tutto dedicato al **Machine Learning**. In questo curriculum, imparerai ciò che a volte viene chiamato **machine learning classico**, utilizzando principalmente la libreria Scikit-learn ed evitando il deep learning, che è trattato nel nostro [curriculum AI for Beginners](https://aka.ms/ai4beginners). Abbina queste lezioni al nostro curriculum ['Data Science for Beginners'](https://aka.ms/ds4beginners)! - -Viaggia con noi per il mondo mentre applichiamo queste tecniche classiche ai dati di molte aree del mondo. Ogni lezione include quiz pre e post lezione, istruzioni scritte per completare la lezione, una soluzione, un compito e altro ancora. La nostra pedagogia basata su progetti ti permette di imparare costruendo, un metodo provato per far sì che le nuove competenze restino impresse. - -**✍️ Un grande grazie ai nostri autori** Jen Looper, Stephen Howell, Francesca Lazzeri, Tomomi Imura, Cassie Breviu, Dmitry Soshnikov, Chris Noring, Anirban Mukherjee, Ornella Altunyan, Ruth Yakubu e Amy Boyd - -**🎨 Grazie anche ai nostri illustratori** Tomomi Imura, Dasani Madipalli e Jen Looper - -**🙏 Un ringraziamento speciale 🙏 ai nostri autori, revisori e contributori di contenuti Microsoft Student Ambassador**, in particolare Rishit Dagli, Muhammad Sakib Khan Inan, Rohan Raj, Alexandru Petrescu, Abhishek Jaiswal, Nawrin Tabassum, Ioan Samuila e Snigdha Agarwal - -**🤩 Un ringraziamento extra agli Microsoft Student Ambassadors Eric Wanjau, Jasleen Sondhi e Vidushi Gupta per le nostre lezioni in R!** - -# Iniziare - -Segui questi passaggi: -1. **Fork del Repository**: Clicca sul pulsante "Fork" nell'angolo in alto a destra di questa pagina. -2. **Clona il Repository**: `git clone https://github.com/microsoft/ML-For-Beginners.git` - -> [trova tutte le risorse aggiuntive per questo corso nella nostra raccolta Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum) - -**[Studenti](https://aka.ms/student-page)**, per utilizzare questo curriculum, fai il fork dell'intero repository nel tuo account GitHub e completa gli esercizi da solo o con un gruppo: - -- Inizia con un quiz pre-lezione. -- Leggi la lezione e completa le attività, fermandoti e riflettendo a ogni verifica delle conoscenze. -- Cerca di creare i progetti comprendendo le lezioni piuttosto che eseguendo il codice della soluzione; tuttavia, quel codice è disponibile nelle cartelle `/solution` in ogni lezione orientata al progetto. -- Fai il quiz post-lezione. -- Completa la sfida. -- Completa il compito. -- Dopo aver completato un gruppo di lezioni, visita il [Forum di Discussione](https://github.com/microsoft/ML-For-Beginners/discussions) e "impara ad alta voce" compilando il rubrica PAT appropriata. Un 'PAT' è uno Strumento di Valutazione del Progresso che è una rubrica che compili per approfondire il tuo apprendimento. Puoi anche reagire ad altri PAT così possiamo imparare insieme. - -> Per ulteriori studi, consigliamo di seguire questi moduli e percorsi di apprendimento [Microsoft Learn](https://docs.microsoft.com/en-us/users/jenlooper-2911/collections/k7o7tg1gp306q4?WT.mc_id=academic-77952-leestott). - -**Insegnanti**, abbiamo [incluso alcuni suggerimenti](for-teachers.md) su come utilizzare questo curriculum. - ---- - -## Video walkthroughs - -Alcune delle lezioni sono disponibili come video brevi. Puoi trovare tutti questi in linea nelle lezioni, o nella [playlist ML for Beginners sul canale YouTube Microsoft Developer](https://aka.ms/ml-beginners-videos) cliccando sull'immagine qui sotto. - -[![ML for beginners banner](../../translated_images/ml-for-beginners-video-banner.279f2a268d2130758668f4044f8c252d42f7c0a141c2cb56294c1ccc157cdd1c.it.png)](https://aka.ms/ml-beginners-videos) - ---- - -## Incontra il Team - -[![Promo video](../../ml.gif)](https://youtu.be/Tj1XWrDSYJU "Promo video") - -**Gif di** [Mohit Jaisal](https://linkedin.com/in/mohitjaisal) - -> 🎥 Clicca sull'immagine qui sopra per un video sul progetto e sulle persone che l'hanno creato! - ---- - -## Pedagogia - -Abbiamo scelto due principi pedagogici mentre costruivamo questo curriculum: assicurarsi che sia **basato su progetti** e che includa **quiz frequenti**. Inoltre, questo curriculum ha un **tema comune** per dargli coesione. - -Assicurando che il contenuto sia allineato con i progetti, il processo diventa più coinvolgente per gli studenti e la ritenzione dei concetti sarà aumentata. Inoltre, un quiz a basso rischio prima di una lezione imposta l'intenzione dello studente verso l'apprendimento di un argomento, mentre un secondo quiz dopo la lezione assicura una maggiore ritenzione. Questo curriculum è stato progettato per essere flessibile e divertente e può essere seguito in tutto o in parte. I progetti iniziano piccoli e diventano sempre più complessi alla fine del ciclo di 12 settimane. Questo curriculum include anche un postscript sulle applicazioni reali del ML, che può essere utilizzato come credito extra o come base per una discussione. - -> Trova il nostro [Codice di Condotta](CODE_OF_CONDUCT.md), [Contributi](CONTRIBUTING.md) e linee guida per [Traduzioni](TRANSLATIONS.md). Accogliamo con favore il tuo feedback costruttivo! - -## Ogni lezione include - -- sketchnote opzionale -- video supplementare opzionale -- video walkthrough (solo alcune lezioni) -- quiz di riscaldamento pre-lezione -- lezione scritta -- per lezioni basate su progetti, guide passo-passo su come costruire il progetto -- verifiche delle conoscenze -- una sfida -- letture supplementari -- compito -- quiz post-lezione - -> **Una nota sulle lingue**: Queste lezioni sono principalmente scritte in Python, ma molte sono disponibili anche in R. Per completare una lezione in R, vai alla cartella `/solution` e cerca le lezioni in R. Includono un'estensione .rmd che rappresenta un **R Markdown** file che può essere semplicemente definito come un'integrazione di `code chunks` (di R o altre lingue) e un `YAML header` (che guida come formattare gli output come PDF) in un `Markdown document`. In quanto tale, serve come un eccellente framework di creazione per la data science poiché ti permette di combinare il tuo codice, il suo output e i tuoi pensieri permettendoti di scriverli in Markdown. Inoltre, i documenti R Markdown possono essere resi in formati di output come PDF, HTML o Word. - -> **Una nota sui quiz**: Tutti i quiz sono contenuti nella [cartella Quiz App](../../quiz-app), per un totale di 52 quiz di tre domande ciascuno. Sono collegati all'interno delle lezioni ma l'app quiz può essere eseguita localmente; segui le istruzioni nella cartella `quiz-app` per ospitare localmente o distribuire su Azure. - -| Numero Lezione | Argomento | Raggruppamento Lezione | Obiettivi di Apprendimento | Lezione Collegata | Autore | -| :-----------: | :------------------------------------------------------------: | :-------------------------------------------------: | ------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------: | :--------------------------------------------------: | -| 01 | Introduzione al machine learning | [Introduzione](1-Introduction/README.md) | Impara i concetti base dietro il machine learning | [Lezione](1-Introduction/1-intro-to-ML/README.md) | Muhammad | -| 02 | La Storia del machine learning | [Introduzione](1-Introduction/README.md) | Impara la storia alla base di questo campo | [Lezione](1-Introduction/2-history-of-ML/README.md) | Jen e Amy | -| 03 | Equità e machine learning | [Introduzione](1-Introduction/README.md) | Quali sono le questioni filosofiche importanti sull'equità che gli studenti dovrebbero considerare quando costruiscono e applicano modelli ML? | [Lezione](1-Introduction/3-fairness/README.md) | Tomomi | -| 04 | Tecniche per il machine learning | [Introduction](1-Introduction/README.md) | Quali tecniche utilizzano i ricercatori di ML per costruire modelli di ML? | [Lesson](1-Introduction/4-techniques-of-ML/README.md) | Chris e Jen | -| 05 | Introduzione alla regressione | [Regression](2-Regression/README.md) | Inizia con Python e Scikit-learn per i modelli di regressione | | | -| 06 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Visualizza e pulisci i dati in preparazione per il ML | | | -| 07 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Costruisci modelli di regressione lineare e polinomiale | | | -| 08 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Costruisci un modello di regressione logistica | | | -| 09 | Una Web App 🔌 | [Web App](3-Web-App/README.md) | Costruisci una web app per utilizzare il tuo modello addestrato | [Python](3-Web-App/1-Web-App/README.md) | Jen | -| 10 | Introduzione alla classificazione | [Classification](4-Classification/README.md) | Pulisci, prepara e visualizza i tuoi dati; introduzione alla classificazione |