msb-public
/
ML-For-Beginners
mirror of https://github.com/microsoft/ML-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity

Update

Browse Source
pull/844/head
Lee Stott 3 months ago committed by GitHub
parent de8bb336a6
commit fdf8e37752
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
365 changed files with 0 additions and 29883 deletions
Show Stats Download Patch File Download Diff File

190
translations/it/6-NLP/3-Translation-Sentiment/README.md
Unescape View File

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

14
translations/it/6-NLP/3-Translation-Sentiment/assignment.md
Unescape View File

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

4
translations/it/6-NLP/3-Translation-Sentiment/solution/Julia/README.md
Unescape View File

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

4
translations/it/6-NLP/3-Translation-Sentiment/solution/R/README.md
Unescape View File

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

294
translations/it/6-NLP/4-Hotel-Reviews-1/README.md
Unescape View File

@ -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 <br />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.

8
translations/it/6-NLP/4-Hotel-Reviews-1/assignment.md
Unescape View File

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

4
translations/it/6-NLP/4-Hotel-Reviews-1/solution/Julia/README.md
Unescape View File

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

4
translations/it/6-NLP/4-Hotel-Reviews-1/solution/R/README.md
Unescape View File

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

377
translations/it/6-NLP/5-Hotel-Reviews-2/README.md
Unescape View File

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

14
translations/it/6-NLP/5-Hotel-Reviews-2/assignment.md
Unescape View File

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

4
translations/it/6-NLP/5-Hotel-Reviews-2/solution/Julia/README.md
Unescape View File

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

4
translations/it/6-NLP/5-Hotel-Reviews-2/solution/R/README.md
Unescape View File

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

27
translations/it/6-NLP/README.md
Unescape View File

@ -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 <a href="https://unsplash.com/@elaineh?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Elaine Howlin</a> su <a href="https://unsplash.com/s/photos/pride-and-prejudice?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## 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.

4
translations/it/6-NLP/data/README.md
Unescape View File

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

188
translations/it/7-TimeSeries/1-Introduction/README.md
Unescape View File

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

14
translations/it/7-TimeSeries/1-Introduction/assignment.md
Unescape View File

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

4
translations/it/7-TimeSeries/1-Introduction/solution/Julia/README.md
Unescape View File

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

4
translations/it/7-TimeSeries/1-Introduction/solution/R/README.md
Unescape View File

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

396
translations/it/7-TimeSeries/2-ARIMA/README.md
Unescape View File

@ -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 actual<sub>t</sub> e predicted<sub>t</sub> viene divisa per actual<sub>t</sub>. "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.

14
translations/it/7-TimeSeries/2-ARIMA/assignment.md
Unescape View File

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

4
translations/it/7-TimeSeries/2-ARIMA/solution/Julia/README.md
Unescape View File

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

4
translations/it/7-TimeSeries/2-ARIMA/solution/R/README.md
Unescape View File

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

389
translations/it/7-TimeSeries/3-SVR/README.md
Unescape View File

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

16
translations/it/7-TimeSeries/3-SVR/assignment.md
Unescape View File

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

26
translations/it/7-TimeSeries/README.md
Unescape View File

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

319
translations/it/8-Reinforcement/1-QLearning/README.md
Unescape View File

@ -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`<sub>a'</sub>*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*:
<img src="images/bellman-equation.png"/>
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+γ max<sub>a'</sub>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.

30
translations/it/8-Reinforcement/1-QLearning/assignment.md
Unescape View File

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

4
translations/it/8-Reinforcement/1-QLearning/solution/Julia/README.md
Unescape View File

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

4
translations/it/8-Reinforcement/1-QLearning/solution/R/README.md
Unescape View File

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

342
translations/it/8-Reinforcement/2-Gym/README.md
Unescape View File

@ -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()<epsilon:
# exploitation - chose the action according to Q-Table probabilities
v = probs(np.array(qvalues(s)))
a = random.choices(actions,weights=v)[0]
else:
# exploration - randomly chose the action
a = np.random.randint(env.action_space.n)
obs, rew, done, info = env.step(a)
cum_reward+=rew
ns = discretize(obs)
Q[(s,a)] = (1 - alpha) * Q.get((s,a),0) + alpha * (rew + gamma * max(qvalues(ns)))
cum_rewards.append(cum_reward)
rewards.append(cum_reward)
# == Periodically print results and calculate average reward ==
if epoch%5000==0:
print(f"{epoch}: {np.average(cum_rewards)}, alpha={alpha}, epsilon={epsilon}")
if np.average(cum_rewards) > 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.

43
translations/it/8-Reinforcement/2-Gym/assignment.md
Unescape View File

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

4
translations/it/8-Reinforcement/2-Gym/solution/Julia/README.md
Unescape View File

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

4
translations/it/8-Reinforcement/2-Gym/solution/R/README.md
Unescape View File

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

56
translations/it/8-Reinforcement/README.md
Unescape View File

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

149
translations/it/9-Real-World/1-Applications/README.md
Unescape View File

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

16
translations/it/9-Real-World/1-Applications/assignment.md
Unescape View File

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

130
translations/it/9-Real-World/2-Debugging-ML-Models/README.md
Unescape View File

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

14
translations/it/9-Real-World/2-Debugging-ML-Models/assignment.md
Unescape View File

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

21
translations/it/9-Real-World/README.md
Unescape View File

@ -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 <a href="https://unsplash.com/@childeye?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Alexis Fauvet</a> su <a href="https://unsplash.com/s/photos/artificial-intelligence?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## 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.

12
translations/it/CODE_OF_CONDUCT.md
Unescape View File

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

14
translations/it/CONTRIBUTING.md
Unescape View File

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

155
translations/it/README.md
Unescape View File

@ -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 | <ul><li>[Python](2-Regression/1-Tools/README.md)</li><li>[R](../../2-Regression/1-Tools/solution/R/lesson_1.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
| 06 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Visualizza e pulisci i dati in preparazione per il ML | <ul><li>[Python](2-Regression/2-Data/README.md)</li><li>[R](../../2-Regression/2-Data/solution/R/lesson_2.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
| 07 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Costruisci modelli di regressione lineare e polinomiale | <ul><li>[Python](2-Regression/3-Linear/README.md)</li><li>[R](../../2-Regression/3-Linear/solution/R/lesson_3.html)</li></ul> | <ul><li>Jen e Dmitry</li><li>Eric Wanjau</li></ul> |
| 08 | Prezzi delle zucche in Nord America 🎃 | [Regression](2-Regression/README.md) | Costruisci un modello di regressione logistica | <ul><li>[Python](2-Regression/4-Logistic/README.md) </li><li>[R](../../2-Regression/4-Logistic/solution/R/lesson_4.html)</li></ul> | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
| 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 | <ul><li> [Python](4-Classification/1-Introduction/README.md) </li><li>[R](../../4-Classification/1-Introduction/solution/R/lesson_10.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
| 11 | Deliziose cucine asiatiche e indiane 🍜 | [Classification](4-Classification/README.md) | Introduzione ai classificatori | <ul><li> [Python](4-Classification/2-Classifiers-1/README.md)</li><li>[R](../../4-Classification/2-Classifiers-1/solution/R/lesson_11.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
| 12 | Deliziose cucine asiatiche e indiane 🍜 | [Classification](4-Classification/README.md) | Altri classificatori | <ul><li> [Python](4-Classification/3-Classifiers-2/README.md)</li><li>[R](../../4-Classification/3-Classifiers-2/solution/R/lesson_12.html) | <ul><li>Jen e Cassie</li><li>Eric Wanjau</li></ul> |
| 13 | Deliziose cucine asiatiche e indiane 🍜 | [Classification](4-Classification/README.md) | Costruisci una web app di raccomandazioni usando il tuo modello | [Python](4-Classification/4-Applied/README.md) | Jen |
| 14 | Introduzione al clustering | [Clustering](5-Clustering/README.md) | Pulisci, prepara e visualizza i tuoi dati; introduzione al clustering | <ul><li> [Python](5-Clustering/1-Visualize/README.md)</li><li>[R](../../5-Clustering/1-Visualize/solution/R/lesson_14.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
| 15 | Esplorando i gusti musicali nigeriani 🎧 | [Clustering](5-Clustering/README.md) | Esplora il metodo di clustering K-Means | <ul><li> [Python](5-Clustering/2-K-Means/README.md)</li><li>[R](../../5-Clustering/2-K-Means/solution/R/lesson_15.html) | <ul><li>Jen</li><li>Eric Wanjau</li></ul> |
| 16 | Introduzione all'elaborazione del linguaggio naturale ☕️ | [Natural language processing](6-NLP/README.md) | Impara le basi dell'NLP costruendo un semplice bot | [Python](6-NLP/1-Introduction-to-NLP/README.md) | Stephen |
| 17 | Compiti comuni di NLP ☕️ | [Natural language processing](6-NLP/README.md) | Approfondisci le tue conoscenze di NLP comprendendo i compiti comuni richiesti quando si lavora con le strutture linguistiche | [Python](6-NLP/2-Tasks/README.md) | Stephen |
| 18 | Traduzione e analisi del sentimento ♥️ | [Natural language processing](6-NLP/README.md) | Traduzione e analisi del sentimento con Jane Austen | [Python](6-NLP/3-Translation-Sentiment/README.md) | Stephen |
| 19 | Hotel romantici d'Europa ♥️ | [Natural language processing](6-NLP/README.md) | Analisi del sentimento con le recensioni degli hotel 1 | [Python](6-NLP/4-Hotel-Reviews-1/README.md) | Stephen |
| 20 | Hotel romantici d'Europa ♥️ | [Natural language processing](6-NLP/README.md) | Analisi del sentimento con le recensioni degli hotel 2 | [Python](6-NLP/5-Hotel-Reviews-2/README.md) | Stephen |
| 21 | Introduzione alla previsione delle serie temporali | [Time series](7-TimeSeries/README.md) | Introduzione alla previsione delle serie temporali | [Python](7-TimeSeries/1-Introduction/README.md) | Francesca |
| 22 | ⚡️ Utilizzo dell'energia mondiale ⚡️ - previsione delle serie temporali con ARIMA | [Time series](7-TimeSeries/README.md) | Previsione delle serie temporali con ARIMA | [Python](7-TimeSeries/2-ARIMA/README.md) | Francesca |
| 23 | ⚡️ Utilizzo dell'energia mondiale ⚡️ - previsione delle serie temporali con SVR | [Time series](7-TimeSeries/README.md) | Previsione delle serie temporali con Support Vector Regressor | [Python](7-TimeSeries/3-SVR/README.md) | Anirban |
| 24 | Introduzione al reinforcement learning | [Reinforcement learning](8-Reinforcement/README.md) | Introduzione al reinforcement learning con Q-Learning | [Python](8-Reinforcement/1-QLearning/README.md) | Dmitry |
| 25 | Aiuta Peter a evitare il lupo! 🐺 | [Reinforcement learning](8-Reinforcement/README.md) | Reinforcement learning Gym | [Python](8-Reinforcement/2-Gym/README.md) | Dmitry |
| Postscript | Scenari e applicazioni ML nel mondo reale | [ML in the Wild](9-Real-World/README.md) | Applicazioni interessanti e rivelatrici del ML classico | [Lesson](9-Real-World/1-Applications/README.md) | Team |
| Postscript | Debugging dei modelli in ML usando il dashboard RAI | [ML in the Wild](9-Real-World/README.md) | Debugging dei modelli di Machine Learning utilizzando i componenti del dashboard di Responsible AI | [Lesson](9-Real-World/2-Debugging-ML-Models/README.md) | Ruth Yakubu |
> [trova tutte le risorse aggiuntive per questo corso nella nostra collezione Microsoft Learn](https://learn.microsoft.com/en-us/collections/qrqzamz1nn2wx3?WT.mc_id=academic-77952-bethanycheum)
## Accesso offline
Puoi eseguire questa documentazione offline utilizzando [Docsify](https://docsify.js.org/#/). Fai un fork di questo repo, [installa Docsify](https://docsify.js.org/#/quickstart) sulla tua macchina locale, e poi nella cartella principale di questo repo, digita `docsify serve`. Il sito web sarà servito sulla porta 3000 del tuo localhost: `localhost:3000`.
## PDF
Trova un pdf del curriculum con i link [qui](https://microsoft.github.io/ML-For-Beginners/pdf/readme.pdf).
## Aiuto Cercasi
Ti piacerebbe contribuire con una traduzione? Per favore leggi le nostre [linee guida per la traduzione](TRANSLATIONS.md) e aggiungi un problema preimpostato per gestire il carico di lavoro [qui](https://github.com/microsoft/ML-For-Beginners/issues).
## Altri Curriculum
Il nostro team produce altri curriculum! Dai un'occhiata a:
- [AI for Beginners](https://aka.ms/ai4beginners)
- [Data Science for Beginners](https://aka.ms/datascience-beginners)
- [**Nuova Versione 2.0** - Generative AI for Beginners](https://aka.ms/genai-beginners)
- [**NUOVO** Cybersecurity for Beginners](https://github.com/microsoft/Security-101??WT.mc_id=academic-96948-sayoung)
- [Web Dev for Beginners](https://aka.ms/webdev-beginners)
- [IoT for Beginners](https://aka.ms/iot-beginners)
- [Machine Learning for Beginners](https://aka.ms/ml4beginners)
- [XR Development for Beginners](https://aka.ms/xr-dev-for-beginners)
- [Mastering GitHub Copilot for AI Paired Programming](https://aka.ms/GitHubCopilotAI)
**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 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.

40
translations/it/SECURITY.md
Unescape View File

@ -1,40 +0,0 @@
## Sicurezza
Microsoft prende molto seriamente la sicurezza dei nostri prodotti software e servizi, il che include tutti i repository di codice sorgente gestiti attraverso le nostre organizzazioni GitHub, che includono [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), e [le nostre organizzazioni GitHub](https://opensource.microsoft.com/).
Se credi di aver trovato una vulnerabilità di sicurezza in qualsiasi repository di proprietà di Microsoft che soddisfi [la definizione di vulnerabilità di sicurezza di Microsoft](https://docs.microsoft.com/previous-versions/tn-archive/cc751383(v=technet.10)?WT.mc_id=academic-77952-leestott), ti preghiamo di segnalarcelo come descritto di seguito.
## Segnalazione di Problemi di Sicurezza
**Ti preghiamo di non segnalare vulnerabilità di sicurezza tramite le issue pubbliche di GitHub.**
Invece, segnalale al Microsoft Security Response Center (MSRC) su [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
Se preferisci inviare la segnalazione senza effettuare il login, invia una email a [secure@microsoft.com](mailto:secure@microsoft.com). Se possibile, cripta il tuo messaggio con la nostra chiave PGP; scaricala dalla [pagina della chiave PGP del Microsoft Security Response Center](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
Dovresti ricevere una risposta entro 24 ore. Se per qualche motivo non dovessi riceverla, ti preghiamo di inviare una email di follow-up per assicurarci di aver ricevuto il tuo messaggio originale. Ulteriori informazioni possono essere trovate su [microsoft.com/msrc](https://www.microsoft.com/msrc).
Per favore includi le informazioni richieste elencate di seguito (per quanto possibile) per aiutarci a comprendere meglio la natura e la portata del possibile problema:
* Tipo di problema (ad esempio, buffer overflow, SQL injection, cross-site scripting, ecc.)
* Percorsi completi dei file sorgente relativi alla manifestazione del problema
* La posizione del codice sorgente interessato (tag/branch/commit o URL diretto)
* Qualsiasi configurazione speciale necessaria per riprodurre il problema
* Istruzioni passo-passo per riprodurre il problema
* Codice proof-of-concept o exploit (se possibile)
* Impatto del problema, incluso come un attaccante potrebbe sfruttare il problema
Queste informazioni ci aiuteranno a dare priorità alla tua segnalazione più rapidamente.
Se stai segnalando per una ricompensa bug bounty, rapporti più completi possono contribuire a un premio più alto. Visita la nostra pagina del [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) per ulteriori dettagli sui nostri programmi attivi.
## Lingue Preferite
Preferiamo che tutte le comunicazioni siano in inglese.
## Politica
Microsoft segue il principio della [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
**Avvertenza**:
Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su intelligenza artificiale. Sebbene 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 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.

13
translations/it/SUPPORT.md
Unescape View File

@ -1,13 +0,0 @@
# Supporto
## Come segnalare problemi e ottenere assistenza
Questo progetto utilizza GitHub Issues per tracciare bug e richieste di funzionalità. Si prega di cercare tra i problemi esistenti prima di segnalare nuovi problemi per evitare duplicati. Per nuovi problemi, segnalare il bug o la richiesta di funzionalità come una nuova Issue.
Per assistenza e domande sull'utilizzo di questo progetto, segnalare un problema.
## Politica di supporto di Microsoft
Il supporto per questo repository è limitato alle risorse elencate sopra.
**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 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.

37
translations/it/TRANSLATIONS.md
Unescape View File

@ -1,37 +0,0 @@
# Contribuire traducendo le lezioni
Siamo lieti di accogliere traduzioni per le lezioni di questo curriculum!
## Linee guida
Ci sono cartelle in ogni cartella di lezione e cartella di introduzione alla lezione che contengono i file markdown tradotti.
> Nota, per favore non tradurre alcun codice nei file di esempio di codice; le uniche cose da tradurre sono README, compiti e quiz. Grazie!
I file tradotti dovrebbero seguire questa convenzione di denominazione:
**README._[language]_.md**
dove _[language]_ è un'abbreviazione di due lettere della lingua secondo lo standard ISO 639-1 (ad esempio `README.es.md` per lo spagnolo e `README.nl.md` per l'olandese).
**assignment._[language]_.md**
Simile ai Readme, per favore traduci anche i compiti.
> Importante: quando traduci il testo in questo repository, assicurati di non utilizzare la traduzione automatica. Verificheremo le traduzioni tramite la comunità, quindi per favore offriti volontario per le traduzioni solo nelle lingue in cui sei competente.
**Quiz**
1. Aggiungi la tua traduzione all'app quiz aggiungendo un file qui: https://github.com/microsoft/ML-For-Beginners/tree/main/quiz-app/src/assets/translations, con la corretta convenzione di denominazione (en.json, fr.json). **Per favore non localizzare le parole 'true' o 'false' comunque. grazie!**
2. Aggiungi il codice della tua lingua al menu a tendina nel file App.vue dell'app quiz.
3. Modifica il [file index.js delle traduzioni](https://github.com/microsoft/ML-For-Beginners/blob/main/quiz-app/src/assets/translations/index.js) dell'app quiz per aggiungere la tua lingua.
4. Infine, modifica TUTTI i link dei quiz nei tuoi file README.md tradotti per puntare direttamente al tuo quiz tradotto: https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1 diventa https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1?loc=id
**GRAZIE**
Apprezziamo davvero i tuoi sforzi!
**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 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.

46
translations/it/docs/_sidebar.md
Unescape View File

@ -1,46 +0,0 @@
- Introduzione
- [Introduzione al Machine Learning](../1-Introduction/1-intro-to-ML/README.md)
- [Storia del Machine Learning](../1-Introduction/2-history-of-ML/README.md)
- [ML e Giustizia](../1-Introduction/3-fairness/README.md)
- [Tecniche di ML](../1-Introduction/4-techniques-of-ML/README.md)
- Regressione
- [Strumenti del mestiere](../2-Regression/1-Tools/README.md)
- [Dati](../2-Regression/2-Data/README.md)
- [Regressione Lineare](../2-Regression/3-Linear/README.md)
- [Regressione Logistica](../2-Regression/4-Logistic/README.md)
- Creare un'App Web
- [App Web](../3-Web-App/1-Web-App/README.md)
- Classificazione
- [Introduzione alla Classificazione](../4-Classification/1-Introduction/README.md)
- [Classificatori 1](../4-Classification/2-Classifiers-1/README.md)
- [Classificatori 2](../4-Classification/3-Classifiers-2/README.md)
- [ML Applicato](../4-Classification/4-Applied/README.md)
- Clustering
- [Visualizza i tuoi Dati](../5-Clustering/1-Visualize/README.md)
- [K-Means](../5-Clustering/2-K-Means/README.md)
- NLP
- [Introduzione al NLP](../6-NLP/1-Introduction-to-NLP/README.md)
- [Compiti di NLP](../6-NLP/2-Tasks/README.md)
- [Traduzione e Sentimento](../6-NLP/3-Translation-Sentiment/README.md)
- [Recensioni di Hotel 1](../6-NLP/4-Hotel-Reviews-1/README.md)
- [Recensioni di Hotel 2](../6-NLP/5-Hotel-Reviews-2/README.md)
- Previsioni di Serie Temporali
- [Introduzione alle Previsioni di Serie Temporali](../7-TimeSeries/1-Introduction/README.md)
- [ARIMA](../7-TimeSeries/2-ARIMA/README.md)
- [SVR](../7-TimeSeries/3-SVR/README.md)
- Apprendimento Rinforzato
- [Q-Learning](../8-Reinforcement/1-QLearning/README.md)
- [Gym](../8-Reinforcement/2-Gym/README.md)
- ML nel Mondo Reale
- [Applicazioni](../9-Real-World/1-Applications/README.md)
**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 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.

26
translations/it/for-teachers.md
Unescape View File

@ -1,26 +0,0 @@
## Per Educatori
Ti piacerebbe usare questo curriculum nella tua classe? Sentiti libero di farlo!
Infatti, puoi usarlo direttamente su GitHub utilizzando GitHub Classroom.
Per farlo, fai un fork di questo repo. Avrai bisogno di creare un repo per ogni lezione, quindi dovrai estrarre ogni cartella in un repo separato. In questo modo, [GitHub Classroom](https://classroom.github.com/classrooms) potrà gestire ogni lezione separatamente.
Queste [istruzioni complete](https://github.blog/2020-03-18-set-up-your-digital-classroom-with-github-classroom/) ti daranno un'idea su come configurare la tua classe.
## Usare il repo così com'è
Se desideri utilizzare questo repo nella sua forma attuale, senza usare GitHub Classroom, puoi farlo. Dovrai comunicare ai tuoi studenti quale lezione seguire insieme.
In un formato online (Zoom, Teams o altri) potresti creare stanze separate per i quiz e fare da mentore agli studenti per aiutarli a prepararsi. Poi invita gli studenti a partecipare ai quiz e a inviare le loro risposte come 'issue' a un orario prestabilito. Potresti fare lo stesso con i compiti, se vuoi che gli studenti lavorino collaborativamente in modo aperto.
Se preferisci un formato più privato, chiedi ai tuoi studenti di fare un fork del curriculum, lezione per lezione, nei loro repo GitHub privati e di darti accesso. In questo modo potranno completare quiz e compiti in privato e inviarteli tramite issue sul tuo repo di classe.
Ci sono molti modi per far funzionare questo formato in una classe online. Facci sapere quale funziona meglio per te!
## Per favore, dacci il tuo feedback!
Vogliamo fare in modo che questo curriculum funzioni per te e i tuoi studenti. Per favore, dacci il tuo [feedback](https://forms.microsoft.com/Pages/ResponsePage.aspx?id=v4j5cvGGr0GRqy180BHbR2humCsRZhxNuI79cm6n0hRUQzRVVU9VVlU5UlFLWTRLWlkyQUxORTg5WS4u).
**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 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.

115
translations/it/quiz-app/README.md
Unescape View File

@ -1,115 +0,0 @@
# Quiz
Questi quiz sono i quiz pre e post-lezione per il curriculum di ML su https://aka.ms/ml-beginners
## Configurazione del progetto
```
npm install
```
### Compilazione e ricaricamento automatico per lo sviluppo
```
npm run serve
```
### Compilazione e minificazione per la produzione
```
npm run build
```
### Lint e correzione dei file
```
npm run lint
```
### Personalizza la configurazione
Consulta [Configuration Reference](https://cli.vuejs.org/config/).
Crediti: Grazie alla versione originale di questa app quiz: https://github.com/arpan45/simple-quiz-vue
## Distribuzione su Azure
Ecco una guida passo-passo per aiutarti a iniziare:
1. Fai un fork del repository GitHub
Assicurati che il codice della tua app web statica sia nel tuo repository GitHub. Fai un fork di questo repository.
2. Crea una Azure Static Web App
- Crea un [account Azure](http://azure.microsoft.com)
- Vai al [portale di Azure](https://portal.azure.com)
- Clicca su “Crea una risorsa” e cerca “Static Web App”.
- Clicca su “Crea”.
3. Configura la Static Web App
- Base: Sottoscrizione: Seleziona la tua sottoscrizione Azure.
- Gruppo di risorse: Crea un nuovo gruppo di risorse o usa uno esistente.
- Nome: Fornisci un nome per la tua app web statica.
- Regione: Scegli la regione più vicina ai tuoi utenti.
- #### Dettagli di distribuzione:
- Sorgente: Seleziona “GitHub”.
- Account GitHub: Autorizza Azure ad accedere al tuo account GitHub.
- Organizzazione: Seleziona la tua organizzazione GitHub.
- Repository: Scegli il repository contenente la tua app web statica.
- Branch: Seleziona il branch da cui vuoi distribuire.
- #### Dettagli di build:
- Preimpostazioni di build: Scegli il framework con cui è costruita la tua app (es. React, Angular, Vue, ecc.).
- Posizione dell'app: Specifica la cartella contenente il codice della tua app (es. / se è nella radice).
- Posizione API: Se hai un'API, specifica la sua posizione (opzionale).
- Posizione output: Specifica la cartella in cui viene generato l'output della build (es. build o dist).
4. Rivedi e crea
Rivedi le tue impostazioni e clicca su “Crea”. Azure configurerà le risorse necessarie e creerà un workflow di GitHub Actions nel tuo repository.
5. Workflow di GitHub Actions
Azure creerà automaticamente un file di workflow di GitHub Actions nel tuo repository (.github/workflows/azure-static-web-apps-<nome>.yml). Questo workflow gestirà il processo di build e distribuzione.
6. Monitora la distribuzione
Vai alla scheda “Actions” nel tuo repository GitHub.
Dovresti vedere un workflow in esecuzione. Questo workflow costruirà e distribuirà la tua app web statica su Azure.
Una volta completato il workflow, la tua app sarà live sull'URL fornito da Azure.
### Esempio di file Workflow
Ecco un esempio di come potrebbe apparire il file di workflow di GitHub Actions:
name: Azure Static Web Apps CI/CD
```
on:
push:
branches:
- main
pull_request:
types: [opened, synchronize, reopened, closed]
branches:
- main
jobs:
build_and_deploy_job:
runs-on: ubuntu-latest
name: Build and Deploy Job
steps:
- uses: actions/checkout@v2
- name: Build And Deploy
id: builddeploy
uses: Azure/static-web-apps-deploy@v1
with:
azure_static_web_apps_api_token: ${{ secrets.AZURE_STATIC_WEB_APPS_API_TOKEN }}
repo_token: ${{ secrets.GITHUB_TOKEN }}
action: "upload"
app_location: "/quiz-app" # App source code path
api_location: ""API source code path optional
output_location: "dist" #Built app content directory - optional
```
### Risorse aggiuntive
- [Documentazione di Azure Static Web Apps](https://learn.microsoft.com/azure/static-web-apps/getting-started)
- [Documentazione di GitHub Actions](https://docs.github.com/actions/use-cases-and-examples/deploying/deploying-to-azure-static-web-app)
**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 professionale umana. Non siamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione.

261
translations/it/sketchnotes/LICENSE.md
Unescape View File

@ -1,261 +0,0 @@
Attribuzione-Condividi allo stesso modo 4.0 Internazionale
=======================================================================
La Creative Commons Corporation ("Creative Commons") non è uno studio legale e non fornisce servizi legali o consulenza legale. La distribuzione delle licenze pubbliche Creative Commons non crea un rapporto avvocato-cliente o altro tipo di rapporto. Creative Commons rende disponibili le sue licenze e le informazioni correlate "così come sono". Creative Commons non offre garanzie riguardo alle sue licenze, qualsiasi materiale concesso in licenza secondo i loro termini e condizioni, o qualsiasi informazione correlata. Creative Commons declina ogni responsabilità per danni derivanti dal loro utilizzo nella misura massima consentita.
Utilizzo delle licenze pubbliche Creative Commons
Le licenze pubbliche Creative Commons forniscono un insieme standard di termini e condizioni che i creatori e altri titolari di diritti possono utilizzare per condividere opere originali e altro materiale soggetto a copyright e altri diritti specificati nella licenza pubblica di seguito. Le seguenti considerazioni sono solo a scopo informativo, non sono esaustive e non fanno parte delle nostre licenze.
Considerazioni per i licenzianti: Le nostre licenze pubbliche sono
destinate all'uso da parte di coloro che sono autorizzati a dare
al pubblico il permesso di utilizzare il materiale in modi altrimenti
limitati dal copyright e da certi altri diritti. Le nostre licenze sono
irrevocabili. I licenzianti dovrebbero leggere e comprendere i termini
e le condizioni della licenza che scelgono prima di applicarla.
I licenzianti dovrebbero anche assicurarsi di avere tutti i diritti
necessari prima di applicare le nostre licenze in modo che il pubblico
possa riutilizzare il materiale come previsto. I licenzianti dovrebbero
chiaramente contrassegnare qualsiasi materiale non soggetto alla licenza.
Questo include altro materiale concesso in licenza CC, o materiale
utilizzato in base a un'eccezione o limitazione al copyright. Maggiori
considerazioni per i licenzianti:
wiki.creativecommons.org/Considerations_for_licensors
Considerazioni per il pubblico: Utilizzando una delle nostre licenze
pubbliche, un licenziante concede al pubblico il permesso di utilizzare
il materiale concesso in licenza secondo i termini e le condizioni
specificati. Se il permesso del licenziante non è necessario per
qualsiasi motivo, ad esempio, a causa di un'eccezione o limitazione
applicabile al copyright, tale uso non è regolato dalla licenza. Le
nostre licenze concedono solo permessi sotto il copyright e certi
altri diritti che un licenziante ha l'autorità di concedere. L'uso del
materiale concesso in licenza può comunque essere limitato per altri
motivi, inclusi il fatto che altri abbiano diritti di copyright o altri
diritti sul materiale. Un licenziante può fare richieste speciali, come
chiedere che tutte le modifiche siano contrassegnate o descritte. Anche
se non richiesto dalle nostre licenze, si consiglia di rispettare tali
richieste quando ragionevoli. Maggiori considerazioni per il pubblico:
wiki.creativecommons.org/Considerations_for_licensees
=======================================================================
Licenza Pubblica Creative Commons Attribution-ShareAlike 4.0 Internazionale
Esercitando i Diritti Concessi (definiti di seguito), accetti e concordi di essere vincolato dai termini e dalle condizioni di questa Licenza Pubblica Creative Commons Attribution-ShareAlike 4.0 Internazionale ("Licenza Pubblica"). Nella misura in cui questa Licenza Pubblica possa essere interpretata come un contratto, ti vengono concessi i Diritti Concessi in considerazione della tua accettazione di questi termini e condizioni, e il Licenziante ti concede tali diritti in considerazione dei benefici che il Licenziante riceve rendendo disponibile il Materiale Concesso in licenza secondo questi termini e condizioni.
Sezione 1 -- Definizioni.
a. Materiale Adattato significa materiale soggetto a Copyright e Diritti Simili che è derivato o basato sul Materiale Concesso in licenza e nel quale il Materiale Concesso in licenza è tradotto, alterato, arrangiato, trasformato o altrimenti modificato in un modo che richiede permesso ai sensi del Copyright e dei Diritti Simili detenuti dal Licenziante. Ai fini di questa Licenza Pubblica, quando il Materiale Concesso in licenza è un'opera musicale, una performance o una registrazione sonora, il Materiale Adattato è sempre prodotto quando il Materiale Concesso in licenza è sincronizzato in relazione temporale con un'immagine in movimento.
b. Licenza dell'Adattatore significa la licenza che applichi ai tuoi Copyright e Diritti Simili nei tuoi contributi al Materiale Adattato in conformità con i termini e le condizioni di questa Licenza Pubblica.
c. Licenza Compatibile BY-SA significa una licenza elencata su creativecommons.org/compatiblelicenses, approvata da Creative Commons come essenzialmente equivalente a questa Licenza Pubblica.
d. Copyright e Diritti Simili significa copyright e/o diritti simili strettamente correlati al copyright inclusi, senza limitazione, performance, trasmissione, registrazione sonora e Diritti sui Database Sui Generis, senza riguardo a come i diritti sono etichettati o categorizzati. Ai fini di questa Licenza Pubblica, i diritti specificati nella Sezione 2(b)(1)-(2) non sono Copyright e Diritti Simili.
e. Misure Tecnologiche Efficaci significa quelle misure che, in assenza di adeguata autorizzazione, non possono essere aggirate ai sensi delle leggi che soddisfano gli obblighi ai sensi dell'Articolo 11 del Trattato sul Copyright dell'OMPI adottato il 20 dicembre 1996 e/o accordi internazionali simili.
f. Eccezioni e Limitazioni significa uso equo, trattativa equa, e/o qualsiasi altra eccezione o limitazione al Copyright e Diritti Simili che si applica al tuo utilizzo del Materiale Concesso in licenza.
g. Elementi della Licenza significa gli attributi della licenza elencati nel nome di una Licenza Pubblica Creative Commons. Gli Elementi della Licenza di questa Licenza Pubblica sono Attribuzione e Condividi allo stesso modo.
h. Materiale Concesso in licenza significa l'opera artistica o letteraria, il database o altro materiale a cui il Licenziante ha applicato questa Licenza Pubblica.
i. Diritti Concessi significa i diritti concessi a te soggetti ai termini e alle condizioni di questa Licenza Pubblica, che sono limitati a tutti i Copyright e Diritti Simili che si applicano al tuo utilizzo del Materiale Concesso in licenza e che il Licenziante ha l'autorità di concedere.
j. Licenziante significa l'individuo o gli individui o l'entità o le entità che concedono diritti ai sensi di questa Licenza Pubblica.
k. Condividere significa fornire materiale al pubblico con qualsiasi mezzo o processo che richiede permesso ai sensi dei Diritti Concessi, come la riproduzione, la visualizzazione pubblica, la performance pubblica, la distribuzione, la diffusione, la comunicazione o l'importazione, e rendere disponibile il materiale al pubblico anche in modi che i membri del pubblico possano accedere al materiale da un luogo e in un momento scelti individualmente da loro.
l. Diritti sui Database Sui Generis significa diritti diversi dal copyright risultanti dalla Direttiva 96/9/CE del Parlamento Europeo e del Consiglio dell'11 marzo 1996 sulla protezione giuridica dei database, come modificata e/o sostituita, nonché altri diritti essenzialmente equivalenti in qualsiasi parte del mondo.
m. Tu significa l'individuo o l'entità che esercita i Diritti Concessi ai sensi di questa Licenza Pubblica. Il tuo ha un significato corrispondente.
Sezione 2 -- Ambito.
a. Concessione della licenza.
1. Soggetto ai termini e alle condizioni di questa Licenza Pubblica,
il Licenziante ti concede una licenza mondiale, gratuita,
non sublicenziabile, non esclusiva, irrevocabile per
esercitare i Diritti Concessi nel Materiale Concesso in licenza per:
a. riprodurre e Condividere il Materiale Concesso in licenza,
in tutto o in parte; e
b. produrre, riprodurre e Condividere Materiale Adattato.
2. Eccezioni e Limitazioni. Per evitare dubbi, laddove
Eccezioni e Limitazioni si applichino al tuo utilizzo, questa
Licenza Pubblica non si applica, e non è necessario che tu
rispetti i suoi termini e condizioni.
3. Durata. La durata di questa Licenza Pubblica è specificata nella Sezione
6(a).
4. Media e formati; modifiche tecniche consentite. Il
Licenziante ti autorizza a esercitare i Diritti Concessi in
tutti i media e formati, sia ora conosciuti che creati in futuro,
e a fare le modifiche tecniche necessarie per farlo. Il
Licenziante rinuncia e/o si impegna a non far valere alcun diritto o
autorità per vietarti di fare modifiche tecniche necessarie per
esercitare i Diritti Concessi, comprese le modifiche tecniche
necessarie per aggirare le Misure Tecnologiche Efficaci. Ai fini di
questa Licenza Pubblica, semplicemente fare modifiche autorizzate
da questa Sezione 2(a)(4) non produce mai Materiale Adattato.
5. Destinatari successivi.
a. Offerta del Licenziante -- Materiale Concesso in licenza. Ogni
destinatario del Materiale Concesso in licenza riceve automaticamente
un'offerta dal Licenziante per esercitare i Diritti Concessi
ai sensi dei termini e delle condizioni di questa Licenza Pubblica.
b. Offerta aggiuntiva del Licenziante -- Materiale Adattato.
Ogni destinatario del Materiale Adattato da te
riceve automaticamente un'offerta dal Licenziante per
esercitare i Diritti Concessi nel Materiale Adattato
secondo le condizioni della Licenza dell'Adattatore che applichi.
c. Nessuna restrizione a valle. Non puoi offrire o imporre
termini o condizioni aggiuntivi o diversi, né
applicare Misure Tecnologiche Efficaci al
Materiale Concesso in licenza se ciò limita l'esercizio dei
Diritti Concessi da parte di qualsiasi destinatario del Materiale
Concesso in licenza.
6. Nessuna approvazione. Nulla in questa Licenza Pubblica costituisce o
può essere interpretato come un permesso di affermare o implicare che tu
sia, o che il tuo utilizzo del Materiale Concesso in licenza sia, collegato
con, o sponsorizzato, approvato, o concesso stato ufficiale dal,
Licenziante o altri designati per ricevere attribuzione come
previsto nella Sezione 3(a)(1)(A)(i).
b. Altri diritti.
1. I diritti morali, come il diritto all'integrità, non sono
concessi ai sensi di questa Licenza Pubblica, né i diritti di pubblicità,
privacy, e/o altri diritti simili della personalità; tuttavia, nella
misura possibile, il Licenziante rinuncia e/o si impegna a non far valere
tali diritti detenuti dal Licenziante nella misura limitata necessaria
per consentirti di esercitare i Diritti Concessi, ma non oltre.
2. I diritti di brevetto e marchio non sono concessi ai sensi di questa
Licenza Pubblica.
3. Nella misura possibile, il Licenziante rinuncia a qualsiasi diritto di
raccogliere royalties da te per l'esercizio dei Diritti Concessi, sia
direttamente che tramite una società di gestione collettiva
ai sensi di qualsiasi schema di licenza volontaria o obbligatoria
che possa essere rinunciata. In tutti gli altri casi il Licenziante si riserva
espressamente qualsiasi diritto di raccogliere tali royalties.
Sezione 3 -- Condizioni della Licenza.
L'esercizio dei Diritti Concessi è espressamente soggetto alle
seguenti condizioni.
a. Attribuzione.
1. Se Condividi il Materiale Concesso in licenza (incluso in forma modificata),
devi:
a. mantenere quanto segue se fornito dal Licenziante
con il Materiale Concesso in licenza:
i. identificazione del creatore o dei creatori del Materiale
Concesso in licenza e di qualsiasi altro designato per ricevere
attribuzione, in qualsiasi modo ragionevole richiesto dal
Licenziante (incluso con pseudonimo se
designato);
ii. un avviso di copyright;
iii. un avviso che fa riferimento a questa Licenza Pubblica;
iv. un avviso che fa riferimento alla dichiarazione di
non responsabilità;
v. un URI o un collegamento ipertestuale al Materiale Concesso in licenza
nella misura ragionevolmente praticabile;
b. indicare se hai modificato il Materiale Concesso in licenza e
mantenere un'indicazione di eventuali modifiche precedenti; e
c. indicare che il Materiale Concesso in licenza è concesso in licenza ai sensi di questa
Licenza Pubblica, e includere il testo di, o l'URI o
il collegamento ipertestuale a, questa Licenza Pubblica.
2. Puoi soddisfare le condizioni nella Sezione 3(a)(1) in qualsiasi
modo ragionevole basato sul mezzo, sui mezzi e sul contesto in
cui Condividi il Materiale Concesso in licenza. Ad esempio, può essere
ragionevole soddisfare le condizioni fornendo un URI o
un collegamento ipertestuale a una risorsa che include le informazioni
richieste.
3. Se richiesto dal Licenziante, devi rimuovere qualsiasi delle
informazioni richieste dalla Sezione 3(a)(1)(A) nella misura
ragionevolmente praticabile.
b. Condividi allo stesso modo.
Oltre alle condizioni nella Sezione 3(a), se Condividi
Materiale Adattato che produci, si applicano anche le seguenti condizioni.
1. La Licenza dell'Adattatore che applichi deve essere una licenza Creative Commons
con gli stessi Elementi della Licenza, questa versione o
successiva, o una Licenza Compatibile BY-SA.
2. Devi includere il testo di, o l'URI o il collegamento ipertestuale a,
la Licenza dell'Adattatore che applichi. Puoi soddisfare questa condizione
in qualsiasi modo ragionevole basato sul mezzo, sui mezzi e sul contesto in
cui Condividi il Materiale Adattato.
3. Non puoi offrire o imporre termini o condizioni aggiuntivi o diversi, né
applicare Misure Tecnologiche Efficaci al
Materiale Adattato che limitino l'esercizio dei
diritti concessi ai sensi della Licenza dell'Adattatore che applichi.
Sezione 4 -- Diritti sui Database Sui Generis.
Laddove i Diritti Concessi includano i Diritti sui Database Sui Generis che
si applicano al tuo utilizzo del Materiale Concesso in licenza:
a. per evitare dubbi, la Sezione 2(a)(1) ti concede il diritto
di estrarre, riutilizzare, riprodurre e Condividere tutto o una parte
sostanziale del contenuto del database;
b. se includi tutto o una parte sostanziale del contenuto del database
in un database in cui hai Diritti sui Database Sui Generis, allora il database in
cui hai Diritti sui Database Sui Generis (ma non i suoi contenuti individuali) è Materiale Adattato,
incluso ai fini della Sezione 3(b); e
c. devi rispettare le condizioni nella Sezione 3(a) se Condividi
tutto o una parte sostanziale del contenuto del database.
Per evitare dubbi, questa Sezione 4 integra e non
sostituisce i tuoi obblighi ai sensi di questa Licenza Pubblica laddove i Diritti
Concessi includano altri Copyright e Diritti Simili.
Sezione 5 -- Dichiarazione di Non Responsabilità e Limitazione di Responsabilità.
a. SALVO DIVERSAMENTE SPECIFICATO DAL LICENZIANTE, NELLA
MISURA POSSIBILE, IL LICENZIANTE OFFRE IL MATERIALE CONCESSO IN LICENZA
COSÌ COM'È E COME DISPONIBILE, E NON FA ALCUNA DICHIARAZIONE O GARANZIA DI
ALCUN TIPO RIGUARDO AL MATERIALE CONCESSO IN LICENZA, SIA ESPRESSA,
IMPLICITA, STATUTARIA, O ALTRO. QUESTO INCLUDE, SENZA LIMITAZIONE,
GARANZIE DI TITOLO, COMMERCIABILITÀ, IDONEITÀ A UNO SCOPO PARTICOLARE,
NON VIOLAZIONE, ASSENZA DI DIFETTI LATENTI O ALTRI DIFETTI,
ACCURATEZZA, O PRESENZA O ASSENZA DI ERRORI, SIA CONOSCIUTI CHE
SCOPRIBILI. LADDOVE LE DICHIARAZIONI DI NON RESPONSABILITÀ DELLE GARANZIE NON
SIANO CONS
**Avvertenza**:
Questo documento è stato tradotto utilizzando servizi di traduzione automatica 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 madre deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione umana professionale. Non siamo responsabili per eventuali fraintendimenti o interpretazioni errate derivanti dall'uso di questa traduzione.

10
translations/it/sketchnotes/README.md
Unescape View File

@ -1,10 +0,0 @@
Tutte le sketchnote del curriculum possono essere scaricate qui.
🖨 Per la stampa in alta risoluzione, le versioni TIFF sono disponibili in [questo repo](https://github.com/girliemac/a-picture-is-worth-a-1000-words/tree/main/ml/tiff).
🎨 Creato da: [Tomomi Imura](https://github.com/girliemac) (Twitter: [@girlie_mac](https://twitter.com/girlie_mac))
[![CC BY-SA 4.0](https://img.shields.io/badge/License-CC%20BY--SA%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-sa/4.0/)
**Disclaimer**:
Questo documento è stato tradotto utilizzando servizi di traduzione automatica basati su AI. Sebbene ci sforziamo di 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.

148
translations/ja/1-Introduction/1-intro-to-ML/README.md
Unescape View File

@ -1,148 +0,0 @@
# 機械学習の入門
## [事前講義クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/1/)
---
[![初心者向け機械学習入門](https://img.youtube.com/vi/6mSx_KJxcHI/0.jpg)](https://youtu.be/6mSx_KJxcHI "初心者向け機械学習入門")
> 🎥 上の画像をクリックすると、このレッスンの短い動画が再生されます。
初心者向けの古典的な機械学習コースへようこそ！このトピックに全くの初心者であっても、または経験豊富なML実践者であっても、私たちはあなたを歓迎します！私たちは、あなたのML学習のための親しみやすい出発点を作りたいと考えており、あなたの[フィードバック](https://github.com/microsoft/ML-For-Beginners/discussions)を評価し、対応し、取り入れることを喜んで行います。
[![機械学習入門](https://img.youtube.com/vi/h0e2HAPTGF4/0.jpg)](https://youtu.be/h0e2HAPTGF4 "機械学習入門")
> 🎥 上の画像をクリックすると、MITのJohn Guttagが機械学習を紹介する動画が再生されます。
---
## 機械学習の始め方
このカリキュラムを始める前に、ノートブックをローカルで実行するためにコンピュータのセットアップを行う必要があります。
- **これらのビデオでマシンを構成する**。システムに[Pythonをインストールする方法](https://youtu.be/CXZYvNRIAKM)と、開発のための[テキストエディタを設定する](https://youtu.be/EU8eayHWoZg)方法を学ぶために以下のリンクを使用してください。
- **Pythonを学ぶ**。このコースで使用するデータサイエンティストに役立つプログラミング言語である[Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott)の基本的な理解も推奨されます。
- **Node.jsとJavaScriptを学ぶ**。このコースでは、Webアプリを作成する際にJavaScriptも数回使用するため、[node](https://nodejs.org)と[npm](https://www.npmjs.com/)をインストールし、[Visual Studio Code](https://code.visualstudio.com/)をPythonとJavaScriptの開発に利用できるようにする必要があります。
- **GitHubアカウントを作成する**。あなたが[GitHub](https://github.com)で私たちを見つけたのであれば、すでにアカウントを持っているかもしれませんが、そうでない場合はアカウントを作成し、このカリキュラムをフォークして自分で使用してください。（星を付けていただけると嬉しいです😊）
- **Scikit-learnを探索する**。これらのレッスンで参照する一連のMLライブラリである[Scikit-learn](https://scikit-learn.org/stable/user_guide.html)に慣れてください。
---
## 機械学習とは何か？
「機械学習」という用語は、今日最も人気があり頻繁に使用される用語の一つです。技術に多少なりとも親しみがあれば、どの分野で働いていても、この用語を少なくとも一度は聞いたことがある可能性があります。しかし、機械学習の仕組みは多くの人にとって謎です。機械学習の初心者にとって、このテーマは時に圧倒的に感じられることがあります。したがって、機械学習が実際に何であるかを理解し、実践的な例を通じて一歩一歩学んでいくことが重要です。
---
## ハイプカーブ
![ml hype curve](../../../../translated_images/hype.07183d711a17aafe70915909a0e45aa286ede136ee9424d418026ab00fec344c.ja.png)
> Google Trendsが示す最近の「機械学習」のハイプカーブ
---
## 謎に満ちた宇宙
私たちは魅力的な謎に満ちた宇宙に住んでいます。スティーブン・ホーキングやアルバート・アインシュタインなどの偉大な科学者たちは、周囲の世界の謎を解き明かす有意義な情報を探求するために一生を捧げました。これは学習という人間の条件です。人間の子供は、新しいことを学び、成長するにつれて世界の構造を年々明らかにしていきます。
---
## 子供の脳
子供の脳と感覚は周囲の事実を知覚し、徐々に生活の隠れたパターンを学び、それによって学んだパターンを識別するための論理的なルールを作成します。人間の脳の学習プロセスは、人間をこの世界で最も高度な生き物にします。隠れたパターンを発見し続け、それに基づいて革新することで、生涯を通じて自分自身をより良くしていくことができます。この学習能力と進化能力は、[脳の可塑性](https://www.simplypsychology.org/brain-plasticity.html)という概念に関連しています。表面的には、人間の脳の学習プロセスと機械学習の概念との間には、いくつかの動機的な類似点を引き出すことができます。
---
## 人間の脳
[人間の脳](https://www.livescience.com/29365-human-brain.html)は現実世界から物事を知覚し、知覚した情報を処理し、合理的な決定を下し、状況に応じて特定の行動を取ります。これが知的に振る舞うと呼ばれるものです。知的な行動プロセスの模倣を機械にプログラムすることを人工知能（AI）と呼びます。
---
## 用語の説明
用語が混同されることがありますが、機械学習（ML）は人工知能の重要なサブセットです。**MLは、知覚されたデータから有意義な情報を発見し、隠れたパターンを見つけて合理的な意思決定プロセスを裏付けるために特化したアルゴリズムを使用することに関心があります**。
---
## AI、ML、ディープラーニング
![AI, ML, deep learning, data science](../../../../translated_images/ai-ml-ds.537ea441b124ebf69c144a52c0eb13a7af63c4355c2f92f440979380a2fb08b8.ja.png)
> AI、ML、ディープラーニング、データサイエンスの関係を示す図。インフォグラフィックは[Jen Looper](https://twitter.com/jenlooper)によって、この[グラフィック](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)にインスパイアされて作成されました。
---
## カバーする概念
このカリキュラムでは、初心者が知っておくべき機械学習の基本概念のみをカバーします。主にScikit-learnを使用して「古典的な機械学習」をカバーします。これは多くの学生が基本を学ぶために使用する優れたライブラリです。人工知能やディープラーニングの広範な概念を理解するためには、機械学習の強固な基礎知識が不可欠であり、ここでそれを提供したいと考えています。
---
## このコースで学ぶこと
- 機械学習の基本概念
- 機械学習の歴史
- 機械学習と公平性
- 回帰ML技術
- 分類ML技術
- クラスタリングML技術
- 自然言語処理ML技術
- 時系列予測ML技術
- 強化学習
- 機械学習の実世界での応用
---
## カバーしないこと
- ディープラーニング
- ニューラルネットワーク
- AI
より良い学習体験を提供するために、ニューラルネットワークの複雑さ、「ディープラーニング」 - ニューラルネットワークを使用した多層モデル構築 - およびAIを避けます。これらは別のカリキュラムで取り上げます。また、データサイエンスに焦点を当てたカリキュラムも今後提供する予定です。
---
## なぜ機械学習を学ぶのか？
システムの観点から見ると、機械学習は、データから隠れたパターンを学習し、知的な意思決定を支援する自動化システムの作成と定義されます。
この動機は、人間の脳が外界から知覚したデータに基づいて特定のことを学習する方法に緩やかに触発されています。
✅ ビジネスがハードコードされたルールベースのエンジンを作成するのではなく、機械学習戦略を使用しようとする理由について考えてみてください。
---
## 機械学習の応用
機械学習の応用は今やほぼどこにでもあり、私たちの社会を流れるデータ、スマートフォン、接続されたデバイス、およびその他のシステムによって生成されるデータと同様に普及しています。最先端の機械学習アルゴリズムの膨大な可能性を考慮して、研究者たちはその能力を多次元および多分野の実生活の問題を解決するために探求し、素晴らしい成果を上げています。
---
## 機械学習の応用例
**機械学習をさまざまな方法で使用できます**：
- 患者の医療履歴やレポートから病気の可能性を予測する。
- 天気データを利用して天気イベントを予測する。
- テキストの感情を理解する。
- 偽ニュースを検出してプロパガンダの拡散を防ぐ。
金融、経済学、地球科学、宇宙探査、生物医学工学、認知科学、さらには人文学の分野でも、機械学習を適用して、その領域の厄介でデータ処理の重い問題を解決しています。
---
## 結論
機械学習は、現実世界のデータや生成されたデータから有意義な洞察を見つけることでパターン発見のプロセスを自動化します。ビジネス、健康、金融などのアプリケーションにおいて非常に価値があることが証明されています。
近い将来、機械学習の基本を理解することは、その広範な採用のため、どの分野の人々にとっても必須になるでしょう。
---
# 🚀 チャレンジ
紙や[Excalidraw](https://excalidraw.com/)のようなオンラインアプリを使用して、AI、ML、ディープラーニング、データサイエンスの違いについての理解をスケッチしてください。これらの技術が得意とする問題のアイデアも追加してください。
# [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/2/)
---
# レビューと自主学習
クラウドでMLアルゴリズムを使用する方法について詳しく学ぶには、この[学習パス](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-77952-leestott)を参照してください。
MLの基本についての[学習パス](https://docs.microsoft.com/learn/modules/introduction-to-machine-learning/?WT.mc_id=academic-77952-leestott)を受講してください。
---
# 課題
[セットアップと実行](assignment.md)
**免責事項**：
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期していますが、自動翻訳にはエラーや不正確さが含まれる場合があることにご注意ください。元の言語の文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

12
translations/ja/1-Introduction/1-intro-to-ML/assignment.md
Unescape View File

@ -1,12 +0,0 @@
# 起動と実行
## 手順
この成績に関係しない課題では、Pythonの復習をし、ノートブックを実行できる環境を整える必要があります。
この[Python学習パス](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-77952-leestott)を取り、その後、以下の入門ビデオを見てシステムを設定してください:
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すために努めておりますが、自動翻訳には誤りや不正確さが含まれる場合があります。原文の言語で記載されたオリジナル文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳について、当方は一切の責任を負いません。

152
translations/ja/1-Introduction/2-history-of-ML/README.md
Unescape View File

@ -1,152 +0,0 @@
# 機械学習の歴史
![機械学習の歴史の概要をスケッチノートでまとめた画像](../../../../translated_images/ml-history.a1bdfd4ce1f464d9a0502f38d355ffda384c95cd5278297a46c9a391b5053bc4.ja.png)
> スケッチノート: [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [講義前のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/3/)
---
[![初心者向け機械学習 - 機械学習の歴史](https://img.youtube.com/vi/N6wxM4wZ7V0/0.jpg)](https://youtu.be/N6wxM4wZ7V0 "初心者向け機械学習 - 機械学習の歴史")
> 🎥 上の画像をクリックすると、このレッスンの短い動画が再生されます。
このレッスンでは、機械学習と人工知能の歴史における主要なマイルストーンを見ていきます。
人工知能（AI）の歴史は機械学習の歴史と密接に関連しています。なぜなら、MLを支えるアルゴリズムや計算の進歩がAIの発展に寄与しているからです。これらの分野が1950年代に独立した研究領域として結晶化し始めた一方で、重要な[アルゴリズム、統計、数学、計算、および技術的発見](https://wikipedia.org/wiki/Timeline_of_machine_learning)はその前から存在し、重なり合っていました。実際、人々は[何百年も前から](https://wikipedia.org/wiki/History_of_artificial_intelligence)これらの問題について考えてきました。この記事では、「考える機械」のアイデアの歴史的な知的基盤について議論しています。
---
## 重要な発見
- 1763年、1812年 [ベイズの定理](https://wikipedia.org/wiki/Bayes%27_theorem) とその前身。この定理とその応用は、事前の知識に基づいてイベントが発生する確率を説明します。
- 1805年 [最小二乗法](https://wikipedia.org/wiki/Least_squares) フランスの数学者Adrien-Marie Legendreによる。この理論はデータフィッティングに役立ち、回帰ユニットで学びます。
- 1913年 [マルコフ連鎖](https://wikipedia.org/wiki/Markov_chain)、ロシアの数学者Andrey Markovにちなんで名付けられたもので、前の状態に基づいて一連の可能なイベントを説明します。
- 1957年 [パーセプトロン](https://wikipedia.org/wiki/Perceptron) アメリカの心理学者Frank Rosenblattによって発明された線形分類器の一種で、深層学習の進歩の基礎となっています。
---
- 1967年 [最近傍法](https://wikipedia.org/wiki/Nearest_neighbor) 元々はルートをマッピングするために設計されたアルゴリズムで、MLの文脈ではパターンを検出するために使用されます。
- 1970年 [逆伝播](https://wikipedia.org/wiki/Backpropagation) [フィードフォワードニューラルネットワーク](https://wikipedia.org/wiki/Feedforward_neural_network) を訓練するために使用されます。
- 1982年 [リカレントニューラルネットワーク](https://wikipedia.org/wiki/Recurrent_neural_network) フィードフォワードニューラルネットワークから派生した人工ニューラルネットワークで、時間的なグラフを作成します。
✅ 少し調べてみましょう。MLとAIの歴史において他に重要な日付は何でしょうか？
---
## 1950年: 考える機械
2019年に[一般投票で](https://wikipedia.org/wiki/Icons:_The_Greatest_Person_of_the_20th_Century) 20世紀の偉大な科学者に選ばれたAlan Turingは、「考える機械」の概念の基礎を築いたとされています。彼は、この概念に対する反対意見や自身の経験的証拠の必要性に取り組むために[チューリングテスト](https://www.bbc.com/news/technology-18475646) を作成しました。このテストについてはNLPレッスンで探求します。
---
## 1956年: ダートマス夏季研究プロジェクト
「ダートマス夏季研究プロジェクトは、人工知能という分野にとって画期的なイベントであり、ここで『人工知能』という用語が生まれました」([source](https://250.dartmouth.edu/highlights/artificial-intelligence-ai-coined-dartmouth))。
> 学習やその他の知能の特徴のすべては、原則として、機械がそれをシミュレートできるほど正確に記述することができます。
---
主任研究者である数学教授John McCarthyは、「学習やその他の知能の特徴のすべては、原則として、機械がそれをシミュレートできるほど正確に記述することができる」という仮定に基づいて進めたいと考えていました。参加者には、分野のもう一人の著名人であるMarvin Minskyも含まれていました。
このワークショップは、「シンボリックメソッドの台頭、限定されたドメインに焦点を当てたシステム（初期のエキスパートシステム）、および帰納システムと演繹システムの議論」などの議論を始め、奨励したとされています ([source](https://wikipedia.org/wiki/Dartmouth_workshop))。
---
## 1956年 - 1974年: 「黄金時代」
1950年代から1970年代半ばにかけて、AIが多くの問題を解決できるという希望に満ちていました。1967年、Marvin Minskyは「一世代のうちに…『人工知能』を作成する問題は実質的に解決されるだろう」と自信を持って述べました (Minsky, Marvin (1967), Computation: Finite and Infinite Machines, Englewood Cliffs, N.J.: Prentice-Hall)。
自然言語処理の研究が盛んになり、検索が洗練され強力になり、「マイクロワールド」という概念が生まれ、簡単なタスクが平易な言語指示で完了されました。
---
政府機関からの研究資金が豊富で、計算とアルゴリズムの進歩があり、インテリジェントな機械のプロトタイプが作られました。これらの機械のいくつかには次のようなものがあります：
* [Shakey the robot](https://wikipedia.org/wiki/Shakey_the_robot)、タスクを「知的に」実行する方法を決定しながら移動できるロボット。
![知的なロボット、Shakey](../../../../translated_images/shakey.4dc17819c447c05bf4b52f76da0bdd28817d056fdb906252ec20124dd4cfa55e.ja.jpg)
> 1972年のShakey
---
* Eliza、初期の「チャターボット」、人々と会話し、原始的な「セラピスト」として機能しました。ElizaについてはNLPレッスンでさらに学びます。
![ボットのEliza](../../../../translated_images/eliza.84397454cda9559bb5ec296b5b8fff067571c0cccc5405f9c1ab1c3f105c075c.ja.png)
> チャットボットの一バージョン、Eliza
---
* 「ブロックワールド」は、ブロックを積み重ねたり分類したりするマイクロワールドの例で、機械に意思決定を教える実験が行われました。 [SHRDLU](https://wikipedia.org/wiki/SHRDLU) などのライブラリを使用して構築された進歩が言語処理を推進しました。
[![SHRDLUを使ったブロックワールド](https://img.youtube.com/vi/QAJz4YKUwqw/0.jpg)](https://www.youtube.com/watch?v=QAJz4YKUwqw "SHRDLUを使ったブロックワールド")
> 🎥 上の画像をクリックすると、SHRDLUを使ったブロックワールドの動画が再生されます
---
## 1974年 - 1980年: 「AIの冬」
1970年代半ばまでに、「知的な機械」を作ることの複雑さが過小評価されており、利用可能な計算能力に対するその約束が過大評価されていたことが明らかになりました。資金は枯渇し、分野への信頼は低下しました。信頼を損なった問題には次のようなものがあります：
---
- **限界**。計算能力が限られていました。
- **組み合わせ爆発**。コンピュータに求めることが増えるにつれて、トレーニングする必要のあるパラメータの数が指数関数的に増加しましたが、計算能力と能力の進化が並行していませんでした。
- **データの不足**。アルゴリズムのテスト、開発、改良を妨げるデータの不足がありました。
- **正しい質問をしているのか？**。研究者が取り組んでいる質問自体が疑問視され始めました。研究者たちはそのアプローチに対して批判を受けるようになりました：
- チューリングテストは、「デジタルコンピュータをプログラムすることで言語を理解しているように見せることはできるが、実際の理解を生み出すことはできない」という『中国語の部屋理論』などのアイデアによって疑問視されました ([source](https://plato.stanford.edu/entries/chinese-room/))。
- 「セラピスト」ELIZAのような人工知能を社会に導入する倫理が問われました。
---
同時に、さまざまなAIの学派が形成され始めました。「[スクラフィー]と[ニートAI](https://wikipedia.org/wiki/Neats_and_scruffies)」の実践の間に二分化が確立されました。_スクラフィー_の研究室は、望む結果が得られるまでプログラムを微調整しました。_ニート_の研究室は「論理と形式的な問題解決」に焦点を当てました。ELIZAとSHRDLUはよく知られた_スクラフィー_システムでした。1980年代に入り、MLシステムを再現可能にする需要が高まると、その結果がより説明可能であるため、_ニート_アプローチが徐々に主流になりました。
---
## 1980年代 エキスパートシステム
分野が成長するにつれて、そのビジネスへの利益が明確になり、1980年代には「エキスパートシステム」の普及が進みました。「エキスパートシステムは、最初に成功した人工知能（AI）ソフトウェアの一つです」([source](https://wikipedia.org/wiki/Expert_system))。
このタイプのシステムは実際には_ハイブリッド_であり、ビジネス要件を定義するルールエンジンと、ルールシステムを活用して新しい事実を推論する推論エンジンから部分的に構成されています。
この時代はまた、ニューラルネットワークに対する関心が高まった時期でもあります。
---
## 1987年 - 1993年: AIの冷却期
専門化されたエキスパートシステムハードウェアの普及は、残念ながらあまりにも専門化されすぎました。パーソナルコンピュータの普及もこれらの大規模で専門化された集中システムと競合しました。コンピューティングの民主化が始まり、最終的にはビッグデータの現代の爆発の道を開きました。
---
## 1993年 - 2011年
この時代は、データと計算能力の不足によって引き起こされた問題を解決するための新しい時代を迎えました。データの量は急速に増加し、より広く利用可能になり、特に2007年頃のスマートフォンの登場とともに、良くも悪くも広まりました。計算能力は指数関数的に拡大し、アルゴリズムもそれに伴って進化しました。この分野は、過去の自由奔放な日々から真の学問分野へと結晶化し始めました。
---
## 現在
今日、機械学習とAIは私たちの生活のほぼすべての部分に触れています。この時代は、これらのアルゴリズムが人間の生活に与えるリスクと影響を慎重に理解することを求めています。MicrosoftのBrad Smithは、「情報技術はプライバシーや表現の自由などの基本的人権保護の核心に関わる問題を提起します。これらの問題は、これらの製品を作成する技術企業に対する責任を高めます。私たちの見解では、思慮深い政府の規制と許容される使用に関する規範の発展も必要です」([source](https://www.technologyreview.com/2019/12/18/102365/the-future-of-ais-impact-on-society/))と述べています。
---
将来がどうなるかはまだわかりませんが、これらのコンピュータシステムとそれらが実行するソフトウェアやアルゴリズムを理解することが重要です。このカリキュラムが、あなた自身が判断するためのより良い理解を得るのに役立つことを願っています。
[![ディープラーニングの歴史](https://img.youtube.com/vi/mTtDfKgLm54/0.jpg)](https://www.youtube.com/watch?v=mTtDfKgLm54 "ディープラーニングの歴史")
> 🎥 上の画像をクリックすると、Yann LeCunがディープラーニングの歴史について講演する動画が再生されます
---
## 🚀チャレンジ
これらの歴史的な瞬間の一つに掘り下げて、その背後にいる人々についてもっと学びましょう。魅力的なキャラクターがいて、どんな科学的発見も文化的な真空の中で生まれたわけではありません。何を発見しますか？
## [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/4/)
---
## 復習と自己学習
以下のアイテムを見たり聞いたりしましょう：
[Amy BoydがAIの進化について話すこのポッドキャスト](http://runasradio.com/Shows/Show/739)
[![The history of AI by Amy Boyd](https://img.youtube.com/vi/EJt3_bFYKss/0.jpg)](https://www.youtube.com/watch?v=EJt3_bFYKss "The history of AI by Amy Boyd")
---
## 課題
[タイムラインを作成する](assignment.md)
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる場合がありますのでご注意ください。原文がその言語での権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤った解釈について、当社は一切の責任を負いません。

14
translations/ja/1-Introduction/2-history-of-ML/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# タイムラインを作成する
## 指示
[このリポジトリ](https://github.com/Digital-Humanities-Toolkit/timeline-builder)を使用して、アルゴリズム、数学、統計、AI、またはMLの歴史のある側面、またはこれらの組み合わせのタイムラインを作成します。一人の人物、一つのアイデア、または長い期間の思考に焦点を当てることができます。マルチメディア要素を追加することを忘れないでください。
## ルーブリック
| 基準 | 優秀 | 十分 | 改善が必要 |
| -------- | ------------------------------------------------- | --------------------------------------- | ---------------------------------------------------------------- |
| | GitHubページとして展開されたタイムラインが提示される | コードが不完全で展開されていない | タイムラインが不完全で、十分に調査されておらず、展開されていない |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すために努力しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。原文の母国語の文書を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当方は一切の責任を負いかねます。

113
translations/ja/1-Introduction/3-fairness/README.md
Unescape View File

@ -1,113 +0,0 @@
# 責任あるAIを用いた機械学習ソリューションの構築
![機械学習における責任あるAIの概要を示すスケッチノート](../../../../translated_images/ml-fairness.ef296ebec6afc98a44566d7b6c1ed18dc2bf1115c13ec679bb626028e852fa1d.ja.png)
> スケッチノート by [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [事前講義クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/5/)
## はじめに
このカリキュラムでは、機械学習がどのように私たちの日常生活に影響を与えているかを発見し始めます。現在でも、システムやモデルは、医療診断、ローンの承認、詐欺の検出など、日常の意思決定タスクに関与しています。したがって、これらのモデルが信頼できる結果を提供するためにうまく機能することが重要です。あらゆるソフトウェアアプリケーションと同様に、AIシステムも期待を裏切ったり、望ましくない結果をもたらすことがあります。そのため、AIモデルの挙動を理解し、説明することが不可欠です。
これらのモデルを構築するために使用するデータに特定の人口統計（人種、性別、政治的見解、宗教など）が欠けている場合、またはこれらの人口統計が不均衡に表現されている場合、何が起こるかを想像してみてください。モデルの出力が特定の人口統計を優遇するように解釈された場合、アプリケーションにとっての結果はどうなるでしょうか。さらに、モデルが望ましくない結果をもたらし、人々に害を及ぼす場合はどうなるでしょうか。AIシステムの挙動に対する責任は誰が負うのでしょうか。これらは、このカリキュラムで探求するいくつかの質問です。
このレッスンでは、次のことを学びます:
- 機械学習における公平性の重要性と関連する害についての認識を高める
- 信頼性と安全性を確保するために異常値や異常なシナリオを探る実践に慣れる
- 包括的なシステムを設計することで全員をエンパワーメントする必要性を理解する
- データと人々のプライバシーとセキュリティを保護することの重要性を探る
- AIモデルの挙動を説明するためのガラスボックスアプローチの重要性を見る
- AIシステムに対する信頼を構築するためにアカウンタビリティが不可欠であることを意識する
## 前提条件
前提条件として、「責任あるAIの原則」学習パスを受講し、以下のビデオを視聴してください:
この[学習パス](https://docs.microsoft.com/learn/modules/responsible-ai-principles/?WT.mc_id=academic-77952-leestott)を通じて責任あるAIについてさらに学びましょう。
[![Microsoftの責任あるAIへのアプローチ](https://img.youtube.com/vi/dnC8-uUZXSc/0.jpg)](https://youtu.be/dnC8-uUZXSc "Microsoftの責任あるAIへのアプローチ")
> 🎥 上の画像をクリックしてビデオを視聴: Microsoftの責任あるAIへのアプローチ
## 公平性
AIシステムはすべての人を公平に扱い、類似のグループに異なる影響を与えないようにする必要があります。例えば、AIシステムが医療処置、ローン申請、または雇用に関するガイダンスを提供する場合、類似の症状、財政状況、または専門資格を持つすべての人に同じ推奨を行うべきです。私たち人間は、意思決定や行動に影響を与える遺伝的なバイアスを持っています。これらのバイアスは、AIシステムをトレーニングするために使用するデータにも現れることがあります。このような操作は時には意図せずに行われることがあります。データにバイアスを導入する際に意識的に気づくことはしばしば困難です。
**「不公平」**とは、人種、性別、年齢、障害状態などの観点から定義される人々のグループに対するネガティブな影響、または「害」を指します。主な公平性に関連する害は次のように分類されます:
- **割り当て**。例えば、性別や民族が他の性別や民族に対して優遇される場合。
- **サービスの質**。特定のシナリオのためにデータをトレーニングしたが、現実ははるかに複雑である場合、パフォーマンスの低いサービスにつながります。例えば、暗い肌の人々を感知できないハンドソープディスペンサー。[参考](https://gizmodo.com/why-cant-this-soap-dispenser-identify-dark-skin-1797931773)
- **中傷**。何かまたは誰かを不公平に批判し、ラベル付けすること。例えば、画像ラベリング技術が暗い肌の人々の画像をゴリラと誤ってラベリングしたことで有名です。
- **過剰または過小な表現**。特定の職業に特定のグループが見られないという考えであり、そのサービスや機能がそれを促進し続けることは害をもたらします。
- **ステレオタイプ**。特定のグループを事前に割り当てられた属性と関連付けること。例えば、英語とトルコ語の間の言語翻訳システムが、性別に関するステレオタイプに関連する単語のために不正確さを持つ可能性があります。
![トルコ語への翻訳](../../../../translated_images/gender-bias-translate-en-tr.f185fd8822c2d4372912f2b690f6aaddd306ffbb49d795ad8d12a4bf141e7af0.ja.png)
> トルコ語への翻訳
![英語への翻訳](../../../../translated_images/gender-bias-translate-tr-en.4eee7e3cecb8c70e13a8abbc379209bc8032714169e585bdeac75af09b1752aa.ja.png)
> 英語への翻訳
AIシステムの設計とテストを行う際には、AIが公平であり、バイアスや差別的な決定を下すようにプログラムされていないことを確認する必要があります。AIと機械学習における公平性を保証することは、依然として複雑な社会技術的課題です。
### 信頼性と安全性
信頼を築くためには、AIシステムは通常および予期せぬ条件下でも信頼性が高く、安全で一貫している必要があります。特に外れ値の場合に、AIシステムがどのように挙動するかを知ることが重要です。AIソリューションを構築する際には、AIソリューションが遭遇するさまざまな状況をどのように処理するかに多くの焦点を当てる必要があります。例えば、自動運転車は人々の安全を最優先に考える必要があります。その結果、車を駆動するAIは、夜間、雷雨、吹雪、道路を横切る子供、ペット、道路工事など、車が遭遇する可能性のあるすべてのシナリオを考慮する必要があります。AIシステムが幅広い条件をどれだけ信頼性が高く安全に処理できるかは、データサイエンティストやAI開発者がシステムの設計やテスト中にどれだけの予測を考慮したかを反映しています。
> [🎥 こちらをクリックしてビデオを見る: ](https://www.microsoft.com/videoplayer/embed/RE4vvIl)
### 包括性
AIシステムは、すべての人々をエンゲージし、エンパワーメントするように設計されるべきです。AIシステムを設計および実装する際に、データサイエンティストやAI開発者は、システムが意図せずに人々を排除する可能性のある障壁を特定し、対処します。例えば、世界中には10億人の障害者がいます。AIの進歩により、彼らは日常生活で幅広い情報や機会により簡単にアクセスできるようになります。障壁に対処することで、すべての人々に利益をもたらすより良い体験を提供するAI製品を革新し、開発する機会が生まれます。
> [🎥 こちらをクリックしてビデオを見る: AIにおける包括性](https://www.microsoft.com/videoplayer/embed/RE4vl9v)
### セキュリティとプライバシー
AIシステムは安全であり、人々のプライバシーを尊重するべきです。プライバシー、情報、または生活を危険にさらすシステムには、人々はあまり信頼を寄せません。機械学習モデルをトレーニングする際には、最良の結果を生み出すためにデータに依存します。そのため、データの出所と整合性を考慮する必要があります。例えば、データがユーザーによって提供されたものか、公開されているものかを確認します。次に、データを扱う際には、機密情報を保護し、攻撃に耐えるAIシステムを開発することが重要です。AIが普及するにつれて、プライバシーを保護し、重要な個人情報やビジネス情報を保護することがますます重要かつ複雑になっています。プライバシーとデータセキュリティの問題は、AIにとって特に注意が必要です。なぜなら、データへのアクセスは、AIシステムが人々について正確で情報に基づいた予測と決定を行うために不可欠だからです。
> [🎥 こちらをクリックしてビデオを見る: AIにおけるセキュリティ](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- 業界として、GDPR（一般データ保護規則）などの規制により、プライバシーとセキュリティの分野で大きな進展を遂げました。
- しかし、AIシステムにおいては、システムをより個人的で効果的にするためにより多くの個人データが必要であるという必要性とプライバシーの間の緊張関係を認識する必要があります。
- インターネットを介した接続されたコンピュータの誕生と同様に、AIに関連するセキュリティ問題の数が急増しています。
- 同時に、セキュリティを向上させるためにAIが使用されているのを目にしています。例えば、ほとんどの最新のアンチウイルススキャナーは、今日ではAIヒューリスティックによって駆動されています。
- データサイエンスのプロセスが最新のプライバシーとセキュリティの実践と調和するようにする必要があります。
### 透明性
AIシステムは理解可能であるべきです。透明性の重要な部分は、AIシステムとそのコンポーネントの挙動を説明することです。AIシステムの理解を深めるためには、ステークホルダーがそれらがどのように機能し、なぜ機能するのかを理解し、潜在的なパフォーマンスの問題、安全性とプライバシーの懸念、バイアス、排除的な実践、または意図しない結果を特定できるようにする必要があります。また、AIシステムを使用する人々は、いつ、なぜ、どのようにそれらを展開することを選択するのかについて正直で率直であるべきだと考えています。使用するシステムの限界も含めて説明する必要があります。例えば、銀行が消費者向け融資決定を支援するためにAIシステムを使用する場合、その結果を調査し、システムの推奨をどのデータが影響しているのかを理解することが重要です。政府は産業全体でAIを規制し始めているため、データサイエンティストや組織は、AIシステムが規制要件を満たしているかどうかを説明する必要があります。特に望ましくない結果が生じた場合には、特に重要です。
> [🎥 こちらをクリックしてビデオを見る: AIにおける透明性](https://www.microsoft.com/videoplayer/embed/RE4voJF)
- AIシステムは非常に複雑であるため、それらがどのように機能し、結果を解釈するのかを理解するのは難しいです。
- この理解の欠如は、これらのシステムがどのように管理され、運用され、文書化されるかに影響を与えます。
- さらに重要なのは、これらのシステムが生成する結果を使用して行われる意思決定に影響を与えます。
### アカウンタビリティ
AIシステムを設計し、展開する人々は、そのシステムの動作に対して責任を負わなければなりません。アカウンタビリティの必要性は、特に顔認識のような敏感な技術において特に重要です。最近、特に失踪した子供を見つけるなどの用途で技術の可能性を見ている法執行機関から、顔認識技術に対する需要が高まっています。しかし、これらの技術は、特定の個人の継続的な監視を可能にすることによって、政府が市民の基本的な自由を危険にさらす可能性があります。したがって、データサイエンティストや組織は、自分たちのAIシステムが個人や社会に与える影響について責任を持つ必要があります。
[![主要なAI研究者が顔認識による大規模監視の警告](../../../../translated_images/accountability.41d8c0f4b85b6231301d97f17a450a805b7a07aaeb56b34015d71c757cad142e.ja.png)](https://www.youtube.com/watch?v=Wldt8P5V6D0 "Microsoftの責任あるAIへのアプローチ")
> 🎥 上の画像をクリックしてビデオを視聴: 顔認識による大規模監視の警告
最終的に、AIを社会に導入する最初の世代としての私たちの最大の課題の一つは、コンピュータが人々に対して責任を持ち続けることをどのように確保するか、そしてコンピュータを設計する人々が他のすべての人々に対して責任を持ち続けることをどのように確保するかです。
## 影響評価
機械学習モデルをトレーニングする前に、AIシステムの目的、意図された使用法、展開場所、およびシステムとやり取りする人々を理解するために影響評価を実施することが重要です。これらは、システムを評価するレビュアーやテスターに、潜在的なリスクや予期される結果を特定する際に考慮すべき要因を知らせるのに役立ちます。
影響評価を行う際の重点領域は次のとおりです:
* **個人への悪影響**。システムのパフォーマンスを妨げる制限や要件、サポートされていない使用法、既知の制限に注意を払うことは、システムが個人に害を与える方法で使用されないようにするために重要です。
* **データ要件**。システムがデータをどのように使用し、どこで使用するかを理解することで、考慮すべきデータ要件（例：GDPRやHIPPAデータ規制）を探ることができます。さらに、トレーニングに十分なデータの出所や量を確認します。
* **影響の概要**。システムの使用によって生じる可能性のある害のリストを収集します。MLライフサイクル全体で、特定された問題が軽減または対処されているかどうかを確認します。
* **6つのコア原則の適用可能な目標**。各原則の目標が達成されているかどうか、およびギャップがあるかどうかを評価します。
## 責任あるAIによるデバッグ
ソフトウェアアプリケーションの
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご理解ください。元の言語で書かれた原文が信頼できる情報源とみなされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤った解釈について、当社は責任を負いません。

14
translations/ja/1-Introduction/3-fairness/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# Responsible AI Toolboxを探る
## 指示
このレッスンでは、データサイエンティストがAIシステムを分析・改善するための「オープンソースのコミュニティ主導のプロジェクト」であるResponsible AI Toolboxについて学びました。この課題では、RAI Toolboxの[ノートブック](https://github.com/microsoft/responsible-ai-toolbox/blob/main/notebooks/responsibleaidashboard/getting-started.ipynb)の一つを探り、その結果を論文やプレゼンテーションで報告してください。
## 評価基準
| 基準 | 優秀 | 適切 | 改善が必要 |
| -------- | --------- | -------- | ----------------- |
| | Fairlearnのシステム、実行したノートブック、およびその結果について論じた論文またはパワーポイントプレゼンテーションが提示されている | 結論のない論文が提示されている | 論文が提示されていない |
**免責事項**:
この文書は機械翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。権威ある情報源として、原文の言語の文書を参照してください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用により生じた誤解や誤認に対して、当社は一切の責任を負いません。

121
translations/ja/1-Introduction/4-techniques-of-ML/README.md
Unescape View File

@ -1,121 +0,0 @@
# 機械学習のテクニック
機械学習モデルを構築、使用、維持するプロセスと、それに使用するデータの管理は、他の多くの開発ワークフローとは大きく異なります。このレッスンでは、そのプロセスを解明し、知っておくべき主要なテクニックを概説します。以下のことを学びます：
- 機械学習のプロセスを高いレベルで理解する。
- 「モデル」、「予測」、「トレーニングデータ」といった基本概念を探る。
## [講義前のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/7/)
[![初心者向け機械学習 - 機械学習のテクニック](https://img.youtube.com/vi/4NGM0U2ZSHU/0.jpg)](https://youtu.be/4NGM0U2ZSHU "初心者向け機械学習 - 機械学習のテクニック")
> 🎥 上の画像をクリックすると、このレッスンの短いビデオが再生されます。
## はじめに
高いレベルでは、機械学習（ML）プロセスを作成する技術は以下のいくつかのステップから成り立っています：
1. **質問を決める**。ほとんどのMLプロセスは、単純な条件付きプログラムやルールベースのエンジンでは答えられない質問から始まります。これらの質問は、データのコレクションに基づく予測に関することが多いです。
2. **データを収集し準備する**。質問に答えるためにはデータが必要です。データの質や量が、最初の質問にどれだけうまく答えられるかを決定します。このフェーズではデータの可視化も重要です。また、データをトレーニング用とテスト用に分割してモデルを構築することも含まれます。
3. **トレーニング方法を選ぶ**。質問とデータの性質に応じて、モデルをどのようにトレーニングするかを選びます。これはMLプロセスの中で特定の専門知識が必要であり、多くの場合、かなりの実験が必要な部分です。
4. **モデルをトレーニングする**。トレーニングデータを使用して、データのパターンを認識するモデルをトレーニングします。モデルは内部の重みを調整して、データの特定の部分を他よりも優先することで、より良いモデルを構築することができます。
5. **モデルを評価する**。収集したデータセットから見たことのないデータ（テストデータ）を使用して、モデルのパフォーマンスを確認します。
6. **パラメータ調整**。モデルのパフォーマンスに基づいて、異なるパラメータやアルゴリズムを使用してプロセスを再実行することができます。
7. **予測する**。新しい入力を使用して、モデルの精度をテストします。
## どの質問をするか
コンピュータはデータの中に隠れたパターンを発見するのが得意です。この能力は、条件ベースのルールエンジンを作成するだけでは簡単に答えられない質問を持つ研究者にとって非常に役立ちます。例えば、アクチュアリアルなタスクを考えると、データサイエンティストは喫煙者と非喫煙者の死亡率に関する手作りのルールを構築できるかもしれません。
しかし、他の多くの変数が関与すると、過去の健康履歴に基づいて将来の死亡率を予測するためにMLモデルがより効率的である可能性があります。より楽しい例として、緯度、経度、気候変動、海への近さ、ジェット気流のパターンなどのデータに基づいて、特定の場所の4月の天気予測をすることが挙げられます。
✅ この[スライドデッキ](https://www2.cisl.ucar.edu/sites/default/files/2021-10/0900%20June%2024%20Haupt_0.pdf)は、天気予報モデルにおけるMLの使用に関する歴史的な視点を提供しています。
## モデル構築前のタスク
モデルを構築する前に、いくつかのタスクを完了する必要があります。質問をテストし、モデルの予測に基づいて仮説を形成するために、いくつかの要素を特定し、設定する必要があります。
### データ
質問に確実に答えるためには、適切な種類のデータが十分に必要です。この時点で行うべきことは2つあります：
- **データを収集する**。前のレッスンでデータ分析の公平性について学んだことを念頭に置き、データを慎重に収集します。このデータのソース、その中に含まれるバイアス、その出所を文書化します。
- **データを準備する**。データ準備プロセスにはいくつかのステップがあります。データを収集して正規化する必要があるかもしれません。データの質と量を向上させるために、文字列を数値に変換するなどの方法を使用することができます（[クラスタリング](../../5-Clustering/1-Visualize/README.md)で行うように）。また、元のデータに基づいて新しいデータを生成することもできます（[分類](../../4-Classification/1-Introduction/README.md)で行うように）。データをクリーンアップし、編集することもできます（[Webアプリ](../../3-Web-App/README.md)のレッスンの前に行うように）。最後に、トレーニングテクニックに応じて、データをランダム化し、シャッフルする必要があるかもしれません。
✅ データを収集し処理した後、その形状が意図した質問に答えるのに適しているか確認してください。データが与えられたタスクでうまく機能しないことがあるかもしれません（[クラスタリング](../../5-Clustering/1-Visualize/README.md)のレッスンで発見するように）。
### 特徴量とターゲット
[特徴量](https://www.datasciencecentral.com/profiles/blogs/an-introduction-to-variable-and-feature-selection)はデータの測定可能な特性です。多くのデータセットでは、「日付」、「サイズ」、「色」などの列見出しとして表現されます。特徴量変数は通常コードでは`X`として表され、モデルをトレーニングするために使用される入力変数を表します。
ターゲットは予測しようとしているものです。ターゲットは通常コードでは`y`として表され、データに対して尋ねようとしている質問の答えを表します：12月にはどの**色**のカボチャが最も安いのか？サンフランシスコではどの地区が最も良い不動産**価格**を持つのか？ターゲットはラベル属性とも呼ばれることがあります。
### 特徴量変数の選択
🎓 **特徴選択と特徴抽出** モデルを構築する際にどの変数を選択するかどうかをどうやって知るのか？おそらく特徴選択や特徴抽出のプロセスを経て、最もパフォーマンスの良いモデルのための適切な変数を選ぶことになるでしょう。しかし、これらは同じことではありません：「特徴抽出は元の特徴の関数から新しい特徴を作成するのに対し、特徴選択は特徴のサブセットを返します。」（[出典](https://wikipedia.org/wiki/Feature_selection)）
### データの可視化
データサイエンティストのツールキットの重要な側面は、SeabornやMatPlotLibのような優れたライブラリを使用してデータを可視化する力です。データを視覚的に表現することで、活用できる隠れた相関関係を見つけることができます。また、バイアスや不均衡なデータを発見するのにも役立ちます（[分類](../../4-Classification/2-Classifiers-1/README.md)で発見するように）。
### データセットの分割
トレーニングの前に、データセットを不均等なサイズの2つ以上の部分に分割し、それでもデータをよく表現する必要があります。
- **トレーニング**。データセットのこの部分は、モデルにフィットしてトレーニングします。このセットは元のデータセットの大部分を構成します。
- **テスト**。テストデータセットは、元のデータから収集された独立したデータのグループで、構築されたモデルのパフォーマンスを確認するために使用します。
- **検証**。検証セットは、モデルのハイパーパラメータやアーキテクチャを調整してモデルを改善するために使用する小さな独立したデータのグループです。データのサイズと質問に応じて、この3つ目のセットを構築する必要がないかもしれません（[時系列予測](../../7-TimeSeries/1-Introduction/README.md)で注目するように）。
## モデルの構築
トレーニングデータを使用して、さまざまなアルゴリズムを使用してデータの統計的表現であるモデルを構築することが目標です。モデルをトレーニングすることで、データに対する仮定を行い、発見したパターンを検証し、受け入れたり拒否したりします。
### トレーニング方法を決定する
質問とデータの性質に応じて、トレーニング方法を選択します。このコースで使用する[Scikit-learnのドキュメント](https://scikit-learn.org/stable/user_guide.html)をステップバイステップで進めることで、モデルをトレーニングするための多くの方法を探ることができます。経験に応じて、最適なモデルを構築するためにいくつかの異なる方法を試す必要があるかもしれません。データサイエンティストが未見のデータをフィードしてモデルのパフォーマンスを評価し、精度、バイアス、その他の品質低下の問題をチェックし、タスクに最も適したトレーニング方法を選択するプロセスを経ることが多いです。
### モデルをトレーニングする
トレーニングデータを用意したら、モデルを「フィット」させる準備が整います。多くのMLライブラリでは、「model.fit」というコードを見つけることができます。このときに特徴量変数（通常は「X」）とターゲット変数（通常は「y」）を値の配列として送信します。
### モデルを評価する
トレーニングプロセスが完了すると（大規模なモデルをトレーニングするには多くの反復や「エポック」が必要な場合があります）、テストデータを使用してモデルのパフォーマンスを評価することができます。このデータは、モデルが以前に分析していない元のデータのサブセットです。モデルの品質に関するメトリクスのテーブルを印刷することができます。
🎓 **モデルのフィッティング**
機械学習の文脈では、モデルのフィッティングとは、モデルの基礎となる関数が未知のデータを分析しようとする際の精度を指します。
🎓 **アンダーフィッティング**と**オーバーフィッティング**は、モデルの品質を低下させる一般的な問題です。モデルがトレーニングデータに対して適合しすぎるか、適合しなさすぎるかのいずれかです。オーバーフィットしたモデルは、データの詳細やノイズを学びすぎるため、トレーニングデータを非常によく予測します。アンダーフィットしたモデルは、トレーニングデータも未知のデータも正確に分析できないため、精度が低いです。
![オーバーフィッティングモデル](../../../../translated_images/overfitting.1c132d92bfd93cb63240baf63ebdf82c30e30a0a44e1ad49861b82ff600c2b5c.ja.png)
> インフォグラフィック by [Jen Looper](https://twitter.com/jenlooper)
## パラメータ調整
初期トレーニングが完了したら、モデルの品質を観察し、「ハイパーパラメータ」を調整することで改善することを考えます。プロセスの詳細は[ドキュメント](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-tune-hyperparameters?WT.mc_id=academic-77952-leestott)を参照してください。
## 予測
これは、完全に新しいデータを使用してモデルの精度をテストする瞬間です。「応用」ML設定では、モデルを実際に使用するためのWebアセットを構築する場合、このプロセスはユーザー入力（例えばボタンの押下）を収集し、変数を設定してモデルに推論または評価のために送信することを含むかもしれません。
これらのレッスンでは、準備、構築、テスト、評価、予測のステップを使用して、データサイエンティストとしてのジェスチャーを学び、より「フルスタック」なMLエンジニアになるための旅を進めていきます。
---
## 🚀チャレンジ
ML実践者のステップを反映したフローチャートを描いてください。現在のプロセスのどこにいると感じますか？どこで困難を感じると予測しますか？何が簡単に感じますか？
## [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/8/)
## 復習と自主学習
データサイエンティストが日常の仕事について話しているインタビューをオンラインで検索してください。ここに[一例](https://www.youtube.com/watch?v=Z3IjgbbCEfs)があります。
## 課題
[データサイエンティストにインタビューする](assignment.md)
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期すため努力しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご理解ください。原文はその言語での正式な文書と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当方は一切の責任を負いません。

14
translations/ja/1-Introduction/4-techniques-of-ML/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# データサイエンティストにインタビューする
## 指示
あなたの会社、ユーザーグループ、友人や同級生の中で、データサイエンティストとして専門的に働いている人に話を聞いてください。彼らの日常業務について500文字の短いレポートを書いてください。彼らはスペシャリストですか、それとも「フルスタック」で働いていますか？
## ルーブリック
| 基準 | 模範的 | 十分 | 改善が必要 |
| -------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------ | --------------------- |
| | 正しい長さのエッセイで、出典が明示されており、.docファイルとして提出されている | エッセイの出典が不十分、または必要な長さに満たない | エッセイが提出されていない |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご了承ください。元の言語での原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳について、当社は責任を負いません。

25
translations/ja/1-Introduction/README.md
Unescape View File

@ -1,25 +0,0 @@
# 機械学習の紹介
このカリキュラムのセクションでは、機械学習の分野における基本概念、機械学習とは何か、その歴史や研究者が使用する技術について学びます。一緒にこの新しいMLの世界を探求しましょう！
![globe](../../../translated_images/globe.59f26379ceb40428672b4d9a568044618a2bf6292ecd53a5c481b90e3fa805eb.ja.jpg)
> 写真提供 <a href="https://unsplash.com/@bill_oxford?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Bill Oxford</a> on <a href="https://unsplash.com/s/photos/globe?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
### レッスン
1. [機械学習の紹介](1-intro-to-ML/README.md)
1. [機械学習とAIの歴史](2-history-of-ML/README.md)
1. [公平性と機械学習](3-fairness/README.md)
1. [機械学習の技術](4-techniques-of-ML/README.md)
### クレジット
"Introduction to Machine Learning" は [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan), [Ornella Altunyan](https://twitter.com/ornelladotcom) および [Jen Looper](https://twitter.com/jenlooper) を含むチームによって♥️を込めて書かれました。
"The History of Machine Learning" は [Jen Looper](https://twitter.com/jenlooper) および [Amy Boyd](https://twitter.com/AmyKateNicho) によって♥️を込めて書かれました。
"Fairness and Machine Learning" は [Tomomi Imura](https://twitter.com/girliemac) によって♥️を込めて書かれました。
"Techniques of Machine Learning" は [Jen Looper](https://twitter.com/jenlooper) および [Chris Noring](https://twitter.com/softchris) によって♥️を込めて書かれました。
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる場合がありますのでご注意ください。原文がある場合は、その原文を正式な情報源とみなしてください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳については、一切の責任を負いかねます。

228
translations/ja/2-Regression/1-Tools/README.md
Unescape View File

@ -1,228 +0,0 @@
# PythonとScikit-learnで回帰モデルを始めよう
![Summary of regressions in a sketchnote](../../../../translated_images/ml-regression.4e4f70e3b3ed446e3ace348dec973e133fa5d3680fbc8412b61879507369b98d.ja.png)
> スケッチノート by [Tomomi Imura](https://www.twitter.com/girlie_mac)
## [プレレクチャークイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/9/)
> ### [このレッスンはRでも利用可能です！](../../../../2-Regression/1-Tools/solution/R/lesson_1.html)
## はじめに
これらの4つのレッスンで、回帰モデルの構築方法を学びます。これが何のためにあるのかについては、すぐに説明します。しかし、何かを始める前に、プロセスを開始するための適切なツールが揃っていることを確認してください！
このレッスンでは、以下のことを学びます：
- ローカル機械学習タスクのためにコンピュータを設定する方法
- Jupyterノートブックの使用方法
- Scikit-learnのインストールと使用方法
- ハンズオンエクササイズで線形回帰を探求する方法
## インストールと設定
[![ML for beginners - Setup your tools ready to build Machine Learning models](https://img.youtube.com/vi/-DfeD2k2Kj0/0.jpg)](https://youtu.be/-DfeD2k2Kj0 "ML for beginners -Setup your tools ready to build Machine Learning models")
> 🎥 上の画像をクリックして、コンピュータをML用に設定する短いビデオをご覧ください。
1. **Pythonをインストールする**。コンピュータに[Python](https://www.python.org/downloads/)がインストールされていることを確認してください。Pythonは多くのデータサイエンスや機械学習タスクで使用されます。ほとんどのコンピュータシステムには既にPythonがインストールされています。一部のユーザーにとってセットアップを簡単にするための便利な[Python Coding Packs](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-77952-leestott)もあります。
ただし、Pythonの使用法によっては、特定のバージョンが必要な場合があります。そのため、[仮想環境](https://docs.python.org/3/library/venv.html)で作業することが便利です。
2. **Visual Studio Codeをインストールする**。コンピュータにVisual Studio Codeがインストールされていることを確認してください。基本的なインストール手順については、[Visual Studio Codeのインストール](https://code.visualstudio.com/)に従ってください。このコースではVisual Studio CodeでPythonを使用するので、[Visual Studio CodeのPython開発用の設定](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-77952-leestott)についても確認しておくと良いでしょう。
> このコレクションの[Learnモジュール](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-77952-leestott)を通してPythonに慣れてください。
>
> [![Setup Python with Visual Studio Code](https://img.youtube.com/vi/yyQM70vi7V8/0.jpg)](https://youtu.be/yyQM70vi7V8 "Setup Python with Visual Studio Code")
>
> 🎥 上の画像をクリックして、VS Code内でPythonを使用するビデオをご覧ください。
3. **Scikit-learnをインストールする**。詳細は[こちらの手順](https://scikit-learn.org/stable/install.html)に従ってください。Python 3を使用する必要があるため、仮想環境を使用することをお勧めします。M1 Macにこのライブラリをインストールする場合は、上記のページに特別な指示があります。
4. **Jupyter Notebookをインストールする**。 [Jupyterパッケージ](https://pypi.org/project/jupyter/)をインストールする必要があります。
## あなたのML著作環境
**ノートブック**を使用してPythonコードを開発し、機械学習モデルを作成します。このタイプのファイルはデータサイエンティストにとって一般的なツールであり、拡張子`.ipynb`で識別できます。
ノートブックは、開発者がコードを書くだけでなく、コードに関するメモやドキュメントを追加することができるインタラクティブな環境であり、実験的または研究指向のプロジェクトに非常に役立ちます。
[![ML for beginners - Set up Jupyter Notebooks to start building regression models](https://img.youtube.com/vi/7E-jC8FLA2E/0.jpg)](https://youtu.be/7E-jC8FLA2E "ML for beginners - Set up Jupyter Notebooks to start building regression models")
> 🎥 上の画像をクリックして、このエクササイズを進める短いビデオをご覧ください。
### エクササイズ - ノートブックを使う
このフォルダには、_notebook.ipynb_というファイルがあります。
1. _notebook.ipynb_をVisual Studio Codeで開きます。
JupyterサーバーがPython 3+で起動します。ノートブックの中には`run`、コードの部分があります。再生ボタンのようなアイコンを選択してコードブロックを実行できます。
1. `md`アイコンを選択し、マークダウンを少し追加し、次のテキストを追加します **# Welcome to your notebook**。
次に、Pythonコードを追加します。
1. コードブロックに**print('hello notebook')**と入力します。
1. 矢印を選択してコードを実行します。
以下の出力が表示されるはずです：
```output
hello notebook
```
![VS Code with a notebook open](../../../../translated_images/notebook.4a3ee31f396b88325607afda33cadcc6368de98040ff33942424260aa84d75f2.ja.jpg)
コードとコメントを交互に記述してノートブックを自己文書化できます。
✅ ウェブ開発者の作業環境とデータサイエンティストの作業環境の違いについて少し考えてみてください。
## Scikit-learnのセットアップ
Pythonがローカル環境に設定され、Jupyterノートブックに慣れたところで、次はScikit-learnに慣れていきましょう（発音は `sci` as in `science`）。Scikit-learnはMLタスクを実行するための[広範なAPI](https://scikit-learn.org/stable/modules/classes.html#api-ref)を提供しています。
彼らの[ウェブサイト](https://scikit-learn.org/stable/getting_started.html)によると、「Scikit-learnは、教師あり学習と教師なし学習をサポートするオープンソースの機械学習ライブラリです。また、モデルフィッティング、データ前処理、モデル選択と評価、その他多くのユーティリティのためのさまざまなツールを提供します。」
このコースでは、Scikit-learnやその他のツールを使用して、いわゆる「伝統的な機械学習」タスクを実行するための機械学習モデルを構築します。ニューラルネットワークやディープラーニングは含まれていませんが、それらについては今後の「AI for Beginners」カリキュラムで詳しく取り上げます。
Scikit-learnはモデルの構築と評価を簡単に行えるようにします。主に数値データの使用に焦点を当てており、学習ツールとして使用できるいくつかの既成のデータセットも含まれています。また、学生が試すための事前構築されたモデルも含まれています。パッケージ化されたデータを読み込み、基本的なデータを使用してScikit-learnで最初のMLモデルを構築するプロセスを探りましょう。
## エクササイズ - 初めてのScikit-learnノートブック
> このチュートリアルは、Scikit-learnのウェブサイトにある[線形回帰の例](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py)に触発されました。
[![ML for beginners - Your First Linear Regression Project in Python](https://img.youtube.com/vi/2xkXL5EUpS0/0.jpg)](https://youtu.be/2xkXL5EUpS0 "ML for beginners - Your First Linear Regression Project in Python")
> 🎥 上の画像をクリックして、このエクササイズを進める短いビデオをご覧ください。
このレッスンに関連する_notebook.ipynb_ファイル内のすべてのセルをゴミ箱アイコンを押してクリアします。
このセクションでは、学習目的でScikit-learnに組み込まれている糖尿病に関する小さなデータセットを使用します。糖尿病患者の治療をテストしたいと考えているとします。機械学習モデルは、変数の組み合わせに基づいて、どの患者が治療に反応しやすいかを判断するのに役立つかもしれません。非常に基本的な回帰モデルでも、視覚化すると、理論的な臨床試験を整理するのに役立つ変数に関する情報を示すかもしれません。
✅ 回帰方法には多くの種類があり、どの方法を選ぶかは求める答えによって異なります。ある年齢の人の予想身長を予測したい場合は、線形回帰を使用します。なぜなら、**数値の値**を求めているからです。ある料理がビーガンかどうかを調べたい場合は、**カテゴリの割り当て**を求めているので、ロジスティック回帰を使用します。ロジスティック回帰については後で詳しく学びます。データに対してどのような質問をすることができるか、そしてどの方法が適切かについて少し考えてみてください。
このタスクを始めましょう。
### ライブラリをインポートする
このタスクのためにいくつかのライブラリをインポートします：
- **matplotlib**。便利な[グラフツール](https://matplotlib.org/)で、ラインプロットを作成するために使用します。
- **numpy**。 [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html)は、Pythonで数値データを扱うのに便利なライブラリです。
- **sklearn**。これは[Scikit-learn](https://scikit-learn.org/stable/user_guide.html)ライブラリです。
タスクを助けるためにいくつかのライブラリをインポートします。
1. 次のコードを入力してインポートを追加します：
```python
import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection
```
上記では、`matplotlib`, `numpy` and you are importing `datasets`, `linear_model` and `model_selection` from `sklearn`. `model_selection` is used for splitting data into training and test sets.
### The diabetes dataset
The built-in [diabetes dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) includes 442 samples of data around diabetes, with 10 feature variables, some of which include:
- age: age in years
- bmi: body mass index
- bp: average blood pressure
- s1 tc: T-Cells (a type of white blood cells)
✅ This dataset includes the concept of 'sex' as a feature variable important to research around diabetes. Many medical datasets include this type of binary classification. Think a bit about how categorizations such as this might exclude certain parts of a population from treatments.
Now, load up the X and y data.
> 🎓 Remember, this is supervised learning, and we need a named 'y' target.
In a new code cell, load the diabetes dataset by calling `load_diabetes()`. The input `return_X_y=True` signals that `X` will be a data matrix, and `y`は回帰ターゲットになります。
1. データマトリックスの形状とその最初の要素を表示するためにいくつかのprintコマンドを追加します：
```python
X, y = datasets.load_diabetes(return_X_y=True)
print(X.shape)
print(X[0])
```
返される応答はタプルです。タプルの最初の2つの値をそれぞれ`X` and `y`に割り当てています。 [タプルについて](https://wikipedia.org/wiki/Tuple)の詳細を学びましょう。
このデータは10個の要素で構成された配列の442アイテムがあることがわかります：
```text
(442, 10)
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
-0.04340085 -0.00259226 0.01990842 -0.01764613]
```
✅ データと回帰ターゲットの関係について少し考えてみてください。線形回帰は特徴量Xとターゲット変数yの関係を予測します。このドキュメントで糖尿病データセットの[ターゲット](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset)を見つけることができますか？ターゲットを考えると、このデータセットは何を示しているのでしょうか？
2. 次に、このデータセットの一部を選択してプロットするために、データセットの3番目の列を選択します。これは`：` operator to select all rows, and then selecting the 3rd column using the index (2). You can also reshape the data to be a 2D array - as required for plotting - by using `reshape(n_rows, n_columns)`を使用して行うことができます。パラメータの1つが-1の場合、対応する次元は自動的に計算されます。
```python
X = X[:, 2]
X = X.reshape((-1,1))
```
✅ いつでもデータを印刷してその形状を確認してください。
3. データがプロットする準備ができたら、このデータセットの数値間に論理的な分割を見つけるために機械を使用できるかどうかを確認できます。これを行うには、データ（X）とターゲット（y）の両方をテストセットとトレーニングセットに分割する必要があります。Scikit-learnにはこれを簡単に行う方法があります。指定したポイントでテストデータを分割できます。
```python
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
```
4. モデルをトレーニングする準備ができました！線形回帰モデルをロードし、Xとyのトレーニングセットを使用して`model.fit()`でトレーニングします：
```python
model = linear_model.LinearRegression()
model.fit(X_train, y_train)
```
✅ `model.fit()` is a function you'll see in many ML libraries such as TensorFlow
5. Then, create a prediction using test data, using the function `predict()`。これはデータグループ間に線を引くために使用されます。
```python
y_pred = model.predict(X_test)
```
6. データをプロットに表示する時が来ました。Matplotlibはこのタスクに非常に便利なツールです。すべてのXとyテストデータの散布図を作成し、モデルのデータグループ間に最も適切な場所に線を引くために予測を使用します。
```python
plt.scatter(X_test, y_test, color='black')
plt.plot(X_test, y_pred, color='blue', linewidth=3)
plt.xlabel('Scaled BMIs')
plt.ylabel('Disease Progression')
plt.title('A Graph Plot Showing Diabetes Progression Against BMI')
plt.show()
```
![a scatterplot showing datapoints around diabetes](../../../../translated_images/scatterplot.ad8b356bcbb33be68d54050e09b9b7bfc03e94fde7371f2609ae43f4c563b2d7.ja.png)
✅ ここで何が起こっているのか少し考えてみてください。多くの小さなデータ点の間に一直線が引かれていますが、具体的に何をしているのでしょうか？この線を使用して、新しい見えないデータポイントがプロットのy軸との関係でどこにフィットするべきかを予測できることがわかりますか？このモデルの実際の使用法を言葉で表現してみてください。
おめでとうございます、最初の線形回帰モデルを構築し、それを使用して予測を作成し、プロットに表示しました！
---
## 🚀チャレンジ
このデータセットから別の変数をプロットしてください。ヒント：この行を編集します：`X = X[:,2]`。このデータセットのターゲットを考えると、糖尿病の進行について何を発見できるでしょうか？
## [ポストレクチャークイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/10/)
## レビュー＆自己学習
このチュートリアルでは、単回帰ではなく、単変量回帰または多重回帰を使用しました。これらの方法の違いについて少し読んでみるか、[このビデオ](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)を見てみてください。
回帰の概念についてさらに読み、どのような質問にこの技術で答えることができるか考えてみてください。この[チュートリアル](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-77952-leestott)を受けて、理解を深めてください。
## 課題
[別のデータセット](assignment.md)
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期すために努力しておりますが、自動翻訳には誤りや不正確さが含まれる場合があります。原文の言語で書かれた文書を権威ある情報源とみなすべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤った解釈について、当社は一切の責任を負いません。

16
translations/ja/2-Regression/1-Tools/assignment.md
Unescape View File

@ -1,16 +0,0 @@
# Scikit-learnを使った回帰
## 説明
Scikit-learnの[Linnerudデータセット](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud)を見てみましょう。このデータセットには複数の[ターゲット](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset)があります。'これはフィットネスクラブに通う20人の中年男性から収集された、3つの運動（データ）と3つの生理学的（ターゲット）変数で構成されています。'
あなた自身の言葉で、ウエストラインと達成された腹筋運動の回数の関係をプロットする回帰モデルの作成方法を説明してください。このデータセットの他のデータポイントについても同様に行ってください。
## ルーブリック
| 基準 | 優秀 | 適切 | 改善の余地あり |
| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
| 説明文の提出 | よく書かれた説明文が提出されている | 数文の説明文が提出されている | 説明文が提出されていない |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。元の言語で書かれた原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いかねます。

4
translations/ja/2-Regression/1-Tools/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械翻訳サービスを使用して翻訳されています。正確さを期すよう努めていますが、自動翻訳には誤りや不正確な点が含まれる場合があります。元の言語で書かれた原文が権威ある情報源とみなされるべきです。重要な情報については、専門の人間による翻訳を推奨します。本翻訳の使用に起因する誤解や誤った解釈について、当社は一切の責任を負いません。

215
translations/ja/2-Regression/2-Data/README.md
Unescape View File

@ -1,215 +0,0 @@
# Scikit-learnで回帰モデルを構築する: データの準備と可視化
![データ可視化のインフォグラフィック](../../../../translated_images/data-visualization.54e56dded7c1a804d00d027543f2881cb32da73aeadda2d4a4f10f3497526114.ja.png)
インフォグラフィック作成者: [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [講義前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/11/)
> ### [このレッスンはRでも利用可能です！](../../../../2-Regression/2-Data/solution/R/lesson_2.html)
## はじめに
Scikit-learnを使って機械学習モデルを構築するためのツールをセットアップしたので、データに対して質問を始める準備が整いました。データを扱い、MLソリューションを適用する際には、データセットの可能性を正しく引き出すために適切な質問をすることが非常に重要です。
このレッスンでは以下を学びます：
- モデル構築のためのデータの準備方法
- Matplotlibを使ったデータの可視化方法
## データに対して適切な質問をする
解決したい質問が、使用するMLアルゴリズムの種類を決定します。そして、得られる回答の質はデータの性質に大きく依存します。
このレッスンで提供される[データ](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv)を見てみましょう。この.csvファイルをVS Codeで開くことができます。ざっと見ると、空白や文字列と数値データの混在があることがすぐにわかります。また、「Package」という奇妙な列があり、データは「sacks」、「bins」などの値が混在しています。実際、このデータは少し乱雑です。
[![初心者向けML - データセットの分析とクリーニング方法](https://img.youtube.com/vi/5qGjczWTrDQ/0.jpg)](https://youtu.be/5qGjczWTrDQ "初心者向けML - データセットの分析とクリーニング方法")
> 🎥 上の画像をクリックして、このレッスンのデータ準備を進める短いビデオを視聴してください。
実際、完全に使える状態のデータセットをそのまま受け取ることはあまり一般的ではありません。このレッスンでは、標準的なPythonライブラリを使用して生データセットを準備する方法を学びます。また、データを可視化するためのさまざまな手法も学びます。
## ケーススタディ: 'かぼちゃ市場'
このフォルダには、ルート`data`フォルダに[US-pumpkins.csv](https://github.com/microsoft/ML-For-Beginners/blob/main/2-Regression/data/US-pumpkins.csv)という名前の.csvファイルがあります。これは、都市ごとに分類されたかぼちゃ市場に関する1757行のデータを含んでいます。これは、米国農務省が配布している[Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice)から抽出された生データです。
### データの準備
このデータはパブリックドメインにあります。USDAのウェブサイトから都市ごとに多数の別々のファイルとしてダウンロードできます。あまりにも多くの別々のファイルを避けるために、すべての都市データを1つのスプレッドシートに連結しましたので、すでに少しデータを準備しています。次に、データを詳しく見てみましょう。
### かぼちゃデータ - 初期の結論
このデータについて何に気づきますか？すでに文字列、数値、空白、奇妙な値が混在していることがわかりました。
回帰手法を使用してこのデータにどのような質問ができますか？例えば、「特定の月に販売されるかぼちゃの価格を予測する」といった質問はどうでしょうか。データを再度見てみると、このタスクに必要なデータ構造を作成するためにいくつかの変更が必要です。
## 演習 - かぼちゃデータの分析
[Pandas](https://pandas.pydata.org/)（名前は`Python Data Analysis`の略です）というデータの整形に非常に役立つツールを使用して、このかぼちゃデータを分析・準備しましょう。
### まず、欠損している日付を確認する
まず、欠損している日付を確認するための手順を踏む必要があります：
1. 日付を月形式に変換します（これらは米国の日付なので、形式は`MM/DD/YYYY`です）。
2. 新しい列に月を抽出します。
Visual Studio Codeで_notebook.ipynb_ファイルを開き、スプレッドシートを新しいPandasデータフレームにインポートします。
1. `head()`関数を使用して最初の5行を表示します。
```python
import pandas as pd
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
pumpkins.head()
```
✅ 最後の5行を表示するにはどの関数を使用しますか？
1. 現在のデータフレームに欠損データがあるかどうかを確認します：
```python
pumpkins.isnull().sum()
```
欠損データがありますが、現在のタスクには影響がないかもしれません。
1. データフレームを扱いやすくするために、以下の例のように必要な列だけを選択します。`loc` function which extracts from the original dataframe a group of rows (passed as first parameter) and columns (passed as second parameter). The expression `:`は「すべての行」を意味します。
```python
columns_to_select = ['Package', 'Low Price', 'High Price', 'Date']
pumpkins = pumpkins.loc[:, columns_to_select]
```
### 次に、かぼちゃの平均価格を決定する
特定の月におけるかぼちゃの平均価格を決定する方法を考えてみましょう。このタスクにはどの列を選びますか？ヒント：3つの列が必要です。
解決策：`Low Price` and `High Price`列の平均を取って新しいPrice列を作成し、Date列を月だけ表示するように変換します。幸い、上記のチェックによると、日付や価格に欠損データはありません。
1. 平均を計算するために、次のコードを追加します：
```python
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
month = pd.DatetimeIndex(pumpkins['Date']).month
```
✅ `print(month)`を使用して、必要なデータをチェックすることができます。
2. 変換したデータを新しいPandasデータフレームにコピーします：
```python
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
```
データフレームを印刷すると、新しい回帰モデルを構築するためのきれいで整理されたデータセットが表示されます。
### しかし、まだ奇妙な点があります
`Package` column, pumpkins are sold in many different configurations. Some are sold in '1 1/9 bushel' measures, and some in '1/2 bushel' measures, some per pumpkin, some per pound, and some in big boxes with varying widths.
> Pumpkins seem very hard to weigh consistently
Digging into the original data, it's interesting that anything with `Unit of Sale` equalling 'EACH' or 'PER BIN' also have the `Package` type per inch, per bin, or 'each'. Pumpkins seem to be very hard to weigh consistently, so let's filter them by selecting only pumpkins with the string 'bushel' in their `Package`列を見てください。
1. 最初の.csvインポートの下にフィルタを追加します：
```python
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
```
データを印刷すると、バスケット単位でかぼちゃを含む約415行のデータのみが表示されます。
### しかし、もう一つやるべきことがあります
バスケットの量が行ごとに異なることに気づきましたか？価格を標準化するために、バスケットごとの価格を表示するように計算を行います。
1. 新しい_pumpkinsデータフレームを作成するブロックの後に、次の行を追加します：
```python
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1 1/9'), 'Price'] = price/(1 + 1/9)
new_pumpkins.loc[new_pumpkins['Package'].str.contains('1/2'), 'Price'] = price/(1/2)
```
✅ [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308)によると、バスケットの重量は産物の種類によって異なります。これは体積の測定だからです。「例えば、トマトのバスケットは56ポンドの重量があるとされています... 葉物や野菜は空間を多く取り、重量が少ないため、ほうれん草のバスケットは20ポンドしかありません。」これは非常に複雑です！バスケットからポンドへの変換は行わず、バスケットごとの価格を表示することにしましょう。このかぼちゃのバスケットに関する研究は、データの性質を理解することの重要性を示しています！
これで、バスケットの測定に基づいて単位ごとの価格を分析できます。データをもう一度印刷すると、標準化されたことがわかります。
✅ 半バスケットで販売されているかぼちゃが非常に高価であることに気づきましたか？なぜかを考えてみましょう。ヒント：小さなかぼちゃは大きなかぼちゃよりもはるかに高価です。なぜなら、大きな中空のパイかぼちゃが占める未使用のスペースが多いからです。
## 可視化戦略
データサイエンティストの役割の一つは、彼らが扱っているデータの質と性質を示すことです。そのために、しばしば興味深い可視化、プロット、グラフ、チャートを作成し、データのさまざまな側面を示します。このようにして、視覚的に関係やギャップを示すことができ、それを発見するのが難しいことがあります。
[![初心者向けML - Matplotlibを使ったデータの可視化方法](https://img.youtube.com/vi/SbUkxH6IJo0/0.jpg)](https://youtu.be/SbUkxH6IJo0 "初心者向けML - Matplotlibを使ったデータの可視化方法")
> 🎥 上の画像をクリックして、このレッスンのデータ可視化を進める短いビデオを視聴してください。
可視化は、データに最も適した機械学習手法を決定するのにも役立ちます。例えば、線に沿っているように見える散布図は、データが線形回帰演習に適していることを示します。
Jupyterノートブックでよく機能するデータ可視化ライブラリの一つに[Matplotlib](https://matplotlib.org/)があります（前のレッスンでも見ました）。
> データ可視化の経験をさらに積むために、[これらのチュートリアル](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-77952-leestott)を参照してください。
## 演習 - Matplotlibを試してみる
作成した新しいデータフレームを表示するために、いくつかの基本的なプロットを作成してみましょう。基本的な折れ線グラフはどのように見えるでしょうか？
1. ファイルの上部に、Pandasのインポートの下にMatplotlibをインポートします：
```python
import matplotlib.pyplot as plt
```
1. ノートブック全体を再実行してリフレッシュします。
1. ノートブックの下部に、データをボックスプロットとしてプロットするセルを追加します：
```python
price = new_pumpkins.Price
month = new_pumpkins.Month
plt.scatter(price, month)
plt.show()
```
![価格と月の関係を示す散布図](../../../../translated_images/scatterplot.b6868f44cbd2051c6680ccdbb1510697d06a3ff6cd4abda656f5009c0ed4e3fc.ja.png)
このプロットは役に立ちますか？何か驚くことがありますか？
特に役に立ちません。データを月ごとの点の広がりとして表示するだけです。
### 役に立つものにする
有用なデータを表示するためには、通常データを何らかの方法でグループ化する必要があります。y軸に月を表示し、データが分布を示すプロットを作成してみましょう。
1. グループ化された棒グラフを作成するセルを追加します：
```python
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
plt.ylabel("Pumpkin Price")
```
![価格と月の関係を示す棒グラフ](../../../../translated_images/barchart.a833ea9194346d769c77a3a870f7d8aee51574cd1138ca902e5500830a41cbce.ja.png)
これはより有用なデータ可視化です！9月と10月にかぼちゃの最高価格が発生しているようです。それはあなたの期待に合っていますか？なぜそう思いますか？
---
## 🚀チャレンジ
Matplotlibが提供するさまざまな種類の可視化を探ってみましょう。回帰問題に最も適した種類はどれですか？
## [講義後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/12/)
## レビューと自己学習
データを可視化するさまざまな方法を見てみましょう。利用可能なさまざまなライブラリのリストを作成し、特定のタスクに最適なものをメモしてください。例えば、2D可視化と3D可視化の違いについて調べてみてください。何がわかりましたか？
## 課題
[可視化の探索](assignment.md)
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる場合があります。原文の母国語の文書を権威ある情報源と見なしてください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤った解釈については、一切の責任を負いかねます。

12
translations/ja/2-Regression/2-Data/assignment.md
Unescape View File

@ -1,12 +0,0 @@
# ビジュアライゼーションの探求
データビジュアライゼーションにはいくつかの異なるライブラリが利用可能です。このレッスンで使用するカボチャのデータを使って、matplotlibとseabornを使用してサンプルノートブックでいくつかのビジュアライゼーションを作成します。どのライブラリが使いやすいですか？
## ルーブリック
| 基準 | 優秀 | 適切 | 改善の余地あり |
| -------- | --------- | -------- | ----------------- |
| | 2つの探求/ビジュアライゼーションを含むノートブックが提出される | 1つの探求/ビジュアライゼーションを含むノートブックが提出される | ノートブックが提出されない |
**免責事項**：
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。原文の言語による文書が信頼できる情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用によって生じる誤解や誤解釈について、当社は一切の責任を負いません。

4
translations/ja/2-Regression/2-Data/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すために努めていますが、自動翻訳にはエラーや不正確さが含まれる場合があります。元の言語での原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用から生じる誤解や誤認については責任を負いかねます。

355
translations/ja/2-Regression/3-Linear/README.md
Unescape View File

@ -1,355 +0,0 @@
# Scikit-learnを使用して回帰モデルを構築する: 回帰の4つの方法
![線形回帰と多項式回帰のインフォグラフィック](../../../../translated_images/linear-polynomial.5523c7cb6576ccab0fecbd0e3505986eb2d191d9378e785f82befcf3a578a6e7.ja.png)
> インフォグラフィック作成者 [Dasani Madipalli](https://twitter.com/dasani_decoded)
## [講義前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/13/)
> ### [このレッスンはRでも利用可能です！](../../../../2-Regression/3-Linear/solution/R/lesson_3.html)
### はじめに
これまでに、かぼちゃの価格データセットから収集したサンプルデータを使用して、回帰が何であるかを調査しました。また、Matplotlibを使用してそれを視覚化しました。
今度は、MLの回帰についてさらに深く掘り下げる準備ができました。視覚化はデータを理解するのに役立ちますが、機械学習の本当の力はモデルのトレーニングにあります。モデルは過去のデータに基づいてデータの依存関係を自動的にキャプチャし、モデルが以前に見たことのない新しいデータの結果を予測できるようにします。
このレッスンでは、基本的な線形回帰と多項式回帰の2種類の回帰について学びます。これらのモデルを使用して、異なる入力データに基づいてかぼちゃの価格を予測できるようになります。
[![初心者向けML - 線形回帰の理解](https://img.youtube.com/vi/CRxFT8oTDMg/0.jpg)](https://youtu.be/CRxFT8oTDMg "初心者向けML - 線形回帰の理解")
> 🎥 上の画像をクリックすると、線形回帰の概要を短いビデオで確認できます。
> このカリキュラム全体を通じて、数学の知識が最小限であることを前提としており、他の分野から来る学生にも理解しやすいように、ノート、🧮 コールアウト、図表、その他の学習ツールを活用しています。
### 前提条件
これまでに、調査しているかぼちゃデータの構造に慣れているはずです。このレッスンの_notebook.ipynb_ファイルに、あらかじめ読み込まれ、前処理された状態でデータが含まれています。ファイルには、かぼちゃの価格が新しいデータフレームでブッシェルごとに表示されています。これらのノートブックをVisual Studio Codeのカーネルで実行できるようにしてください。
### 準備
データを読み込む目的を思い出してください。
- かぼちゃを買うのに最適な時期はいつですか？
- ミニチュアかぼちゃ1ケースの価格はどのくらいですか？
- それらを半ブッシェルバスケットで買うべきですか、それとも1 1/9ブッシェルボックスで買うべきですか？
このデータをさらに掘り下げてみましょう。
前のレッスンでは、Pandasデータフレームを作成し、元のデータセットの一部を取り込み、ブッシェル単位で価格を標準化しました。しかし、その結果、約400のデータポイントしか収集できず、秋の数か月分のデータしかありませんでした。
このレッスンのノートブックに事前に読み込まれたデータを見てみましょう。データは事前に読み込まれ、月ごとのデータを示す初期の散布図が描かれています。データをさらにクリーンアップすることで、データの性質についてもう少し詳細を得ることができるかもしれません。
## 線形回帰のライン
レッスン1で学んだように、線形回帰の目的は次のことができるようにラインをプロットすることです：
- **変数の関係を示す**。変数間の関係を示す
- **予測を行う**。新しいデータポイントがそのラインに対してどこに位置するかを正確に予測する
このタイプのラインを描くのは、通常、**最小二乗法回帰**です。「最小二乗」とは、回帰線の周りのすべてのデータポイントを二乗してから合計することを意味します。理想的には、その最終的な合計ができるだけ小さいことが望まれます。なぜなら、エラーの数を少なくしたいからです。
すべてのデータポイントからの累積距離が最小になるようにラインをモデル化したいからです。また、方向よりも大きさを重視するため、項を加算する前に二乗します。
> **🧮 数学を見せて**
>
> このライン、最適フィットラインは[方程式](https://en.wikipedia.org/wiki/Simple_linear_regression)で表すことができます：
>
> ```
> Y = a + bX
> ```
>
> `X` is the 'explanatory variable'. `Y` is the 'dependent variable'. The slope of the line is `b` and `a` is the y-intercept, which refers to the value of `Y` when `X = 0`.
>
>![calculate the slope](../../../../translated_images/slope.f3c9d5910ddbfcf9096eb5564254ba22c9a32d7acd7694cab905d29ad8261db3.ja.png)
>
> First, calculate the slope `b`. Infographic by [Jen Looper](https://twitter.com/jenlooper)
>
> In other words, and referring to our pumpkin data's original question: "predict the price of a pumpkin per bushel by month", `X` would refer to the price and `Y` would refer to the month of sale.
>
>![complete the equation](../../../../translated_images/calculation.a209813050a1ddb141cdc4bc56f3af31e67157ed499e16a2ecf9837542704c94.ja.png)
>
> Calculate the value of Y. If you're paying around $4, it must be April! Infographic by [Jen Looper](https://twitter.com/jenlooper)
>
> The math that calculates the line must demonstrate the slope of the line, which is also dependent on the intercept, or where `Y` is situated when `X = 0`.
>
> You can observe the method of calculation for these values on the [Math is Fun](https://www.mathsisfun.com/data/least-squares-regression.html) web site. Also visit [this Least-squares calculator](https://www.mathsisfun.com/data/least-squares-calculator.html) to watch how the numbers' values impact the line.
## Correlation
One more term to understand is the **Correlation Coefficient** between given X and Y variables. Using a scatterplot, you can quickly visualize this coefficient. A plot with datapoints scattered in a neat line have high correlation, but a plot with datapoints scattered everywhere between X and Y have a low correlation.
A good linear regression model will be one that has a high (nearer to 1 than 0) Correlation Coefficient using the Least-Squares Regression method with a line of regression.
✅ Run the notebook accompanying this lesson and look at the Month to Price scatterplot. Does the data associating Month to Price for pumpkin sales seem to have high or low correlation, according to your visual interpretation of the scatterplot? Does that change if you use more fine-grained measure instead of `Month`, eg. *day of the year* (i.e. number of days since the beginning of the year)?
In the code below, we will assume that we have cleaned up the data, and obtained a data frame called `new_pumpkins`, similar to the following:
ID | Month | DayOfYear | Variety | City | Package | Low Price | High Price | Price
---|-------|-----------|---------|------|---------|-----------|------------|-------
70 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
71 | 9 | 267 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
72 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 18.0 | 18.0 | 16.363636
73 | 10 | 274 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 17.0 | 17.0 | 15.454545
74 | 10 | 281 | PIE TYPE | BALTIMORE | 1 1/9 bushel cartons | 15.0 | 15.0 | 13.636364
> The code to clean the data is available in [`notebook.ipynb`](../../../../2-Regression/3-Linear/notebook.ipynb). We have performed the same cleaning steps as in the previous lesson, and have calculated `DayOfYear` カラムを次の式を使用して計算します：
```python
day_of_year = pd.to_datetime(pumpkins['Date']).apply(lambda dt: (dt-datetime(dt.year,1,1)).days)
```
線形回帰の数学的背景を理解したので、回帰モデルを作成して、どのパッケージのかぼちゃが最も良い価格を持つかを予測してみましょう。ホリデーパンプキンパッチのためにかぼちゃを購入する人は、この情報を利用してかぼちゃパッケージの購入を最適化することができるでしょう。
## 相関を探す
[![初心者向けML - 相関を探す: 線形回帰の鍵](https://img.youtube.com/vi/uoRq-lW2eQo/0.jpg)](https://youtu.be/uoRq-lW2eQo "初心者向けML - 相関を探す: 線形回帰の鍵")
> 🎥 上の画像をクリックすると、相関の概要を短いビデオで確認できます。
前のレッスンで、異なる月の平均価格が次のように見えることに気づいたかもしれません：
<img alt="月ごとの平均価格" src="../2-Data/images/barchart.png" width="50%"/>
これは、ある種の相関があることを示唆しており、`Month` and `Price`, or between `DayOfYear` and `Price`. Here is the scatter plot that shows the latter relationship:
<img alt="Scatter plot of Price vs. Day of Year" src="images/scatter-dayofyear.png" width="50%" />
Let's see if there is a correlation using the `corr` 関数を使用して相関を計算してみることができます：
```python
print(new_pumpkins['Month'].corr(new_pumpkins['Price']))
print(new_pumpkins['DayOfYear'].corr(new_pumpkins['Price']))
```
相関はかなり小さいようです、`Month` and -0.17 by the `DayOfMonth`, but there could be another important relationship. It looks like there are different clusters of prices corresponding to different pumpkin varieties. To confirm this hypothesis, let's plot each pumpkin category using a different color. By passing an `ax` parameter to the `scatter` プロット関数を使用してすべてのポイントを同じグラフにプロットできます：
```python
ax=None
colors = ['red','blue','green','yellow']
for i,var in enumerate(new_pumpkins['Variety'].unique()):
df = new_pumpkins[new_pumpkins['Variety']==var]
ax = df.plot.scatter('DayOfYear','Price',ax=ax,c=colors[i],label=var)
```
<img alt="年の中の日付と価格の散布図" src="images/scatter-dayofyear-color.png" width="50%" />
私たちの調査は、実際の販売日よりも品種が全体の価格に影響を与えることを示唆しています。これを棒グラフで確認できます：
```python
new_pumpkins.groupby('Variety')['Price'].mean().plot(kind='bar')
```
<img alt="品種ごとの価格の棒グラフ" src="images/price-by-variety.png" width="50%" />
今のところ、'パイタイプ'のかぼちゃ品種にのみ焦点を当て、日付が価格に与える影響を見てみましょう：
```python
pie_pumpkins = new_pumpkins[new_pumpkins['Variety']=='PIE TYPE']
pie_pumpkins.plot.scatter('DayOfYear','Price')
```
<img alt="年の中の日付と価格の散布図" src="images/pie-pumpkins-scatter.png" width="50%" />
`Price` and `DayOfYear` using `corr` function, we will get something like `-0.27` の相関を計算すると、予測モデルのトレーニングが意味を持つことがわかります。
> 線形回帰モデルをトレーニングする前に、データがクリーンであることを確認することが重要です。線形回帰は欠損値に対してうまく機能しないため、すべての空のセルを取り除くことが理にかなっています：
```python
pie_pumpkins.dropna(inplace=True)
pie_pumpkins.info()
```
もう一つのアプローチは、それらの空の値を対応する列の平均値で埋めることです。
## 単純な線形回帰
[![初心者向けML - Scikit-learnを使用した線形および多項式回帰](https://img.youtube.com/vi/e4c_UP2fSjg/0.jpg)](https://youtu.be/e4c_UP2fSjg "初心者向けML - Scikit-learnを使用した線形および多項式回帰")
> 🎥 上の画像をクリックすると、線形回帰と多項式回帰の概要を短いビデオで確認できます。
線形回帰モデルをトレーニングするために、**Scikit-learn**ライブラリを使用します。
```python
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
```
まず、入力値（特徴）と予想出力（ラベル）を別々のnumpy配列に分けます：
```python
X = pie_pumpkins['DayOfYear'].to_numpy().reshape(-1,1)
y = pie_pumpkins['Price']
```
> 入力データに`reshape`を実行する必要があることに注意してください。線形回帰は2D配列を入力として期待し、配列の各行が入力特徴のベクトルに対応します。私たちの場合、入力が1つしかないため、形状がN×1の配列が必要です。Nはデータセットのサイズです。
次に、データをトレーニングデータセットとテストデータセットに分割し、トレーニング後にモデルを検証できるようにします：
```python
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
最後に、実際の線形回帰モデルのトレーニングは2行のコードで行います。`LinearRegression` object, and fit it to our data using the `fit` メソッドを定義します：
```python
lin_reg = LinearRegression()
lin_reg.fit(X_train,y_train)
```
`LinearRegression` object after `fit`-ting contains all the coefficients of the regression, which can be accessed using `.coef_` property. In our case, there is just one coefficient, which should be around `-0.017`. It means that prices seem to drop a bit with time, but not too much, around 2 cents per day. We can also access the intersection point of the regression with Y-axis using `lin_reg.intercept_` - it will be around `21` が示しているように、年の初めの価格を示しています。
モデルの精度を確認するために、テストデータセットで価格を予測し、予測値と期待値の違いを測定します。これは、期待値と予測値のすべての二乗誤差の平均である平均二乗誤差（MSE）を使用して行うことができます。
```python
pred = lin_reg.predict(X_test)
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
```
誤差は約2ポイントで、約17％です。あまり良くありません。モデルの品質のもう一つの指標は**決定係数**であり、次のように取得できます：
```python
score = lin_reg.score(X_train,y_train)
print('Model determination: ', score)
```
値が0の場合、モデルは入力データを考慮せず、*最悪の線形予測器*として機能し、単に結果の平均値を示します。値が1の場合、すべての期待出力を完全に予測できることを意味します。私たちの場合、決定係数は約0.06で、かなり低いです。
テストデータと回帰ラインを一緒にプロットして、回帰がどのように機能するかをよりよく見ることができます：
```python
plt.scatter(X_test,y_test)
plt.plot(X_test,pred)
```
<img alt="線形回帰" src="images/linear-results.png" width="50%" />
## 多項式回帰
もう一つの線形回帰のタイプは多項式回帰です。変数間に線形関係がある場合がありますが、例えば、かぼちゃの体積が大きいほど価格が高くなる場合がありますが、これらの関係は平面や直線としてプロットできないことがあります。
✅ ここに[いくつかの例](https://online.stat.psu.edu/stat501/lesson/9/9.8)があります。多項式回帰を使用できるデータの例です。
日付と価格の関係をもう一度見てみましょう。この散布図は直線で分析すべきだと思いますか？価格は変動する可能性がありますか？この場合、多項式回帰を試すことができます。
✅ 多項式は、1つ以上の変数と係数で構成される数学的表現です。
多項式回帰は、非線形データにより適合する曲線を作成します。私たちの場合、入力データに`DayOfYear`の二乗変数を含めると、年のある時点で最小値を持つ放物線をフィットさせることができます。
Scikit-learnには、データ処理の異なるステップを組み合わせるための便利な[パイプラインAPI](https://scikit-learn.org/stable/modules/generated/sklearn.pipeline.make_pipeline.html?highlight=pipeline#sklearn.pipeline.make_pipeline)が含まれています。**パイプライン**は、**推定器**のチェーンです。私たちの場合、まずモデルに多項式特徴を追加し、その後回帰をトレーニングするパイプラインを作成します：
```python
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
```
`PolynomialFeatures(2)` means that we will include all second-degree polynomials from the input data. In our case it will just mean `DayOfYear`<sup>2</sup>, but given two input variables X and Y, this will add X<sup>2</sup>, XY and Y<sup>2</sup>. We may also use higher degree polynomials if we want.
Pipelines can be used in the same manner as the original `LinearRegression` object, i.e. we can `fit` the pipeline, and then use `predict` to get the prediction results. Here is the graph showing test data, and the approximation curve:
<img alt="Polynomial regression" src="images/poly-results.png" width="50%" />
Using Polynomial Regression, we can get slightly lower MSE and higher determination, but not significantly. We need to take into account other features!
> You can see that the minimal pumpkin prices are observed somewhere around Halloween. How can you explain this?
🎃 Congratulations, you just created a model that can help predict the price of pie pumpkins. You can probably repeat the same procedure for all pumpkin types, but that would be tedious. Let's learn now how to take pumpkin variety into account in our model!
## Categorical Features
In the ideal world, we want to be able to predict prices for different pumpkin varieties using the same model. However, the `Variety` column is somewhat different from columns like `Month`, because it contains non-numeric values. Such columns are called **categorical**.
[![ML for beginners - Categorical Feature Predictions with Linear Regression](https://img.youtube.com/vi/DYGliioIAE0/0.jpg)](https://youtu.be/DYGliioIAE0 "ML for beginners - Categorical Feature Predictions with Linear Regression")
> 🎥 Click the image above for a short video overview of using categorical features.
Here you can see how average price depends on variety:
<img alt="Average price by variety" src="images/price-by-variety.png" width="50%" />
To take variety into account, we first need to convert it to numeric form, or **encode** it. There are several way we can do it:
* Simple **numeric encoding** will build a table of different varieties, and then replace the variety name by an index in that table. This is not the best idea for linear regression, because linear regression takes the actual numeric value of the index, and adds it to the result, multiplying by some coefficient. In our case, the relationship between the index number and the price is clearly non-linear, even if we make sure that indices are ordered in some specific way.
* **One-hot encoding** will replace the `Variety` column by 4 different columns, one for each variety. Each column will contain `1` if the corresponding row is of a given variety, and `0` ということになります。つまり、線形回帰には4つの係数があり、各かぼちゃ品種ごとに1つの係数があり、その品種の「開始価格」（または「追加価格」）を表します。
以下のコードは、品種をワンホットエンコードする方法を示しています：
```python
pd.get_dummies(new_pumpkins['Variety'])
```
ID | FAIRYTALE | MINIATURE | MIXED HEIRLOOM VARIETIES | PIE TYPE
----|-----------|-----------|--------------------------|----------
70 | 0 | 0 | 0 | 1
71 | 0 | 0 | 0 | 1
... | ... | ... | ... | ...
1738 | 0 | 1 | 0 | 0
1739 | 0 | 1 | 0 | 0
1740 | 0 | 1 | 0 | 0
1741 | 0 | 1 | 0 | 0
1742 | 0 | 1 | 0 | 0
ワンホットエンコードされた品種を使用して線形回帰をトレーニングするには、`X` and `y`データを正しく初期化するだけです：
```python
X = pd.get_dummies(new_pumpkins['Variety'])
y = new_pumpkins['Price']
```
他のコードは、上記で使用した線形回帰をトレーニングするためのコードと同じです。試してみると、平均二乗誤差はほぼ同じですが、決定係数が大幅に高くなります（約77％）。さらに正確な予測を行うために、より多くのカテゴリカル特徴や数値的特徴（例えば`Month` or `DayOfYear`. To get one large array of features, we can use `join`）を考慮することができます：
```python
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
```
ここでは、`City` and `Package`タイプも考慮しており、MSEは2.84（10％）、決定係数は0.94です！
## すべてをまとめる
最良のモデルを作成するために、上記の例からの結合データ（ワンホットエンコードされたカテゴリカルデータ＋数値データ）と多項式回帰を使用します。ここに完全なコードがあります：
```python
# set up training data
X = pd.get_dummies(new_pumpkins['Variety']) \
.join(new_pumpkins['Month']) \
.join(pd.get_dummies(new_pumpkins['City'])) \
.join(pd.get_dummies(new_pumpkins['Package']))
y = new_pumpkins['Price']
# make train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# setup and train the pipeline
pipeline = make_pipeline(PolynomialFeatures(2), LinearRegression())
pipeline.fit(X_train,y_train)
# predict results for test data
pred = pipeline.predict(X_test)
# calculate MSE and determination
mse = np.sqrt(mean_squared_error(y_test,pred))
print(f'Mean error: {mse:3.3} ({mse/np.mean(pred)*100:3.3}%)')
score = pipeline.score(X_train,y_train)
print('Model determination: ', score)
```
これにより、決定係数がほぼ97％、MSE=2.23（約8％の予測誤差）となります。
| モデル | MSE | 決定係数 |
|-------|-----|---------------|
| `DayOfYear` Linear | 2.77 (17.2%) | 0.07 |
| `DayOfYear` Polynomial | 2.73 (17.0%) | 0.08 |
| `Variety` 線形 | 5.24 (19.7%) | 0.77 |
| すべての特徴 線形 | 2.84 (10.5%) | 0.94 |
| すべての特徴 多項式 | 2.23 (8.25%) | 0.97 |
🏆 よくできました！1つのレッスンで4つの回帰モデルを作成し、モデルの品質を97％に向上させました。回帰の最終セクションでは、ロジスティック回帰について学び、カテゴリを
**免責事項**:
この文書は機械翻訳サービスを使用して翻訳されています。正確さを期すよう努めていますが、自動翻訳には誤りや不正確さが含まれる場合があります。原文の言語による文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤認について、当社は一切の責任を負いません。

14
translations/ja/2-Regression/3-Linear/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# 回帰モデルの作成
## 手順
このレッスンでは、線形回帰と多項式回帰の両方を使用してモデルを構築する方法が示されました。この知識を活用して、データセットを見つけるか、Scikit-learn の組み込みセットのいずれかを使用して新しいモデルを構築してください。ノートブックで、なぜその手法を選んだのかを説明し、モデルの精度を実証してください。もし精度が低い場合は、その理由を説明してください。
## ルーブリック
| 基準 | 模範的な | 適切な | 改善が必要な |
| --------- | ------------------------------------------------------------ | -------------------------- | ------------------------------ |
| | 完全にドキュメント化された解決策を含む完全なノートブックを提示する | 解決策が不完全である | 解決策に欠陥やバグがある |
**免責事項**:
この文書は、機械翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語で書かれた原文を公式な情報源と見なしてください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解については、一切の責任を負いかねます。

4
translations/ja/2-Regression/3-Linear/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご了承ください。原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用により生じた誤解や誤った解釈について、当方は責任を負いません。

328
translations/ja/2-Regression/4-Logistic/README.md
Unescape View File

@ -1,328 +0,0 @@
# カテゴリー予測のためのロジスティック回帰
![ロジスティック回帰と線形回帰のインフォグラフィック](../../../../translated_images/linear-vs-logistic.ba180bf95e7ee66721ba10ebf2dac2666acbd64a88b003c83928712433a13c7d.ja.png)
## [講義前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/15/)
> ### [このレッスンはRでも利用可能です！](../../../../2-Regression/4-Logistic/solution/R/lesson_4.html)
## はじめに
この回帰に関する最終レッスンでは、基本的な _クラシック_ な機械学習技術の一つであるロジスティック回帰について見ていきます。この技術を使用して、二値のカテゴリーを予測するパターンを発見することができます。このキャンディーはチョコレートかどうか？この病気は伝染するかどうか？この顧客はこの製品を選ぶかどうか？
このレッスンで学ぶこと：
- データビジュアライゼーションのための新しいライブラリ
- ロジスティック回帰の技術
✅ このタイプの回帰を扱う理解を深めるために、この [Learnモジュール](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-77952-leestott) を参照してください。
## 前提条件
パンプキンデータを扱ってきたので、二値のカテゴリーが一つあることに気づくことができました：`Color`。
いくつかの変数を与えられた場合に、_特定のカボチャの色がオレンジ 🎃 か白 👻 かを予測する_ ロジスティック回帰モデルを構築しましょう。
> なぜ回帰に関するレッスンで二値分類について話しているのか？それは言語的な便宜のためであり、ロジスティック回帰は [実際には分類方法](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression) ですが、線形に基づいているためです。次のレッスングループでは、データを分類する他の方法について学びます。
## 質問を定義する
私たちの目的のために、これを「白」または「白ではない」として表現します。データセットには「ストライプ」カテゴリもありますが、インスタンスが少ないため使用しません。データセットからnull値を削除すると、いずれにせよ消えます。
> 🎃 面白い事実：白いカボチャを「ゴーストカボチャ」と呼ぶことがあります。彫るのが難しいので、オレンジのカボチャほど人気はありませんが、見た目はクールです！したがって、質問を「ゴースト」または「ゴーストではない」と再定義することもできます。👻
## ロジスティック回帰について
ロジスティック回帰は、以前に学んだ線形回帰とはいくつかの重要な点で異なります。
[![ML初心者向け - 機械学習分類のためのロジスティック回帰の理解](https://img.youtube.com/vi/KpeCT6nEpBY/0.jpg)](https://youtu.be/KpeCT6nEpBY "ML初心者向け - 機械学習分類のためのロジスティック回帰の理解")
> 🎥 上の画像をクリックして、ロジスティック回帰の概要を短いビデオで確認してください。
### 二値分類
ロジスティック回帰は、線形回帰と同じ機能を提供しません。前者は二値のカテゴリー（「白か白ではない」）についての予測を提供しますが、後者は連続的な値を予測することができます。たとえば、カボチャの産地と収穫時期を考慮して、_その価格がどの程度上昇するか_ を予測できます。
![カボチャ分類モデル](../../../../translated_images/pumpkin-classifier.562771f104ad5436b87d1c67bca02a42a17841133556559325c0a0e348e5b774.ja.png)
> インフォグラフィック by [Dasani Madipalli](https://twitter.com/dasani_decoded)
### 他の分類
ロジスティック回帰には、他にも多項式や順序などの種類があります：
- **多項式**：複数のカテゴリを持つもの - 「オレンジ、白、ストライプ」。
- **順序**：順序付けられたカテゴリを持つもの。たとえば、カボチャのサイズ（ミニ、小、中、大、XL、XXL）で順序付ける場合など。
![多項式回帰と順序回帰](../../../../translated_images/multinomial-vs-ordinal.36701b4850e37d86c9dd49f7bef93a2f94dbdb8fe03443eb68f0542f97f28f29.ja.png)
### 変数が相関している必要はない
線形回帰がより相関のある変数でうまく機能することを覚えていますか？ロジスティック回帰はその逆で、変数が一致する必要はありません。このデータには、やや弱い相関がありますが、それでも機能します。
### たくさんのクリーンなデータが必要
ロジスティック回帰は、データが多いほど正確な結果をもたらします。私たちの小さなデータセットはこのタスクには最適ではないので、それを念頭に置いてください。
[![ML初心者向け - ロジスティック回帰のためのデータ分析と準備](https://img.youtube.com/vi/B2X4H9vcXTs/0.jpg)](https://youtu.be/B2X4H9vcXTs "ML初心者向け - ロジスティック回帰のためのデータ分析と準備")
> 🎥 上の画像をクリックして、線形回帰のためのデータ準備の概要を短いビデオで確認してください。
✅ ロジスティック回帰に適したデータの種類について考えてみてください。
## 演習 - データの整頓
まず、データを少しクリーンにし、null値を削除し、いくつかの列のみを選択します：
1. 以下のコードを追加します：
```python
columns_to_select = ['City Name','Package','Variety', 'Origin','Item Size', 'Color']
pumpkins = full_pumpkins.loc[:, columns_to_select]
pumpkins.dropna(inplace=True)
```
新しいデータフレームを覗いてみることもできます：
```python
pumpkins.info
```
### ビジュアライゼーション - カテゴリカルプロット
これまでに、パンプキンデータを再度読み込み、いくつかの変数を含むデータセットを保持するようにクリーニングした [スターターノートブック](../../../../2-Regression/4-Logistic/notebook.ipynb) をロードしました。ノートブックでデータフレームを新しいライブラリを使ってビジュアライズしましょう：[Seaborn](https://seaborn.pydata.org/index.html) は、以前使用したMatplotlibの上に構築されています。
Seabornはデータをビジュアライズするための便利な方法を提供します。たとえば、`Variety`と`Color`のデータの分布をカテゴリカルプロットで比較することができます。
1. `catplot` function, using our pumpkin data `pumpkins` を使用して、各カボチャカテゴリ（オレンジまたは白）の色マッピングを指定して、プロットを作成します：
```python
import seaborn as sns
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
sns.catplot(
data=pumpkins, y="Variety", hue="Color", kind="count",
palette=palette,
)
```
![ビジュアライズされたデータのグリッド](../../../../translated_images/pumpkins_catplot_1.c55c409b71fea2ecc01921e64b91970542101f90bcccfa4aa3a205db8936f48b.ja.png)
データを観察することで、色データがVarietyにどのように関連しているかがわかります。
✅ このカテゴリカルプロットを見て、どのような興味深い探索ができるか考えてみてください。
### データ前処理：特徴とラベルのエンコーディング
私たちのカボチャデータセットには、すべての列に文字列値が含まれています。カテゴリカルデータを扱うことは人間にとっては直感的ですが、機械にはそうではありません。機械学習アルゴリズムは数値でうまく機能します。そのため、エンコーディングはデータ前処理フェーズで非常に重要なステップです。これにより、カテゴリカルデータを数値データに変換することができ、情報を失うことなく行えます。良いエンコーディングは良いモデルの構築につながります。
特徴エンコーディングには2つの主要なエンコーダーがあります：
1. 順序エンコーダー：これは順序変数に適しています。順序変数は、データが論理的な順序に従うカテゴリカル変数です。私たちのデータセットの`Item Size`列のようなものです。各カテゴリを数値で表し、その列の順序に従ってマッピングを作成します。
```python
from sklearn.preprocessing import OrdinalEncoder
item_size_categories = [['sml', 'med', 'med-lge', 'lge', 'xlge', 'jbo', 'exjbo']]
ordinal_features = ['Item Size']
ordinal_encoder = OrdinalEncoder(categories=item_size_categories)
```
2. カテゴリカルエンコーダー：これは名義変数に適しています。名義変数は、データが論理的な順序に従わないカテゴリカル変数です。データセットの`Item Size`以外のすべての特徴がこれに該当します。これはワンホットエンコーディングであり、各カテゴリをバイナリ列で表します。エンコードされた変数が1の場合、そのカボチャがそのVarietyに属し、0の場合はそうではありません。
```python
from sklearn.preprocessing import OneHotEncoder
categorical_features = ['City Name', 'Package', 'Variety', 'Origin']
categorical_encoder = OneHotEncoder(sparse_output=False)
```
その後、`ColumnTransformer`を使用して、複数のエンコーダーを1つのステップに組み合わせて適切な列に適用します。
```python
from sklearn.compose import ColumnTransformer
ct = ColumnTransformer(transformers=[
('ord', ordinal_encoder, ordinal_features),
('cat', categorical_encoder, categorical_features)
])
ct.set_output(transform='pandas')
encoded_features = ct.fit_transform(pumpkins)
```
一方、ラベルをエンコードするために、scikit-learnの`LabelEncoder`クラスを使用します。これは、ラベルを0からn_classes-1（ここでは0と1）の間の値のみを含むように正規化するユーティリティクラスです。
```python
from sklearn.preprocessing import LabelEncoder
label_encoder = LabelEncoder()
encoded_label = label_encoder.fit_transform(pumpkins['Color'])
```
特徴とラベルをエンコードしたら、新しいデータフレーム`encoded_pumpkins`にマージできます。
```python
encoded_pumpkins = encoded_features.assign(Color=encoded_label)
```
✅ 順序エンコーダーを`Item Size` column?
### Analyse relationships between variables
Now that we have pre-processed our data, we can analyse the relationships between the features and the label to grasp an idea of how well the model will be able to predict the label given the features.
The best way to perform this kind of analysis is plotting the data. We'll be using again the Seaborn `catplot` function, to visualize the relationships between `Item Size`, `Variety`および`Color`にカテゴリカルプロットで使用する利点は何ですか？データをよりよくプロットするために、エンコードされた`Item Size` column and the unencoded `Variety`列を使用します。
```python
palette = {
'ORANGE': 'orange',
'WHITE': 'wheat',
}
pumpkins['Item Size'] = encoded_pumpkins['ord__Item Size']
g = sns.catplot(
data=pumpkins,
x="Item Size", y="Color", row='Variety',
kind="box", orient="h",
sharex=False, margin_titles=True,
height=1.8, aspect=4, palette=palette,
)
g.set(xlabel="Item Size", ylabel="").set(xlim=(0,6))
g.set_titles(row_template="{row_name}")
```
![ビジュアライズされたデータのカテゴリカルプロット](../../../../translated_images/pumpkins_catplot_2.87a354447880b3889278155957f8f60dd63db4598de5a6d0fda91c334d31f9f1.ja.png)
### スウォームプロットを使用する
色は二値のカテゴリ（白か白ではない）であるため、ビジュアライゼーションには「[特化したアプローチ](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar)」が必要です。このカテゴリと他の変数の関係をビジュアライズする他の方法もあります。
Seabornプロットを使用して変数を並べて視覚化することができます。
1. 値の分布を示すために「スウォーム」プロットを試してみてください：
```python
palette = {
0: 'orange',
1: 'wheat'
}
sns.swarmplot(x="Color", y="ord__Item Size", data=encoded_pumpkins, palette=palette)
```
![ビジュアライズされたデータのスウォーム](../../../../translated_images/swarm_2.efeacfca536c2b577dc7b5f8891f28926663fbf62d893ab5e1278ae734ca104e.ja.png)
**注意**：上記のコードは警告を生成する可能性があります。これはSeabornがスウォームプロットに多くのデータポイントを表示するのに失敗するためです。解決策として、マーカーのサイズを「size」パラメーターを使用して小さくすることが考えられます。ただし、これによりプロットの可読性が影響を受ける可能性があることに注意してください。
> **🧮 数学を見せて**
>
> ロジスティック回帰は「最大尤度」の概念に依存しており、[シグモイド関数](https://wikipedia.org/wiki/Sigmoid_function)を使用します。プロット上の「シグモイド関数」は「S」字型に見えます。これは値を取り、それを0から1の間のどこかにマッピングします。この曲線は「ロジスティック曲線」とも呼ばれます。その公式は次のようになります：
>
> ![ロジスティック関数](../../../../translated_images/sigmoid.8b7ba9d095c789cf72780675d0d1d44980c3736617329abfc392dfc859799704.ja.png)
>
> ここで、シグモイドの中点はxの0点にあり、Lは曲線の最大値、kは曲線の急峻さです。関数の結果が0.5を超える場合、そのラベルは二値選択の「1」として分類されます。それ以外の場合は「0」として分類されます。
## モデルを構築する
Scikit-learnでこの二値分類を見つけるモデルを構築するのは驚くほど簡単です。
[![ML初心者向け - データの分類のためのロジスティック回帰](https://img.youtube.com/vi/MmZS2otPrQ8/0.jpg)](https://youtu.be/MmZS2otPrQ8 "ML初心者向け - データの分類のためのロジスティック回帰")
> 🎥 上の画像をクリックして、線形回帰モデルの構築についての短いビデオを確認してください。
1. 分類モデルで使用する変数を選択し、`train_test_split()`を呼び出してトレーニングセットとテストセットに分割します：
```python
from sklearn.model_selection import train_test_split
X = encoded_pumpkins[encoded_pumpkins.columns.difference(['Color'])]
y = encoded_pumpkins['Color']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
2. 次に、トレーニングデータを使用してモデルをトレーニングし、結果を出力します：
```python
from sklearn.metrics import f1_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('F1-score: ', f1_score(y_test, predictions))
```
モデルのスコアボードを見てみましょう。約1000行のデータしかないことを考えると、悪くないです：
```output
precision recall f1-score support
0 0.94 0.98 0.96 166
1 0.85 0.67 0.75 33
accuracy 0.92 199
macro avg 0.89 0.82 0.85 199
weighted avg 0.92 0.92 0.92 199
Predicted labels: [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0
0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 1 0 0 0 0 0 0 0 0 1 1]
F1-score: 0.7457627118644068
```
## 混同行列による理解の向上
上記の項目を印刷してスコアボードレポートを取得することもできますが、[混同行列](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix)を使用してモデルのパフォーマンスを理解する方が簡単かもしれません。
> 🎓 「[混同行列](https://wikipedia.org/wiki/Confusion_matrix)」または「エラーマトリックス」は、モデルの真陽性と偽陽性、および真陰性と偽陰性を表現する表であり、予測の正確性を測定します。
1. 混同行列を使用するには、`confusion_matrix()`を呼び出します：
```python
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, predictions)
```
モデルの混同行列を見てみましょう：
```output
array([[162, 4],
[ 11, 22]])
```
Scikit-learnの混同行列では、行（軸0）は実際のラベルであり、列（軸1）は予測されたラベルです。
| | 0 | 1 |
| :---: | :---: | :---: |
| 0 | TN | FP |
| 1 | FN | TP |
ここで何が起こっているのでしょうか？たとえば、モデルがカボチャを「白」と「白ではない」という二値カテゴリに分類するとしましょう。
- モデルがカボチャを「白ではない」と予測し、実際に「白ではない」カテゴリに属する場合、これを真陰性（TN）と呼びます。これは左上の数字で示されます。
- モデルがカボチャを「白」と予測し、実際に「白ではない」カテゴリに属する場合、これを偽陰性（FN）と呼びます。これは左下の数字で示されます。
- モデルがカボチャを「白ではない」と予測し、実際に「白」カテゴリに属する場合、これを偽陽性（FP）と呼びます。これは右上の数字で示されます。
- モデルがカボチャを「白」と予測し、実際に「白」カテゴリに属する場合、これを真陽性（TP）と呼びます。これは右下の数字で示されます。
予想通り、真陽性と真陰性の数が多く、偽陽性と偽陰性の数が少ない方が、モデルのパフォーマンスが優れていることを示します。
混同行列が精度と再現率にどのように関連しているかを見てみましょう。前述の分類レポートには精度（0.85）と再現率（0.67）が表示されました。
精度 = tp / (tp + fp) = 22 / (22 + 4) = 0.8461538461538461
再現率 = tp / (tp + fn) = 22 / (22 + 11) = 0.6666666666666666
✅ Q: 混同行列によると、モデルはどうでしたか？ A: 悪くないです。真陰性の数が多いですが、偽陰性もいくつかあります。
混同行列のTP/TNとFP/FNのマッピングを使用して、先ほど見た用語を再確認しましょう：
🎓 精度：TP/(TP + FP)
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる場合がありますのでご注意ください。原文の言語による元の文書を信頼できる情報源とみなすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

14
translations/ja/2-Regression/4-Logistic/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# 回帰の再試行
## 手順
このレッスンでは、かぼちゃデータの一部を使用しました。今度は、元のデータに戻り、すべてのデータをクリーンアップして標準化し、ロジスティック回帰モデルを構築してみましょう。
## 評価基準
| 基準 | 優秀 | 適切 | 改善の余地あり |
| -------- | -------------------------------------------------------------------- | ------------------------------------------------------- | -------------------------------------------------------- |
| | よく説明され、パフォーマンスの良いモデルを持つノートブックが提出される | 最低限のパフォーマンスを持つモデルを持つノートブックが提出される | パフォーマンスの低いモデル、またはモデルがないノートブックが提出される |
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語で記載された原文を信頼できる情報源と見なしてください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤った解釈については責任を負いかねます。

4
translations/ja/2-Regression/4-Logistic/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**：
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳にはエラーや不正確さが含まれる場合があります。元の言語で記載された原文を信頼できる情報源と見なしてください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用によって生じたいかなる誤解や誤訳についても、当社は責任を負いません。

43
translations/ja/2-Regression/README.md
Unescape View File

@ -1,43 +0,0 @@
# 機械学習のための回帰モデル
## 地域トピック: 北米のカボチャ価格に対する回帰モデル 🎃
北米では、ハロウィンのためにカボチャがよく怖い顔に彫られます。この魅力的な野菜についてもっと発見してみましょう！
![ジャック・オー・ランタン](../../../translated_images/jack-o-lanterns.181c661a9212457d7756f37219f660f1358af27554d856e5a991f16b4e15337c.ja.jpg)
> 写真提供: <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> on <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## 学ぶこと
[![回帰の紹介](https://img.youtube.com/vi/5QnJtDad4iQ/0.jpg)](https://youtu.be/5QnJtDad4iQ "回帰紹介ビデオ - クリックして視聴！")
> 🎥 上の画像をクリックして、このレッスンの簡単な紹介ビデオを視聴してください
このセクションのレッスンでは、機械学習の文脈での回帰の種類について説明します。回帰モデルは、変数間の_関係_を決定するのに役立ちます。このタイプのモデルは、長さ、温度、年齢などの値を予測することができ、データポイントを分析することで変数間の関係を明らかにします。
この一連のレッスンでは、線形回帰とロジスティック回帰の違いを発見し、どちらを選ぶべきかを学びます。
[![初心者向け機械学習 - 回帰モデルの紹介](https://img.youtube.com/vi/XA3OaoW86R8/0.jpg)](https://youtu.be/XA3OaoW86R8 "初心者向け機械学習 - 回帰モデルの紹介")
> 🎥 上の画像をクリックして、回帰モデルの紹介ビデオを視聴してください
この一連のレッスンでは、機械学習のタスクを開始するための準備を行います。これには、データサイエンティストの共通の環境であるノートブックを管理するためのVisual Studio Codeの設定が含まれます。Scikit-learnという機械学習のライブラリを発見し、この章では回帰モデルに焦点を当てて最初のモデルを構築します。
> 回帰モデルの操作について学ぶのに役立つローコードツールがあります。このタスクには [Azure ML](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott) を試してみてください。
### レッスン
1. [ツールの紹介](1-Tools/README.md)
2. [データの管理](2-Data/README.md)
3. [線形および多項式回帰](3-Linear/README.md)
4. [ロジスティック回帰](4-Logistic/README.md)
---
### クレジット
「回帰を用いた機械学習」は [Jen Looper](https://twitter.com/jenlooper) によって♥️を込めて書かれました。
♥️ クイズの貢献者には [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) と [Ornella Altunyan](https://twitter.com/ornelladotcom) が含まれます。
カボチャのデータセットは [このKaggleプロジェクト](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) によって提案され、そのデータはアメリカ合衆国農務省が配布する [Specialty Crops Terminal Markets Standard Reports](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) に由来しています。品種に基づく色に関するポイントを追加して分布を正規化しました。このデータはパブリックドメインです。
**免責事項**：
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すよう努めていますが、自動翻訳には誤りや不正確さが含まれる場合がありますのでご注意ください。原文の言語によるオリジナル文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

348
translations/ja/3-Web-App/1-Web-App/README.md
Unescape View File

@ -1,348 +0,0 @@
# MLモデルを使用するWebアプリを構築する
このレッスンでは、NUFORCのデータベースから取得した「過去1世紀のUFO目撃情報」という、まさに非現実的なデータセットでMLモデルを訓練します。
あなたが学ぶこと:
- 訓練されたモデルを「ピクル」する方法
- Flaskアプリでそのモデルを使用する方法
データをクリーンアップし、モデルを訓練するためにノートブックを引き続き使用しますが、プロセスを一歩進めて、いわば「野生で」モデルを使用する方法を探求します：それはWebアプリの中でのことです。
これを実現するために、Flaskを使用してWebアプリを構築する必要があります。
## [講義前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/17/)
## アプリの構築
機械学習モデルを消費するためのWebアプリを構築する方法はいくつかあります。あなたのWebアーキテクチャは、モデルがどのように訓練されるかに影響を与えるかもしれません。データサイエンスグループが訓練したモデルをアプリで使用したいビジネスで働いていると想像してください。
### 考慮事項
考慮すべき多くの質問があります：
- **Webアプリですか、それともモバイルアプリですか？** モバイルアプリを構築している場合や、IoTのコンテキストでモデルを使用する必要がある場合は、[TensorFlow Lite](https://www.tensorflow.org/lite/)を使用して、AndroidまたはiOSアプリでモデルを使用できます。
- **モデルはどこに配置されますか？** クラウド上かローカルか？
- **オフラインサポート。** アプリはオフラインで動作する必要がありますか？
- **モデルを訓練するために使用された技術は何ですか？** 選択した技術は、使用するツールに影響を与えるかもしれません。
- **TensorFlowを使用する。** 例えば、TensorFlowを使用してモデルを訓練している場合、そのエコシステムは[TensorFlow.js](https://www.tensorflow.org/js/)を使用してWebアプリで利用するためにTensorFlowモデルを変換する機能を提供します。
- **PyTorchを使用する。** [PyTorch](https://pytorch.org/)のようなライブラリを使用してモデルを構築している場合、JavaScriptのWebアプリで使用できる[ONNX](https://onnx.ai/)（Open Neural Network Exchange）形式でエクスポートするオプションがあります。このオプションは、Scikit-learnで訓練されたモデルの将来のレッスンで探求されます。
- **Lobe.aiまたはAzure Custom Visionを使用する。** [Lobe.ai](https://lobe.ai/)や[Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-77952-leestott)のようなML SaaS（Software as a Service）システムを使用してモデルを訓練している場合、この種のソフトウェアは、オンラインアプリケーションからクラウドでクエリされるカスタムAPIを構築するなど、多くのプラットフォーム向けにモデルをエクスポートする方法を提供します。
また、ブラウザでモデルを自ら訓練できる完全なFlask Webアプリを構築する機会もあります。これもJavaScriptコンテキストでTensorFlow.jsを使用して実現できます。
私たちの目的のために、Pythonベースのノートブックを使用しているので、そのようなノートブックから訓練されたモデルをPythonで構築されたWebアプリが読み取れる形式にエクスポートする手順を探ってみましょう。
## ツール
このタスクには2つのツールが必要です：FlaskとPickle、どちらもPythonで動作します。
✅ [Flask](https://palletsprojects.com/p/flask/)とは何ですか？ Flaskはその作成者によって「マイクロフレームワーク」と定義されており、Pythonを使用してWebページを構築するための基本機能を提供します。Flaskでの構築を練習するために、[このLearnモジュール](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-77952-leestott)を見てみてください。
✅ [Pickle](https://docs.python.org/3/library/pickle.html)とは何ですか？ Pickle 🥒はPythonオブジェクト構造をシリアライズおよびデシリアライズするPythonモジュールです。モデルを「ピクル」すると、Webで使用するためにその構造をシリアライズまたはフラット化します。注意してください：pickleは本質的に安全ではないため、ファイルを「アンピクル」するように求められた場合は注意してください。ピクルされたファイルには接尾辞`.pkl`があります。
## 演習 - データをクリーンアップする
このレッスンでは、[NUFORC](https://nuforc.org)（全米UFO報告センター）が収集した80,000件のUFO目撃データを使用します。このデータには、UFO目撃の興味深い説明が含まれています。例えば：
- **長い例の説明。** 「光のビームから男が現れ、夜の草原に照らされ、テキサス・インスツルメンツの駐車場に向かって走る」。
- **短い例の説明。** 「光が私たちを追いかけてきた」。
[ufos.csv](../../../../3-Web-App/1-Web-App/data/ufos.csv)スプレッドシートには、目撃が発生した`city`、`state`、`country`に関する列、オブジェクトの`shape`、およびその`latitude`と`longitude`が含まれています。
このレッスンに含まれる空の[ノートブック](../../../../3-Web-App/1-Web-App/notebook.ipynb)で：
1. 前のレッスンで行ったように`pandas`、`matplotlib`、`numpy`をインポートし、ufosスプレッドシートをインポートします。サンプルデータセットを確認できます：
```python
import pandas as pd
import numpy as np
ufos = pd.read_csv('./data/ufos.csv')
ufos.head()
```
1. ufosデータを新しいタイトルの小さなデータフレームに変換します。`Country`フィールドのユニークな値を確認します。
```python
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
ufos.Country.unique()
```
1. 次に、null値を削除し、1〜60秒の間の目撃情報のみをインポートすることで、処理するデータの量を減らすことができます：
```python
ufos.dropna(inplace=True)
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
ufos.info()
```
1. Scikit-learnの`LabelEncoder`ライブラリをインポートして、国のテキスト値を数値に変換します：
✅ LabelEncoderはデータをアルファベット順にエンコードします
```python
from sklearn.preprocessing import LabelEncoder
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
ufos.head()
```
あなたのデータは次のようになります：
```output
Seconds Country Latitude Longitude
2 20.0 3 53.200000 -2.916667
3 20.0 4 28.978333 -96.645833
14 30.0 4 35.823889 -80.253611
23 60.0 4 45.582778 -122.352222
24 3.0 3 51.783333 -0.783333
```
## 演習 - モデルを構築する
データを訓練グループとテストグループに分割して、モデルを訓練する準備が整いました。
1. 訓練に使用する3つの特徴をXベクトルとして選択し、yベクトルは`Country`. You want to be able to input `Seconds`, `Latitude` and `Longitude`で、国のIDを返します。
```python
from sklearn.model_selection import train_test_split
Selected_features = ['Seconds','Latitude','Longitude']
X = ufos[Selected_features]
y = ufos['Country']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
```
1. ロジスティック回帰を使用してモデルを訓練します：
```python
from sklearn.metrics import accuracy_score, classification_report
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
predictions = model.predict(X_test)
print(classification_report(y_test, predictions))
print('Predicted labels: ', predictions)
print('Accuracy: ', accuracy_score(y_test, predictions))
```
精度は悪くありません **（約95%）**、予想通り、`Country` and `Latitude/Longitude` correlate.
The model you created isn't very revolutionary as you should be able to infer a `Country` from its `Latitude` and `Longitude`ですが、クリーンアップし、エクスポートした生データから訓練し、このモデルをWebアプリで使用することを試みるのは良い練習です。
## 演習 - モデルを「ピクル」する
さて、モデルを_ピクル_する時が来ました！ いくつかの行のコードでそれを行うことができます。一度_ピクル_したら、ピクルされたモデルを読み込み、秒、緯度、経度の値を含むサンプルデータ配列に対してテストします。
```python
import pickle
model_filename = 'ufo-model.pkl'
pickle.dump(model, open(model_filename,'wb'))
model = pickle.load(open('ufo-model.pkl','rb'))
print(model.predict([[50,44,-12]]))
```
モデルは**「3」**を返します。これは、イギリスの国コードです。すごい！ 👽
## 演習 - Flaskアプリを構築する
次に、モデルを呼び出して似たような結果を返すFlaskアプリを構築できますが、より視覚的に魅力的な方法で。
1. _ufo-model.pkl_ファイルが存在する_notebook.ipynb_ファイルの隣に**web-app**という名前のフォルダを作成します。
1. そのフォルダ内に、**static**というフォルダとその中に**css**フォルダ、さらに**templates**というフォルダを作成します。これで、次のファイルとディレクトリが揃っているはずです：
```output
web-app/
static/
css/
templates/
notebook.ipynb
ufo-model.pkl
```
✅ 完成したアプリのビューについては、ソリューションフォルダを参照してください。
1. _web-app_フォルダで最初に作成するファイルは**requirements.txt**ファイルです。JavaScriptアプリの_package.json_のように、このファイルにはアプリに必要な依存関係がリストされています。**requirements.txt**に次の行を追加します：
```text
scikit-learn
pandas
numpy
flask
```
1. 次に、このファイルを実行するために_web-app_に移動します：
```bash
cd web-app
```
1. ターミナルに`pip install`と入力し、_requirements.txt_にリストされたライブラリをインストールします：
```bash
pip install -r requirements.txt
```
1. これで、アプリを完成させるためにさらに3つのファイルを作成する準備が整いました：
1. ルートに**app.py**を作成します。
2. _templates_ディレクトリに**index.html**を作成します。
3. _static/css_ディレクトリに**styles.css**を作成します。
1. _styles.css_ファイルにいくつかのスタイルを追加します：
```css
body {
width: 100%;
height: 100%;
font-family: 'Helvetica';
background: black;
color: #fff;
text-align: center;
letter-spacing: 1.4px;
font-size: 30px;
}
input {
min-width: 150px;
}
.grid {
width: 300px;
border: 1px solid #2d2d2d;
display: grid;
justify-content: center;
margin: 20px auto;
}
.box {
color: #fff;
background: #2d2d2d;
padding: 12px;
display: inline-block;
}
```
1. 次に、_index.html_ファイルを構築します：
```html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>🛸 UFO Appearance Prediction! 👽</title>
<link rel="stylesheet" href="{{ url_for('static', filename='css/styles.css') }}">
</head>
<body>
<div class="grid">
<div class="box">
<p>According to the number of seconds, latitude and longitude, which country is likely to have reported seeing a UFO?</p>
<form action="{{ url_for('predict')}}" method="post">
<input type="number" name="seconds" placeholder="Seconds" required="required" min="0" max="60" />
<input type="text" name="latitude" placeholder="Latitude" required="required" />
<input type="text" name="longitude" placeholder="Longitude" required="required" />
<button type="submit" class="btn">Predict country where the UFO is seen</button>
</form>
<p>{{ prediction_text }}</p>
</div>
</div>
</body>
</html>
```
このファイルのテンプレートに目を通してください。アプリによって提供される変数の周りの「マスタッシュ」構文、例えば予測テキスト：`{{}}`. There's also a form that posts a prediction to the `/predict` route.
Finally, you're ready to build the python file that drives the consumption of the model and the display of predictions:
1. In `app.py`を追加します：
```python
import numpy as np
from flask import Flask, request, render_template
import pickle
app = Flask(__name__)
model = pickle.load(open("./ufo-model.pkl", "rb"))
@app.route("/")
def home():
return render_template("index.html")
@app.route("/predict", methods=["POST"])
def predict():
int_features = [int(x) for x in request.form.values()]
final_features = [np.array(int_features)]
prediction = model.predict(final_features)
output = prediction[0]
countries = ["Australia", "Canada", "Germany", "UK", "US"]
return render_template(
"index.html", prediction_text="Likely country: {}".format(countries[output])
)
if __name__ == "__main__":
app.run(debug=True)
```
> 💡 ヒント：[`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) while running the web app using Flask, any changes you make to your application will be reflected immediately without the need to restart the server. Beware! Don't enable this mode in a production app.
If you run `python app.py` or `python3 app.py` - your web server starts up, locally, and you can fill out a short form to get an answer to your burning question about where UFOs have been sighted!
Before doing that, take a look at the parts of `app.py`:
1. First, dependencies are loaded and the app starts.
1. Then, the model is imported.
1. Then, index.html is rendered on the home route.
On the `/predict` route, several things happen when the form is posted:
1. The form variables are gathered and converted to a numpy array. They are then sent to the model and a prediction is returned.
2. The Countries that we want displayed are re-rendered as readable text from their predicted country code, and that value is sent back to index.html to be rendered in the template.
Using a model this way, with Flask and a pickled model, is relatively straightforward. The hardest thing is to understand what shape the data is that must be sent to the model to get a prediction. That all depends on how the model was trained. This one has three data points to be input in order to get a prediction.
In a professional setting, you can see how good communication is necessary between the folks who train the model and those who consume it in a web or mobile app. In our case, it's only one person, you!
---
## 🚀 Challenge
Instead of working in a notebook and importing the model to the Flask app, you could train the model right within the Flask app! Try converting your Python code in the notebook, perhaps after your data is cleaned, to train the model from within the app on a route called `train`を追加したときに、アプリのエラーを特定するのが簡単になります。この方法の利点と欠点は何ですか？
## [講義後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/18/)
## まとめと自己学習
MLモデルを消費するためのWebアプリを構築する方法はいくつかあります。JavaScriptまたはPythonを使用して機械学習を活用するWebアプリを構築する方法のリストを作成してください。アーキテクチャを考慮してください：モデルはアプリ内に留まるべきか、それともクラウドに存在するべきか？ 後者の場合、どのようにアクセスしますか？ 実用的なML Webソリューションのアーキテクチャモデルを描いてみてください。
## 課題
[別のモデルを試す](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を追求していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご理解ください。元の文書は、その原語での権威ある情報源と見なされるべきです。重要な情報については、専門の人間翻訳を推奨します。この翻訳の使用から生じる誤解や誤訳について、当社は一切の責任を負いません。

14
translations/ja/3-Web-App/1-Web-App/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# 別のモデルを試す
## 手順
既に訓練された回帰モデルを使用して1つのウェブアプリを構築したので、以前の回帰レッスンで使用したモデルの1つを使用して、このウェブアプリを再作成してください。スタイルを維持するか、かぼちゃデータを反映するように異なるデザインにすることができます。モデルの訓練方法を反映するように入力を変更することに注意してください。
## ルーブリック
| 基準 | 優秀 | 十分 | 改善が必要 |
| -------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------- |
| ウェブアプリの動作 | ウェブアプリが期待通りに動作し、クラウドにデプロイされている | ウェブアプリに欠陥があるか、予期しない結果を示す | ウェブアプリが正しく機能しない |
**免責事項**:
この文書は機械翻訳サービスを使用して翻訳されています。正確性を期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。原文は権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤認について、当社は責任を負いません。

24
translations/ja/3-Web-App/README.md
Unescape View File

@ -1,24 +0,0 @@
# あなたのMLモデルを使用するためのWebアプリを構築する
このカリキュラムのセクションでは、応用されたMLのトピックに触れます。具体的には、Scikit-learnモデルをファイルとして保存し、それをWebアプリケーション内で予測に使用する方法について学びます。モデルを保存した後、そのモデルをFlaskで構築されたWebアプリで使用する方法を学びます。まず、UFO目撃情報に関するデータを使用してモデルを作成します。そして、緯度と経度の値を入力して、UFOを目撃した国を予測するWebアプリを構築します。
![UFO Parking](../../../translated_images/ufo.9e787f5161da9d4d1dafc537e1da09be8210f2ee996cb638aa5cee1d92867a04.ja.jpg)
Photo by <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> on <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## レッスン
1. [Webアプリを構築する](1-Web-App/README.md)
## クレジット
"Build a Web App" は [Jen Looper](https://twitter.com/jenlooper) によって書かれました。
クイズはRohan Rajによって書かれました。
データセットは[Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings)から提供されています。
Webアプリのアーキテクチャは、部分的に[この記事](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4)および[このリポジトリ](https://github.com/abhinavsagar/machine-learning-deployment)（Abhinav Sagarによる）を参考にしています。
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確性を期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語での原文を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解釈について、当社は責任を負いかねます。

302
translations/ja/4-Classification/1-Introduction/README.md
Unescape View File

@ -1,302 +0,0 @@
# 分類の紹介
この4つのレッスンでは、クラシックな機械学習の基本的な焦点である_分類_について探ります。アジアとインドの素晴らしい料理に関するデータセットを使用して、さまざまな分類アルゴリズムを使用する方法を説明します。お腹が空いてきましたか？
![just a pinch!](../../../../translated_images/pinch.1b035ec9ba7e0d408313b551b60c721c9c290b2dd2094115bc87e6ddacd114c9.ja.png)
> これらのレッスンでパンアジア料理を祝おう！画像提供：[Jen Looper](https://twitter.com/jenlooper)
分類は、回帰技術と多くの共通点を持つ[教師あり学習](https://wikipedia.org/wiki/Supervised_learning)の一形態です。機械学習がデータセットを使用して値や名前を予測することに関するものであるならば、分類は一般的に2つのグループに分かれます：_二値分類_と_多クラス分類_です。
[![Introduction to classification](https://img.youtube.com/vi/eg8DJYwdMyg/0.jpg)](https://youtu.be/eg8DJYwdMyg "Introduction to classification")
> 🎥 上の画像をクリックしてビデオを視聴：MITのJohn Guttagが分類を紹介
覚えておいてください：
- **線形回帰**は、変数間の関係を予測し、新しいデータポイントがその線とどのように関係するかを正確に予測するのに役立ちました。例えば、_9月と12月のカボチャの価格_を予測することができました。
- **ロジスティック回帰**は、「二値カテゴリ」を発見するのに役立ちました：この価格帯では、_このカボチャはオレンジ色か、オレンジ色でないか_？
分類は、データポイントのラベルやクラスを決定するためにさまざまなアルゴリズムを使用します。この料理データを使用して、材料のグループを観察することで、その料理の起源を特定できるかどうかを見てみましょう。
## [事前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/19/)
> ### [このレッスンはRでも利用可能です！](../../../../4-Classification/1-Introduction/solution/R/lesson_10.html)
### はじめに
分類は、機械学習研究者やデータサイエンティストの基本的な活動の1つです。二値値の基本的な分類（「このメールはスパムかどうか」）から、コンピュータビジョンを使用した複雑な画像分類やセグメンテーションまで、データをクラスに分類し、それに質問する能力は常に役立ちます。
プロセスをより科学的に述べると、分類法は入力変数と出力変数の関係をマッピングする予測モデルを作成します。
![binary vs. multiclass classification](../../../../translated_images/binary-multiclass.b56d0c86c81105a697dddd82242c1d11e4d78b7afefea07a44627a0f1111c1a9.ja.png)
> 分類アルゴリズムが処理する二値問題と多クラス問題。インフォグラフィック提供：[Jen Looper](https://twitter.com/jenlooper)
データのクリーニング、視覚化、およびMLタスクの準備を開始する前に、データを分類するために機械学習を使用するさまざまな方法について学びましょう。
[統計学](https://wikipedia.org/wiki/Statistical_classification)に由来する、クラシックな機械学習を使用した分類は、`smoker`、`weight`、および`age`などの特徴を使用して、_X病を発症する可能性_を決定します。以前に行った回帰演習と同様の教師あり学習技術として、データはラベル付けされ、MLアルゴリズムはこれらのラベルを使用してデータセットのクラス（または「特徴」）を分類および予測し、それらをグループまたは結果に割り当てます。
✅ 料理に関するデータセットを想像してみてください。多クラスモデルでは何が答えられるでしょうか？二値モデルでは何が答えられるでしょうか？ある料理がフェヌグリークを使用する可能性があるかどうかを判断したい場合はどうでしょうか？星アニス、アーティチョーク、カリフラワー、ホースラディッシュが入った食料袋をプレゼントされた場合、典型的なインド料理を作れるかどうかを確認したい場合はどうでしょうか？
[![Crazy mystery baskets](https://img.youtube.com/vi/GuTeDbaNoEU/0.jpg)](https://youtu.be/GuTeDbaNoEU "Crazy mystery baskets")
> 🎥 上の画像をクリックしてビデオを視聴。ショー「Chopped」の全体の前提は、「ミステリーバスケット」で、シェフがランダムな材料の選択から料理を作らなければならないというものです。確かにMLモデルが役立ったでしょう！
## こんにちは「分類器」
この料理データセットに関して私たちが尋ねたい質問は、実際には**多クラスの質問**です。私たちにはいくつかの潜在的な国の料理があるためです。一連の材料が与えられた場合、そのデータはこれらの多くのクラスのどれに適合するでしょうか？
Scikit-learnは、解決したい問題の種類に応じて、データを分類するために使用できるさまざまなアルゴリズムを提供しています。次の2つのレッスンでは、これらのアルゴリズムのいくつかについて学びます。
## 演習 - データをクリーンアップしてバランスを取る
このプロジェクトを開始する前の最初のタスクは、データをクリーンアップして**バランスを取る**ことです。これにより、より良い結果が得られます。このフォルダーのルートにある空の_notebook.ipynb_ファイルから始めます。
最初にインストールするものは[imblearn](https://imbalanced-learn.org/stable/)です。これはScikit-learnパッケージで、データのバランスをより良く取ることができます（このタスクについては後で詳しく学びます）。
1. `imblearn`をインストールするには、次のように`pip install`を実行します：
```python
pip install imblearn
```
1. データをインポートして視覚化するために必要なパッケージをインポートし、`imblearn`から`SMOTE`もインポートします。
```python
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE
```
これで、次にデータをインポートする準備が整いました。
1. 次のタスクはデータのインポートです：
```python
df = pd.read_csv('../data/cuisines.csv')
```
`read_csv()` will read the content of the csv file _cusines.csv_ and place it in the variable `df`を使用します。
1. データの形状を確認します：
```python
df.head()
```
最初の5行は次のようになります：
```output
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0 | 65 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 66 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 67 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 68 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 69 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
```
1. `info()`を呼び出してこのデータに関する情報を取得します：
```python
df.info()
```
出力は次のようになります：
```output
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2448 entries, 0 to 2447
Columns: 385 entries, Unnamed: 0 to zucchini
dtypes: int64(384), object(1)
memory usage: 7.2+ MB
```
## 演習 - 料理について学ぶ
ここからが面白くなります。料理ごとのデータの分布を見てみましょう。
1. `barh()`を呼び出してデータをバーとしてプロットします：
```python
df.cuisine.value_counts().plot.barh()
```
![cuisine data distribution](../../../../translated_images/cuisine-dist.d0cc2d551abe5c25f83d73a5f560927e4a061e9a4560bac1e97d35682ef3ca6d.ja.png)
料理の数は限られていますが、データの分布は不均一です。これを修正できます！その前に、もう少し探ってみましょう。
1. 料理ごとに利用可能なデータの量を調べて印刷します：
```python
thai_df = df[(df.cuisine == "thai")]
japanese_df = df[(df.cuisine == "japanese")]
chinese_df = df[(df.cuisine == "chinese")]
indian_df = df[(df.cuisine == "indian")]
korean_df = df[(df.cuisine == "korean")]
print(f'thai df: {thai_df.shape}')
print(f'japanese df: {japanese_df.shape}')
print(f'chinese df: {chinese_df.shape}')
print(f'indian df: {indian_df.shape}')
print(f'korean df: {korean_df.shape}')
```
出力は次のようになります：
```output
thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)
```
## 材料の発見
次に、データをさらに深く掘り下げて、各料理の典型的な材料を学びます。料理間の混乱を引き起こす再発データをクリーニングする必要があるので、この問題について学びましょう。
1. Pythonで`create_ingredient()`関数を作成して材料データフレームを作成します。この関数は、役に立たない列を削除し、カウントによって材料をソートすることから始めます：
```python
def create_ingredient_df(df):
ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
inplace=False)
return ingredient_df
```
これで、この関数を使用して、料理ごとのトップ10の人気材料のアイデアを得ることができます。
1. `create_ingredient()` and plot it calling `barh()`を呼び出します：
```python
thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()
```
![thai](../../../../translated_images/thai.0269dbab2e78bd38a132067759fe980008bdb80b6d778e5313448dbe12bed846.ja.png)
1. 日本のデータについても同じことを行います：
```python
japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()
```
![japanese](../../../../translated_images/japanese.30260486f2a05c463c8faa62ebe7b38f0961ed293bd9a6db8eef5d3f0cf17155.ja.png)
1. 次に、中国の材料についても同じことを行います：
```python
chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()
```
![chinese](../../../../translated_images/chinese.e62cafa5309f111afd1b54490336daf4e927ce32bed837069a0b7ce481dfae8d.ja.png)
1. インドの材料をプロットします：
```python
indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()
```
![indian](../../../../translated_images/indian.2c4292002af1a1f97a4a24fec6b1459ee8ff616c3822ae56bb62b9903e192af6.ja.png)
1. 最後に、韓国の材料をプロットします：
```python
korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()
```
![korean](../../../../translated_images/korean.4a4f0274f3d9805a65e61f05597eeaad8620b03be23a2c0a705c023f65fad2c0.ja.png)
1. `drop()`を呼び出して、異なる料理間で混乱を引き起こす最も一般的な材料を削除します：
みんなお米、にんにく、しょうがが大好きです！
```python
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```
## データセットのバランスを取る
データをクリーンアップしたので、[SMOTE](https://imbalanced-learn.org/dev/references/generated/imblearn.over_sampling.SMOTE.html) - 「合成少数オーバーサンプリング技術」 - を使用してバランスを取ります。
1. `fit_resample()`を呼び出します。この戦略は、補間によって新しいサンプルを生成します。
```python
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
データのバランスを取ることで、分類時により良い結果が得られます。二値分類を考えてみてください。データのほとんどが1つのクラスである場合、MLモデルはそのクラスをより頻繁に予測します。なぜなら、そのクラスのデータが多いためです。データのバランスを取ることで、偏ったデータを取り除き、この不均衡を解消するのに役立ちます。
1. 次に、材料ごとのラベルの数を確認します：
```python
print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')
```
出力は次のようになります：
```output
new label count: korean 799
chinese 799
indian 799
japanese 799
thai 799
Name: cuisine, dtype: int64
old label count: korean 799
indian 598
chinese 442
japanese 320
thai 289
Name: cuisine, dtype: int64
```
データはきれいでバランスが取れており、とてもおいしそうです！
1. 最後のステップは、ラベルと特徴を含むバランスの取れたデータを新しいデータフレームに保存し、ファイルにエクスポートできるようにすることです：
```python
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
1. `transformed_df.head()` and `transformed_df.info()`を使用してデータをもう一度確認できます。今後のレッスンで使用するためにこのデータのコピーを保存します：
```python
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
この新しいCSVはルートデータフォルダーにあります。
---
## 🚀チャレンジ
このカリキュラムにはいくつかの興味深いデータセットが含まれています。`data`フォルダーを掘り下げて、二値または多クラス分類に適したデータセットが含まれているかどうかを確認してください。このデータセットにどのような質問をしますか？
## [事後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/20/)
## レビューと自己学習
SMOTEのAPIを探ってみてください。どのようなユースケースに最適ですか？どのような問題を解決しますか？
## 課題
[分類方法を探る](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳にはエラーや不正確さが含まれる可能性があることをご了承ください。原文の言語で書かれたオリジナル文書を権威ある情報源とみなしてください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳については、一切の責任を負いかねます。

14
translations/ja/4-Classification/1-Introduction/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# 分類方法を探る
## 指示
[Scikit-learn ドキュメント](https://scikit-learn.org/stable/supervised_learning.html)には、データを分類するための多くの方法が記載されています。これらのドキュメントで少し宝探しをしてみてください。あなたの目標は、分類方法を探し、このカリキュラムのデータセット、質問、分類技術をマッチさせることです。スプレッドシートまたは.docファイルで表を作成し、データセットが分類アルゴリズムとどのように連携するかを説明してください。
## 評価基準
| 基準 | 優秀 | 適切 | 改善の余地あり |
| -------- | -------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| | 5つのアルゴリズムと分類技術の概要を示す文書が提示されており、その概要はよく説明され詳細です。 | 3つのアルゴリズムと分類技術の概要を示す文書が提示されており、その概要はよく説明され詳細です。 | 3つ未満のアルゴリズムと分類技術の概要を示す文書が提示されており、その概要は十分に説明されておらず詳細でもありません。 |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すために努力しておりますが、自動翻訳にはエラーや不正確さが含まれる可能性があります。元の言語での原文を権威ある情報源とみなすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤った解釈について、当社は一切の責任を負いません。

4
translations/ja/4-Classification/1-Introduction/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語での原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤訳については、一切の責任を負いかねます。

244
translations/ja/4-Classification/2-Classifiers-1/README.md
Unescape View File

@ -1,244 +0,0 @@
# Cuisine classifiers 1
このレッスンでは、前回のレッスンで保存した、バランスの取れたきれいなデータセットを使って、料理に関する予測を行います。
このデータセットを使って、さまざまな分類器を使用し、_材料のグループに基づいて特定の国の料理を予測_します。その過程で、アルゴリズムを分類タスクに利用する方法についてさらに学びます。
## [事前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/21/)
# 準備
[Lesson 1](../1-Introduction/README.md)を完了したと仮定して、_cleaned_cuisines.csv_ ファイルがルート `/data` フォルダーに存在することを確認してください。このファイルは4つのレッスンで使用されます。
## 演習 - 国の料理を予測する
1. このレッスンの _notebook.ipynb_ フォルダーで、そのファイルとPandasライブラリをインポートします:
```python
import pandas as pd
cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
cuisines_df.head()
```
データは次のように見えます:
| | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0 | 0 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 1 | indian | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 2 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 3 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 4 | indian | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 |
1. 次に、いくつかのライブラリをインポートします:
```python
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
from sklearn.svm import SVC
import numpy as np
```
1. Xとyの座標を2つのデータフレームに分けてトレーニングします。`cuisine`をラベルデータフレームにします:
```python
cuisines_label_df = cuisines_df['cuisine']
cuisines_label_df.head()
```
次のように見えます:
```output
0 indian
1 indian
2 indian
3 indian
4 indian
Name: cuisine, dtype: object
```
1. `Unnamed: 0` column and the `cuisine` column, calling `drop()`をドロップします。残りのデータをトレーニング可能な特徴として保存します:
```python
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
cuisines_feature_df.head()
```
あなたの特徴は次のように見えます:
| | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | artemisia | artichoke | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| ---: | -----: | -------: | ----: | ---------: | ----: | -----------: | ------: | -------: | --------: | --------: | ---: | ------: | ----------: | ---------: | ----------------------: | ---: | ---: | ---: | ----: | -----: | -------: |
| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 3 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
| 4 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | ... | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 |
これでモデルのトレーニングの準備が整いました！
## 分類器の選択
データがきれいになり、トレーニングの準備が整ったので、どのアルゴリズムを使用するかを決定する必要があります。
Scikit-learnは分類を教師あり学習の下にグループ化しており、そのカテゴリーでは多くの分類方法があります。[この多様性](https://scikit-learn.org/stable/supervised_learning.html)は最初は非常に圧倒されるかもしれません。以下の方法にはすべて分類技術が含まれます:
- 線形モデル
- サポートベクターマシン
- 確率的勾配降下法
- 最近傍法
- ガウス過程
- 決定木
- アンサンブル法（投票分類器）
- マルチクラスおよびマルチアウトプットアルゴリズム（マルチクラスおよびマルチラベル分類、マルチクラス-マルチアウトプット分類）
> データを分類するために[ニューラルネットワークを使用する](https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification)こともできますが、これはこのレッスンの範囲外です。
### どの分類器を選ぶべきか？
では、どの分類器を選ぶべきでしょうか？多くの場合、いくつかの分類器を試して良い結果を探すのが一つの方法です。Scikit-learnは[KNeighbors、SVCの2つの方法、GaussianProcessClassifier、DecisionTreeClassifier、RandomForestClassifier、MLPClassifier、AdaBoostClassifier、GaussianNB、QuadraticDiscrinationAnalysis](https://scikit-learn.org/stable/auto_examples/classification/plot_classifier_comparison.html)の比較を行い、結果を視覚化して表示します:
![比較](../../../../translated_images/comparison.edfab56193a85e7fdecbeaa1b1f8c99e94adbf7178bed0de902090cf93d6734f.ja.png)
> Scikit-learnのドキュメントで生成されたプロット
> AutoMLはこれらの比較をクラウドで実行し、データに最適なアルゴリズムを選択できるようにすることで、この問題をうまく解決します。試してみてください [こちら](https://docs.microsoft.com/learn/modules/automate-model-selection-with-azure-automl/?WT.mc_id=academic-77952-leestott)
### より良いアプローチ
しかし、無作為に推測するよりも、ダウンロード可能な[ML Cheat Sheet](https://docs.microsoft.com/azure/machine-learning/algorithm-cheat-sheet?WT.mc_id=academic-77952-leestott)のアイデアに従う方が良いです。ここでは、マルチクラスの問題に対していくつかの選択肢があることがわかります:
![チートシート](../../../../translated_images/cheatsheet.07a475ea444d22234cb8907a3826df5bdd1953efec94bd18e4496f36ff60624a.ja.png)
> マイクロソフトのアルゴリズムチートシートの一部、マルチクラス分類オプションの詳細
✅ このチートシートをダウンロードし、印刷して壁に貼りましょう！
### 理由付け
制約を考慮して、異なるアプローチを検討してみましょう:
- **ニューラルネットワークは重すぎる**。きれいだが最小限のデータセットと、ノートブックを使ってローカルでトレーニングを実行するという事実を考えると、ニューラルネットワークはこのタスクには重すぎます。
- **2クラス分類器は使用しない**。2クラス分類器は使用しないため、one-vs-allは除外されます。
- **決定木やロジスティック回帰が使える**。決定木やマルチクラスデータのロジスティック回帰が使えるかもしれません。
- **マルチクラスブーステッド決定木は異なる問題を解決する**。マルチクラスブーステッド決定木は非パラメトリックなタスク、例えばランキングを作成するタスクに最も適しているため、私たちには役立ちません。
### Scikit-learnの使用
データを分析するためにScikit-learnを使用します。しかし、Scikit-learnでロジスティック回帰を使用する方法はたくさんあります。[渡すパラメータ](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression)を確認してください。
本質的に、重要なパラメータは2つあります - `multi_class` and `solver` - that we need to specify, when we ask Scikit-learn to perform a logistic regression. The `multi_class` value applies a certain behavior. The value of the solver is what algorithm to use. Not all solvers can be paired with all `multi_class` values.
According to the docs, in the multiclass case, the training algorithm:
- **Uses the one-vs-rest (OvR) scheme**, if the `multi_class` option is set to `ovr`
- **Uses the cross-entropy loss**, if the `multi_class` option is set to `multinomial`. (Currently the `multinomial` option is supported only by the ‘lbfgs’, ‘sag’, ‘saga’ and ‘newton-cg’ solvers.)"
> 🎓 The 'scheme' here can either be 'ovr' (one-vs-rest) or 'multinomial'. Since logistic regression is really designed to support binary classification, these schemes allow it to better handle multiclass classification tasks. [source](https://machinelearningmastery.com/one-vs-rest-and-one-vs-one-for-multi-class-classification/)
> 🎓 The 'solver' is defined as "the algorithm to use in the optimization problem". [source](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html?highlight=logistic%20regressio#sklearn.linear_model.LogisticRegression).
Scikit-learn offers this table to explain how solvers handle different challenges presented by different kinds of data structures:
![solvers](../../../../translated_images/solvers.5fc648618529e627dfac29b917b3ccabda4b45ee8ed41b0acb1ce1441e8d1ef1.ja.png)
## Exercise - split the data
We can focus on logistic regression for our first training trial since you recently learned about the latter in a previous lesson.
Split your data into training and testing groups by calling `train_test_split()`です:
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
```
## 演習 - ロジスティック回帰を適用する
マルチクラスの場合、どのスキームを使用するか、どのソルバーを設定するかを選択する必要があります。マルチクラス設定と**liblinear**ソルバーを使用してロジスティック回帰をトレーニングします。
1. multi_classを`ovr` and the solver set to `liblinear`に設定してロジスティック回帰を作成します:
```python
lr = LogisticRegression(multi_class='ovr',solver='liblinear')
model = lr.fit(X_train, np.ravel(y_train))
accuracy = model.score(X_test, y_test)
print ("Accuracy is {}".format(accuracy))
```
✅ `lbfgs`, which is often set as default
> Note, use Pandas [`ravel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Series.ravel.html)関数を試して、必要に応じてデータをフラットにします。
正確度は**80%**を超えています！
1. データの1行（#50）をテストすることで、このモデルを実際に見ることができます:
```python
print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
print(f'cuisine: {y_test.iloc[50]}')
```
結果が表示されます:
```output
ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object')
cuisine: indian
```
✅ 別の行番号を試して結果を確認してみてください
1. この予測の正確性を確認するために、さらに掘り下げてみましょう:
```python
test= X_test.iloc[50].values.reshape(-1, 1).T
proba = model.predict_proba(test)
classes = model.classes_
resultdf = pd.DataFrame(data=proba, columns=classes)
topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
topPrediction.head()
```
結果が表示されます - インド料理が最も高い確率で予測されています:
| | 0 |
| -------: | -------: |
| indian | 0.715851 |
| chinese | 0.229475 |
| japanese | 0.029763 |
| korean | 0.017277 |
| thai | 0.007634 |
✅ なぜこのモデルがインド料理だと確信しているのか説明できますか？
1. 回帰レッスンで行ったように、分類レポートを印刷して詳細を確認します:
```python
y_pred = model.predict(X_test)
print(classification_report(y_test,y_pred))
```
| | precision | recall | f1-score | support |
| ------------ | --------- | ------ | -------- | ------- |
| chinese | 0.73 | 0.71 | 0.72 | 229 |
| indian | 0.91 | 0.93 | 0.92 | 254 |
| japanese | 0.70 | 0.75 | 0.72 | 220 |
| korean | 0.86 | 0.76 | 0.81 | 242 |
| thai | 0.79 | 0.85 | 0.82 | 254 |
| accuracy | 0.80 | 1199 | | |
| macro avg | 0.80 | 0.80 | 0.80 | 1199 |
| weighted avg | 0.80 | 0.80 | 0.80 | 1199 |
## 🚀チャレンジ
このレッスンでは、クリーンなデータを使用して、材料の一連のリストに基づいて国の料理を予測する機械学習モデルを構築しました。Scikit-learnがデータを分類するために提供する多くのオプションを読み、さらに掘り下げてみてください。ソルバーの概念を深く理解し、背後で何が起こっているのかを理解してください。
## [事後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/22/)
## レビュー & 自己学習
[このレッスン](https://people.eecs.berkeley.edu/~russell/classes/cs194/f11/lectures/CS194%20Fall%202011%20Lecture%2006.pdf)でロジスティック回帰の数学についてさらに掘り下げてみてください。
## 課題
[ソルバーを研究する](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることにご注意ください。元の言語での原文を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

13
translations/ja/4-Classification/2-Classifiers-1/assignment.md
Unescape View File

@ -1,13 +0,0 @@
# ソルバーの研究
## 手順
このレッスンでは、アルゴリズムと機械学習プロセスを組み合わせて正確なモデルを作成するさまざまなソルバーについて学びました。レッスンで紹介されたソルバーを見直し、その中から2つを選んでください。自分の言葉でこれら2つのソルバーを比較・対照してください。彼らはどのような問題に対処しますか？さまざまなデータ構造とどのように連携しますか？なぜ一方を選ぶ理由があるのかを説明してください。
## 評価基準
| 基準 | 模範的 | 適切 | 改善が必要 |
| -------- | ---------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------------------------- |
| | 各ソルバーについて比較を考慮した2つの段落がある.docファイルが提出されている。 | 1つの段落のみがある.docファイルが提出されている | 課題が未完成 |
**免責事項**:
この文書は、機械翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることにご注意ください。元の言語での文書が権威ある情報源とみなされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤認については、当社は一切の責任を負いません。

4
translations/ja/4-Classification/2-Classifiers-1/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があることにご留意ください。原文の言語によるオリジナル文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いかねます。

238
translations/ja/4-Classification/3-Classifiers-2/README.md
Unescape View File

@ -1,238 +0,0 @@
# 料理の分類器 2
この第2の分類レッスンでは、数値データを分類するためのさまざまな方法を探求します。また、異なる分類器を選択することの影響についても学びます。
## [講義前のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/23/)
### 前提条件
前のレッスンを完了し、この4つのレッスンフォルダーのルートにある `data` フォルダーに _cleaned_cuisines.csv_ という名前のクリーンなデータセットがあることを前提としています。
### 準備
クリーンなデータセットを使用して _notebook.ipynb_ ファイルを読み込み、モデル構築プロセスに向けて X と y のデータフレームに分割しました。
## 分類マップ
以前、Microsoftのチートシートを使用してデータを分類する際のさまざまなオプションについて学びました。Scikit-learnも同様の、しかしより詳細なチートシートを提供しており、推定器（分類器の別名）をさらに絞り込むのに役立ちます：
![Scikit-learnのMLマップ](../../../../translated_images/map.e963a6a51349425ab107b38f6c7307eb4c0d0c7ccdd2e81a5e1919292bab9ac7.ja.png)
> Tip: [このマップをオンラインで見る](https://scikit-learn.org/stable/tutorial/machine_learning_map/)と、パスに沿ってクリックしてドキュメントを読むことができます。
### 計画
このマップはデータの理解が深まると非常に役立ちます。パスに沿って歩きながら決定を下すことができます：
- 50以上のサンプルがあります
- カテゴリを予測したい
- ラベル付きデータがあります
- 100K未満のサンプルがあります
- ✨ Linear SVCを選択できます
- それがうまくいかない場合、数値データがあるので
- ✨ KNeighbors Classifierを試すことができます
- それもうまくいかない場合、✨ SVCや✨ Ensemble Classifiersを試してみることができます
これは非常に役立つルートです。
## 演習 - データを分割する
このパスに従って、使用するライブラリをインポートすることから始めましょう。
1. 必要なライブラリをインポートします：
```python
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
import numpy as np
```
1. トレーニングデータとテストデータを分割します：
```python
X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)
```
## Linear SVC分類器
サポートベクタークラスタリング（SVC）は、サポートベクターマシンのML技術ファミリーの一部です（詳細は以下を参照）。この方法では、ラベルをクラスタリングする方法を決定するための「カーネル」を選択できます。「C」パラメータは「正則化」を指し、パラメータの影響を調整します。カーネルは[いくつかの](https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) から選択でき、ここでは線形SVCを利用するために「linear」に設定します。確率はデフォルトで「false」ですが、ここでは確率推定を収集するために「true」に設定します。ランダム状態を「0」に設定してデータをシャッフルし、確率を取得します。
### 演習 - 線形SVCを適用する
分類器の配列を作成することから始めます。テストを進めるにつれてこの配列に追加していきます。
1. Linear SVCから始めます：
```python
C = 10
# Create different classifiers.
classifiers = {
'Linear SVC': SVC(kernel='linear', C=C, probability=True,random_state=0)
}
```
2. Linear SVCを使用してモデルをトレーニングし、レポートを出力します：
```python
n_classifiers = len(classifiers)
for index, (name, classifier) in enumerate(classifiers.items()):
classifier.fit(X_train, np.ravel(y_train))
y_pred = classifier.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy (train) for %s: %0.1f%% " % (name, accuracy * 100))
print(classification_report(y_test,y_pred))
```
結果はかなり良好です：
```output
Accuracy (train) for Linear SVC: 78.6%
precision recall f1-score support
chinese 0.71 0.67 0.69 242
indian 0.88 0.86 0.87 234
japanese 0.79 0.74 0.76 254
korean 0.85 0.81 0.83 242
thai 0.71 0.86 0.78 227
accuracy 0.79 1199
macro avg 0.79 0.79 0.79 1199
weighted avg 0.79 0.79 0.79 1199
```
## K-Neighbors分類器
K-Neighborsは「neighbors」ファミリーのMLメソッドの一部で、これは教師あり学習と教師なし学習の両方に使用できます。この方法では、事前に定義されたポイントの周りにデータを集め、一般化されたラベルをデータに対して予測できるようにします。
### 演習 - K-Neighbors分類器を適用する
前の分類器は良好で、データにうまく適合しましたが、さらに精度を向上させることができるかもしれません。K-Neighbors分類器を試してみましょう。
1. 分類器の配列に行を追加します（Linear SVC項目の後にカンマを追加）：
```python
'KNN classifier': KNeighborsClassifier(C),
```
結果は少し悪くなります：
```output
Accuracy (train) for KNN classifier: 73.8%
precision recall f1-score support
chinese 0.64 0.67 0.66 242
indian 0.86 0.78 0.82 234
japanese 0.66 0.83 0.74 254
korean 0.94 0.58 0.72 242
thai 0.71 0.82 0.76 227
accuracy 0.74 1199
macro avg 0.76 0.74 0.74 1199
weighted avg 0.76 0.74 0.74 1199
```
✅ [K-Neighbors](https://scikit-learn.org/stable/modules/neighbors.html#neighbors) について学びましょう
## サポートベクター分類器
サポートベクター分類器は、分類と回帰タスクに使用される[サポートベクターマシン](https://wikipedia.org/wiki/Support-vector_machine)ファミリーの一部です。SVMは「トレーニング例を空間のポイントにマップ」して、2つのカテゴリ間の距離を最大化します。その後のデータはこの空間にマップされ、カテゴリを予測できます。
### 演習 - サポートベクター分類器を適用する
サポートベクター分類器を使用して、さらに精度を向上させましょう。
1. K-Neighbors項目の後にカンマを追加し、この行を追加します：
```python
'SVC': SVC(),
```
結果は非常に良好です！
```output
Accuracy (train) for SVC: 83.2%
precision recall f1-score support
chinese 0.79 0.74 0.76 242
indian 0.88 0.90 0.89 234
japanese 0.87 0.81 0.84 254
korean 0.91 0.82 0.86 242
thai 0.74 0.90 0.81 227
accuracy 0.83 1199
macro avg 0.84 0.83 0.83 1199
weighted avg 0.84 0.83 0.83 1199
```
✅ [サポートベクター](https://scikit-learn.org/stable/modules/svm.html#svm) について学びましょう
## アンサンブル分類器
前のテストは非常に良好でしたが、最後までパスをたどってみましょう。ランダムフォレストとAdaBoostのようなアンサンブル分類器を試してみましょう：
```python
'RFST': RandomForestClassifier(n_estimators=100),
'ADA': AdaBoostClassifier(n_estimators=100)
```
結果は非常に良好で、特にランダムフォレストは優れています：
```output
Accuracy (train) for RFST: 84.5%
precision recall f1-score support
chinese 0.80 0.77 0.78 242
indian 0.89 0.92 0.90 234
japanese 0.86 0.84 0.85 254
korean 0.88 0.83 0.85 242
thai 0.80 0.87 0.83 227
accuracy 0.84 1199
macro avg 0.85 0.85 0.84 1199
weighted avg 0.85 0.84 0.84 1199
Accuracy (train) for ADA: 72.4%
precision recall f1-score support
chinese 0.64 0.49 0.56 242
indian 0.91 0.83 0.87 234
japanese 0.68 0.69 0.69 254
korean 0.73 0.79 0.76 242
thai 0.67 0.83 0.74 227
accuracy 0.72 1199
macro avg 0.73 0.73 0.72 1199
weighted avg 0.73 0.72 0.72 1199
```
✅ [アンサンブル分類器](https://scikit-learn.org/stable/modules/ensemble.html) について学びましょう
この機械学習の方法は、「いくつかの基本推定器の予測を組み合わせる」ことでモデルの質を向上させます。私たちの例では、ランダムツリーとAdaBoostを使用しました。
- [ランダムフォレスト](https://scikit-learn.org/stable/modules/ensemble.html#forest) は、平均化法であり、ランダム性を取り入れた「決定木」の「森」を構築して過学習を回避します。n_estimatorsパラメータは木の数を設定します。
- [AdaBoost](https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.AdaBoostClassifier.html) は、データセットに分類器を適合させ、その分類器のコピーを同じデータセットに適合させます。誤分類されたアイテムの重みを重視し、次の分類器の適合を調整して修正します。
---
## 🚀チャレンジ
これらの技術のそれぞれには、多くの調整可能なパラメータがあります。それぞれのデフォルトパラメータを調査し、これらのパラメータを調整することがモデルの質にどのような影響を与えるかを考えてみてください。
## [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/24/)
## 復習と自己学習
これらのレッスンには多くの専門用語が含まれているため、[この用語集](https://docs.microsoft.com/dotnet/machine-learning/resources/glossary?WT.mc_id=academic-77952-leestott) を見直してみましょう！
## 課題
[パラメータの調整](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期すために努めていますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語での文書を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

14
translations/ja/4-Classification/3-Classifiers-2/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# パラメータ プレイ
## 指示
これらの分類器を使用する際には、多くのパラメータがデフォルトで設定されています。VS Code の Intellisense を使ってそれらを掘り下げてみましょう。このレッスンで紹介された ML 分類技術の一つを採用し、さまざまなパラメータ値を調整してモデルを再訓練してください。なぜいくつかの変更がモデルの品質を向上させ、他の変更がそれを悪化させるのかを説明するノートブックを作成してください。回答には詳細を記載してください。
## ルーブリック
| 基準 | 模範的 | 適切 | 改善が必要 |
| -------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------- | ----------------------------- |
| | 分類器が完全に構築され、そのパラメータが調整され、変更点がテキストボックスで説明されたノートブックが提示されている | ノートブックが部分的に提示されているか、説明が不十分 | ノートブックにバグや欠陥がある |
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期していますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語の文書が信頼できる情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

4
translations/ja/4-Classification/3-Classifiers-2/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。権威ある情報源としては、原文の母国語の文書を考慮してください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解釈について、当社は一切の責任を負いません。

317
translations/ja/4-Classification/4-Applied/README.md
Unescape View File

@ -1,317 +0,0 @@
# 料理推薦Webアプリを作成しよう
このレッスンでは、以前のレッスンで学んだ技術と、このシリーズ全体で使用されているおいしい料理データセットを使用して、分類モデルを構築します。さらに、保存したモデルを使用する小さなWebアプリを構築し、OnnxのWebランタイムを活用します。
機械学習の最も実用的な用途の一つは推薦システムの構築であり、今日からその方向に一歩を踏み出すことができます！
[![このWebアプリのプレゼンテーション](https://img.youtube.com/vi/17wdM9AHMfg/0.jpg)](https://youtu.be/17wdM9AHMfg "Applied ML")
> 🎥 上の画像をクリックしてビデオを見る: Jen Looperが分類された料理データを使用してWebアプリを構築します
## [レッスン前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/25/)
このレッスンで学ぶこと:
- モデルを構築してOnnxモデルとして保存する方法
- Netronを使用してモデルを検査する方法
- 推論のためにWebアプリでモデルを使用する方法
## モデルを構築しよう
ビジネスシステムにこれらの技術を活用するためには、応用機械学習システムを構築することが重要です。Onnxを使用することで、Webアプリケーション内でモデルを使用し（必要に応じてオフラインコンテキストでも使用可能）、JavaScriptアプリケーションで使用することができます。
[前のレッスン](../../3-Web-App/1-Web-App/README.md)では、UFO目撃情報についての回帰モデルを構築し、それをFlaskアプリで使用しました。このアーキテクチャは非常に有用ですが、フルスタックのPythonアプリであり、JavaScriptアプリケーションを使用する要件があるかもしれません。
このレッスンでは、推論のための基本的なJavaScriptベースのシステムを構築できます。しかし、まずモデルを訓練し、Onnxで使用するために変換する必要があります。
## 演習 - 分類モデルを訓練しよう
まず、使用したクリーンな料理データセットを使用して分類モデルを訓練します。
1. 有用なライブラリをインポートすることから始めます：
```python
!pip install skl2onnx
import pandas as pd
```
Scikit-learnモデルをOnnx形式に変換するために '[skl2onnx](https://onnx.ai/sklearn-onnx/)' が必要です。
1. 次に、前のレッスンと同じ方法でデータを処理し、`read_csv()`を使用してCSVファイルを読み込みます：
```python
data = pd.read_csv('../data/cleaned_cuisines.csv')
data.head()
```
1. 不要な最初の2列を削除し、残りのデータを 'X' として保存します：
```python
X = data.iloc[:,2:]
X.head()
```
1. ラベルを 'y' として保存します：
```python
y = data[['cuisine']]
y.head()
```
### 訓練ルーチンを開始しよう
'SVC' ライブラリを使用します。これは高い精度を持っています。
1. Scikit-learnから適切なライブラリをインポートします：
```python
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
```
1. 訓練セットとテストセットを分けます：
```python
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
```
1. 前のレッスンで行ったように、SVC分類モデルを構築します：
```python
model = SVC(kernel='linear', C=10, probability=True,random_state=0)
model.fit(X_train,y_train.values.ravel())
```
1. 次に、`predict()`を呼び出してモデルをテストします：
```python
y_pred = model.predict(X_test)
```
1. モデルの品質を確認するために分類レポートを出力します：
```python
print(classification_report(y_test,y_pred))
```
以前見たように、精度は良好です：
```output
precision recall f1-score support
chinese 0.72 0.69 0.70 257
indian 0.91 0.87 0.89 243
japanese 0.79 0.77 0.78 239
korean 0.83 0.79 0.81 236
thai 0.72 0.84 0.78 224
accuracy 0.79 1199
macro avg 0.79 0.79 0.79 1199
weighted avg 0.79 0.79 0.79 1199
```
### モデルをOnnxに変換しよう
適切なテンソル数で変換を行うことを確認してください。このデータセットには380の成分が記載されているため、`FloatTensorType`にその数を記載する必要があります：
1. 380のテンソル数を使用して変換します。
```python
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
initial_type = [('float_input', FloatTensorType([None, 380]))]
options = {id(model): {'nocl': True, 'zipmap': False}}
```
1. onxを作成し、ファイル **model.onnx** として保存します：
```python
onx = convert_sklearn(model, initial_types=initial_type, options=options)
with open("./model.onnx", "wb") as f:
f.write(onx.SerializeToString())
```
> Note、変換スクリプトに[オプション](https://onnx.ai/sklearn-onnx/parameterized.html)を渡すことができます。この場合、'nocl'をTrue、'zipmap'をFalseに設定しました。これは分類モデルなので、辞書のリストを生成するZipMapを削除するオプションがあります（必要ありません）。`nocl` refers to class information being included in the model. Reduce your model's size by setting `nocl` to 'True'.
Running the entire notebook will now build an Onnx model and save it to this folder.
## View your model
Onnx models are not very visible in Visual Studio code, but there's a very good free software that many researchers use to visualize the model to ensure that it is properly built. Download [Netron](https://github.com/lutzroeder/Netron) and open your model.onnx file. You can see your simple model visualized, with its 380 inputs and classifier listed:
![Netron visual](../../../../translated_images/netron.a05f39410211915e0f95e2c0e8b88f41e7d13d725faf660188f3802ba5c9e831.ja.png)
Netron is a helpful tool to view your models.
Now you are ready to use this neat model in a web app. Let's build an app that will come in handy when you look in your refrigerator and try to figure out which combination of your leftover ingredients you can use to cook a given cuisine, as determined by your model.
## Build a recommender web application
You can use your model directly in a web app. This architecture also allows you to run it locally and even offline if needed. Start by creating an `index.html` file in the same folder where you stored your `model.onnx`ファイル。
1. このファイル _index.html_ に次のマークアップを追加します：
```html
<!DOCTYPE html>
<html>
<header>
<title>Cuisine Matcher</title>
</header>
<body>
...
</body>
</html>
```
1. 次に、`body`タグ内で、いくつかの成分を反映するチェックボックスのリストを表示するための少しのマークアップを追加します：
```html
<h1>Check your refrigerator. What can you create?</h1>
<div id="wrapper">
<div class="boxCont">
<input type="checkbox" value="4" class="checkbox">
<label>apple</label>
</div>
<div class="boxCont">
<input type="checkbox" value="247" class="checkbox">
<label>pear</label>
</div>
<div class="boxCont">
<input type="checkbox" value="77" class="checkbox">
<label>cherry</label>
</div>
<div class="boxCont">
<input type="checkbox" value="126" class="checkbox">
<label>fenugreek</label>
</div>
<div class="boxCont">
<input type="checkbox" value="302" class="checkbox">
<label>sake</label>
</div>
<div class="boxCont">
<input type="checkbox" value="327" class="checkbox">
<label>soy sauce</label>
</div>
<div class="boxCont">
<input type="checkbox" value="112" class="checkbox">
<label>cumin</label>
</div>
</div>
<div style="padding-top:10px">
<button onClick="startInference()">What kind of cuisine can you make?</button>
</div>
```
各チェックボックスには値が与えられています。これは、データセットに従って成分が見つかるインデックスを反映しています。例えば、リンゴはこのアルファベット順のリストの5番目の列を占めるため、その値は'4'です（0から数え始めます）。[成分スプレッドシート](../../../../4-Classification/data/ingredient_indexes.csv)を参照して、特定の成分のインデックスを確認できます。
index.htmlファイルでの作業を続け、最終的な閉じタグ`</div>`の後にモデルを呼び出すスクリプトブロックを追加します。
1. まず、[Onnxランタイム](https://www.onnxruntime.ai/)をインポートします：
```html
<script src="https://cdn.jsdelivr.net/npm/onnxruntime-web@1.9.0/dist/ort.min.js"></script>
```
> Onnxランタイムは、幅広いハードウェアプラットフォームでOnnxモデルを実行できるようにするために使用され、最適化と使用するためのAPIを提供します。
1. ランタイムが設定されたら、それを呼び出します：
```html
<script>
const ingredients = Array(380).fill(0);
const checks = [...document.querySelectorAll('.checkbox')];
checks.forEach(check => {
check.addEventListener('change', function() {
// toggle the state of the ingredient
// based on the checkbox's value (1 or 0)
ingredients[check.value] = check.checked ? 1 : 0;
});
});
function testCheckboxes() {
// validate if at least one checkbox is checked
return checks.some(check => check.checked);
}
async function startInference() {
let atLeastOneChecked = testCheckboxes()
if (!atLeastOneChecked) {
alert('Please select at least one ingredient.');
return;
}
try {
// create a new session and load the model.
const session = await ort.InferenceSession.create('./model.onnx');
const input = new ort.Tensor(new Float32Array(ingredients), [1, 380]);
const feeds = { float_input: input };
// feed inputs and run
const results = await session.run(feeds);
// read from results
alert('You can enjoy ' + results.label.data[0] + ' cuisine today!')
} catch (e) {
console.log(`failed to inference ONNX model`);
console.error(e);
}
}
</script>
```
このコードでは、いくつかのことが行われています：
1. モデルに送信するために、成分チェックボックスがチェックされているかどうかに応じて設定される380の可能な値（1または0）の配列を作成しました。
2. チェックボックスの配列を作成し、それらがチェックされているかどうかを決定する方法を`init` function that is called when the application starts. When a checkbox is checked, the `ingredients` array is altered to reflect the chosen ingredient.
3. You created a `testCheckboxes` function that checks whether any checkbox was checked.
4. You use `startInference` function when the button is pressed and, if any checkbox is checked, you start inference.
5. The inference routine includes:
1. Setting up an asynchronous load of the model
2. Creating a Tensor structure to send to the model
3. Creating 'feeds' that reflects the `float_input` input that you created when training your model (you can use Netron to verify that name)
4. Sending these 'feeds' to the model and waiting for a response
## Test your application
Open a terminal session in Visual Studio Code in the folder where your index.html file resides. Ensure that you have [http-server](https://www.npmjs.com/package/http-server) installed globally, and type `http-server`プロンプトで。ローカルホストが開き、Webアプリを見ることができます。さまざまな成分に基づいてどの料理が推奨されるかを確認してください：
![成分Webアプリ](../../../../translated_images/web-app.4c76450cabe20036f8ec6d5e05ccc0c1c064f0d8f2fe3304d3bcc0198f7dc139.ja.png)
おめでとうございます、いくつかのフィールドを持つ「推薦」Webアプリを作成しました。このシステムを構築するために時間をかけてください！
## 🚀チャレンジ
Webアプリは非常にミニマルなので、[ingredient_indexes](../../../../4-Classification/data/ingredient_indexes.csv)データの成分とそのインデックスを使用して引き続き構築してください。どのような風味の組み合わせが特定の国の料理を作るのに役立ちますか？
## [レッスン後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/26/)
## レビューと自己学習
このレッスンでは、食材の推薦システムの作成の有用性について簡単に触れましたが、この分野のMLアプリケーションには多くの例があります。これらのシステムがどのように構築されているかについてもっと読んでください：
- https://www.sciencedirect.com/topics/computer-science/recommendation-engine
- https://www.technologyreview.com/2014/08/25/171547/the-ultimate-challenge-for-recommendation-engines/
- https://www.technologyreview.com/2015/03/23/168831/everything-is-a-recommendation/
## 課題
[新しい推薦システムを構築する](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期すために努力していますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語での原文を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解について、当社は責任を負いません。

14
translations/ja/4-Classification/4-Applied/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# レコメンダーの構築
## 指示
このレッスンの演習を通じて、Onnx Runtimeと変換されたOnnxモデルを使用してJavaScriptベースのウェブアプリを構築する方法を学びました。これらのレッスンのデータや他のソースからのデータを使用して、新しいレコメンダーを構築する実験をしてみてください（クレジットを忘れずに）。例えば、さまざまな性格属性に基づいたペットレコメンダーや、人の気分に基づいた音楽ジャンルのレコメンダーを作成することができます。創造力を発揮してください！
## ルブリック
| 基準 | 模範的 | 適切 | 改善が必要 |
| -------- | ---------------------------------------------------------------------- | ------------------------------------- | --------------------------------- |
| | ウェブアプリとノートブックが提示されており、どちらもよく文書化されて動作している | そのうちの一つが欠けているか、または欠陥がある | 両方が欠けているか、または欠陥がある |
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期すよう努めていますが、自動翻訳には誤りや不正確さが含まれる場合があります。原文の母国語で書かれた文書が権威ある情報源とみなされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤認について、当社は一切の責任を負いません。

30
translations/ja/4-Classification/README.md
Unescape View File

@ -1,30 +0,0 @@
# 分類の始め方
## 地域のトピック: 美味しいアジアとインドの料理 🍜
アジアとインドでは、食文化が非常に多様であり、非常に美味しいです！地域の料理に関するデータを見て、その材料を理解してみましょう。
![タイの食べ物売り](../../../translated_images/thai-food.c47a7a7f9f05c21892a1f9dc7bf30669e6d18dfda420c5c7ebb4153f6a304edd.ja.jpg)
> <a href="https://unsplash.com/@changlisheng?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lisheng Chang</a>による写真 <a href="https://unsplash.com/s/photos/asian-food?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
## 学べること
このセクションでは、回帰に関する以前の学習を基にして、データをよりよく理解するために使用できる他の分類器について学びます。
> 分類モデルを扱うことを学ぶのに役立つ低コードツールがあります。このタスクには [Azure ML](https://docs.microsoft.com/learn/modules/create-classification-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott) を試してみてください。
## レッスン
1. [分類の紹介](1-Introduction/README.md)
2. [その他の分類器](2-Classifiers-1/README.md)
3. [さらに別の分類器](3-Classifiers-2/README.md)
4. [応用機械学習: ウェブアプリを作成する](4-Applied/README.md)
## クレジット
「分類の始め方」は [Cassie Breviu](https://www.twitter.com/cassiebreviu) と [Jen Looper](https://www.twitter.com/jenlooper) によって♥️で書かれました。
美味しい料理のデータセットは [Kaggle](https://www.kaggle.com/hoandan/asian-and-indian-cuisines) から提供されました。
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すために努力しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。原文の言語で書かれた元の文書が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解については責任を負いかねます。

144
translations/ja/5-Clustering/1-Visualize/README.md
Unescape View File

@ -1,144 +0,0 @@
# クラスタリング入門
クラスタリングは、データセットがラベル付けされていない、またはその入力が事前定義された出力と一致していないことを前提とする[教師なし学習](https://wikipedia.org/wiki/Unsupervised_learning)の一種です。さまざまなアルゴリズムを使用してラベルのないデータを整理し、データ内のパターンに従ってグループ化を提供します。
[![No One Like You by PSquare](https://img.youtube.com/vi/ty2advRiWJM/0.jpg)](https://youtu.be/ty2advRiWJM "No One Like You by PSquare")
> 🎥 上の画像をクリックするとビデオが再生されます。クラスタリングを使った機械学習を勉強しながら、ナイジェリアのダンスホールトラックを楽しんでください。これはPSquareの2014年の高評価の曲です。
## [プレ講義クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/27/)
### イントロダクション
[クラスタリング](https://link.springer.com/referenceworkentry/10.1007%2F978-0-387-30164-8_124)はデータ探索に非常に役立ちます。ナイジェリアの聴衆が音楽を消費する方法に関するトレンドやパターンを発見できるかどうか見てみましょう。
✅ クラスタリングの利用方法について少し考えてみてください。現実世界では、洗濯物を家族ごとに仕分けるときにクラスタリングが行われます🧦👕👖🩲。データサイエンスでは、ユーザーの好みを分析したり、ラベルのないデータセットの特性を決定したりする際にクラスタリングが行われます。クラスタリングは、混沌とした状況を整理するのに役立ちます。例えば、靴下の引き出しのように。
[![Introduction to ML](https://img.youtube.com/vi/esmzYhuFnds/0.jpg)](https://youtu.be/esmzYhuFnds "Introduction to Clustering")
> 🎥 上の画像をクリックするとビデオが再生されます。MITのジョン・グットタグがクラスタリングを紹介します。
プロフェッショナルな設定では、クラスタリングは市場セグメンテーションや、どの年齢層がどの商品を購入するかの決定などに使用されます。別の使用例としては、クレジットカード取引のデータセットから詐欺を検出するための異常検出があります。また、医療スキャンのバッチから腫瘍を特定するためにクラスタリングを使用することもできます。
✅ 銀行、eコマース、ビジネスの設定で「野生の中で」クラスタリングに遭遇した方法について考えてみてください。
> 🎓 興味深いことに、クラスタ分析は1930年代に人類学と心理学の分野で始まりました。どのように使用されたか想像できますか？
また、検索結果をグループ化するために使用することもできます。例えば、ショッピングリンク、画像、レビューなど。クラスタリングは、大規模なデータセットを減らし、より詳細な分析を行いたいときに役立ちます。この技術は、他のモデルを構築する前にデータを理解するために使用されます。
✅ データがクラスタに整理されると、クラスタIDを割り当てます。この技術はデータセットのプライバシーを保護する際に役立ちます。クラスタIDでデータポイントを参照することで、より具体的な識別可能なデータを使用せずに済みます。他の要素ではなくクラスタIDを使用して識別する理由を考えてみてください。
クラスタリング技術の理解を深めるために、この[Learnモジュール](https://docs.microsoft.com/learn/modules/train-evaluate-cluster-models?WT.mc_id=academic-77952-leestott)を参照してください。
## クラスタリングの始め方
[Scikit-learnは](https://scikit-learn.org/stable/modules/clustering.html)クラスタリングを実行するための多くの方法を提供しています。選択するタイプは使用ケースに依存します。ドキュメントによると、各方法にはさまざまな利点があります。以下は、Scikit-learnでサポートされている方法とその適切な使用ケースの簡略化された表です：
| メソッド名 | 使用ケース |
| :--------------------------- | :--------------------------------------------------------------------- |
| K-Means | 一般的な目的、帰納的 |
| Affinity propagation | 多くの、不均一なクラスタ、帰納的 |
| Mean-shift | 多くの、不均一なクラスタ、帰納的 |
| Spectral clustering | 少数の、均一なクラスタ、推論的 |
| Ward hierarchical clustering | 多くの、制約されたクラスタ、推論的 |
| Agglomerative clustering | 多くの、制約された、非ユークリッド距離、推論的 |
| DBSCAN | 非平坦な幾何学、不均一なクラスタ、推論的 |
| OPTICS | 非平坦な幾何学、変動密度の不均一なクラスタ、推論的 |
| Gaussian mixtures | 平坦な幾何学、帰納的 |
| BIRCH | 外れ値のある大規模なデータセット、帰納的 |
> 🎓 クラスタを作成する方法は、データポイントをグループにまとめる方法に大きく関係しています。いくつかの用語を解説しましょう：
>
> 🎓 ['推論的' vs. '帰納的'](https://wikipedia.org/wiki/Transduction_(machine_learning))
>
> 推論的推論は、特定のテストケースにマッピングされる観察されたトレーニングケースから導かれます。帰納的推論は、一般的なルールにマッピングされるトレーニングケースから導かれ、それがテストケースに適用されます。
>
> 例：部分的にラベル付けされたデータセットがあると想像してください。いくつかは「レコード」、いくつかは「CD」、いくつかは空白です。あなたの仕事は空白にラベルを付けることです。帰納的アプローチを選択すると、「レコード」と「CD」を探すモデルをトレーニングし、そのラベルをラベルのないデータに適用します。このアプローチは、実際には「カセット」であるものを分類するのに苦労します。一方、推論的アプローチは、似たアイテムをグループ化し、そのグループにラベルを適用することで、この未知のデータをより効果的に処理します。この場合、クラスタは「丸い音楽のもの」や「四角い音楽のもの」を反映するかもしれません。
>
> 🎓 ['非平坦' vs. '平坦'な幾何学](https://datascience.stackexchange.com/questions/52260/terminology-flat-geometry-in-the-context-of-clustering)
>
> 数学的用語から派生した非平坦 vs. 平坦な幾何学は、ポイント間の距離を「平坦」（[ユークリッド](https://wikipedia.org/wiki/Euclidean_geometry)）または「非平坦」（非ユークリッド）な幾何学的方法で測定することを指します。
>
>'平坦'はユークリッド幾何学（部分的には「平面」幾何学として教えられる）を指し、非平坦は非ユークリッド幾何学を指します。幾何学が機械学習と何の関係があるのでしょうか？数学に根ざした2つの分野として、クラスタ内のポイント間の距離を測定する共通の方法が必要であり、それはデータの性質に応じて「平坦」または「非平坦」な方法で行うことができます。[ユークリッド距離](https://wikipedia.org/wiki/Euclidean_distance)は、2つのポイント間の線分の長さとして測定されます。[非ユークリッド距離](https://wikipedia.org/wiki/Non-Euclidean_geometry)は曲線に沿って測定されます。データが平面上に存在しないように見える場合、特殊なアルゴリズムを使用する必要があるかもしれません。
>
![Flat vs Nonflat Geometry Infographic](../../../../translated_images/flat-nonflat.d1c8c6e2a96110c1d57fa0b72913f6aab3c245478524d25baf7f4a18efcde224.ja.png)
> インフォグラフィック: [Dasani Madipalli](https://twitter.com/dasani_decoded)
>
> 🎓 ['距離'](https://web.stanford.edu/class/cs345a/slides/12-clustering.pdf)
>
> クラスタは、その距離行列、つまりポイント間の距離によって定義されます。この距離は、いくつかの方法で測定できます。ユークリッドクラスタはポイント値の平均によって定義され、「重心」または中心点を含みます。距離はその重心までの距離によって測定されます。非ユークリッド距離は「クラストロイド」と呼ばれる最も近いポイントによって測定されます。クラストロイドはさまざまな方法で定義できます。
>
> 🎓 ['制約された'](https://wikipedia.org/wiki/Constrained_clustering)
>
> [制約付きクラスタリング](https://web.cs.ucdavis.edu/~davidson/Publications/ICDMTutorial.pdf)は、この教師なし方法に「半教師あり」学習を導入します。ポイント間の関係は「リンクできない」または「リンクしなければならない」としてフラグが立てられ、データセットにいくつかのルールが適用されます。
>
>例：アルゴリズムがラベルのないまたは半ラベルのデータのバッチに自由に設定されると、生成されるクラスタは質が低い可能性があります。上記の例では、クラスタは「丸い音楽のもの」、「四角い音楽のもの」、「三角形のもの」、「クッキー」をグループ化するかもしれません。いくつかの制約、つまりフォローするルール（「アイテムはプラスチックでなければならない」、「アイテムは音楽を生成できる必要がある」）を与えると、アルゴリズムがより良い選択をするのに役立ちます。
>
> 🎓 '密度'
>
> 'ノイズ'の多いデータは「密度が高い」と見なされます。そのクラスタ内のポイント間の距離は、調査の結果、より密度が高い、または低い、つまり「混雑している」ことがわかるかもしれません。このデータは適切なクラスタリング方法で分析する必要があります。[この記事](https://www.kdnuggets.com/2020/02/understanding-density-based-clustering.html)は、不均一なクラスタ密度を持つノイズの多いデータセットを探索するためにK-MeansクラスタリングとHDBSCANアルゴリズムを使用する違いを示しています。
## クラスタリングアルゴリズム
クラスタリングアルゴリズムは100以上あり、その使用は手元のデータの性質に依存します。主要なものをいくつか紹介しましょう：
- **階層的クラスタリング**。オブジェクトが遠くのオブジェクトよりも近くのオブジェクトに基づいて分類される場合、クラスタはメンバーの他のオブジェクトとの距離に基づいて形成されます。Scikit-learnの凝集クラスタリングは階層的です。
![Hierarchical clustering Infographic](../../../../translated_images/hierarchical.bf59403aa43c8c47493bfdf1cc25230f26e45f4e38a3d62e8769cd324129ac15.ja.png)
> インフォグラフィック: [Dasani Madipalli](https://twitter.com/dasani_decoded)
- **重心クラスタリング**。この人気のあるアルゴリズムは、'k'、つまり形成するクラスタの数を選択する必要があります。その後、アルゴリズムはクラスタの中心点を決定し、その点の周りにデータを収集します。[K-meansクラスタリング](https://wikipedia.org/wiki/K-means_clustering)は重心クラスタリングの人気バージョンです。中心は最も近い平均によって決定されるため、この名前が付いています。クラスタからの二乗距離が最小化されます。
![Centroid clustering Infographic](../../../../translated_images/centroid.097fde836cf6c9187d0b2033e9f94441829f9d86f4f0b1604dd4b3d1931aee34.ja.png)
> インフォグラフィック: [Dasani Madipalli](https://twitter.com/dasani_decoded)
- **分布ベースのクラスタリング**。統計モデリングに基づいており、分布ベースのクラスタリングはデータポイントがクラスタに属する確率を決定し、それに応じて割り当てます。ガウス混合法はこのタイプに属します。
- **密度ベースのクラスタリング**。データポイントはその密度、つまり互いの周りにグループ化されることに基づいてクラスタに割り当てられます。グループから遠く離れたデータポイントは外れ値またはノイズと見なされます。DBSCAN、Mean-shift、およびOPTICSはこのタイプのクラスタリングに属します。
- **グリッドベースのクラスタリング**。多次元データセットの場合、グリッドが作成され、データはグリッドのセルに分割され、それによってクラスタが作成されます。
## 演習 - データをクラスタリングする
クラスタリング技術は適切な視覚化によって大いに助けられるので、音楽データを視覚化することから始めましょう。この演習は、このデータの性質に最も効果的なクラスタリング方法を決定するのに役立ちます。
1. このフォルダ内の[_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/1-Visualize/notebook.ipynb)ファイルを開きます。
1. 良いデータ視覚化のために`Seaborn`パッケージをインポートします。
```python
!pip install seaborn
```
1. [_nigerian-songs.csv_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/data/nigerian-songs.csv)から曲データを追加します。曲に関するデータでデータフレームを読み込みます。ライブラリをインポートし、データをダンプしてこのデータを探索する準備をします：
```python
import matplotlib.pyplot as plt
import pandas as pd
df = pd.read_csv("../data/nigerian-songs.csv")
df.head()
```
最初の数行のデータを確認します：
| | name | album | artist | artist_top_genre | release_date | length | popularity | danceability | acousticness | energy | instrumentalness | liveness | loudness | speechiness | tempo | time_signature |
| --- | ------------------------ | ---------------------------- | ------------------- | ---------------- | ------------ | ------ | ---------- | ------------ | ------------ | ------ | ---------------- | -------- | -------- | ----------- | ------- | -------------- |
| 0 | Sparky | Mandy & The Jungle | Cruel Santino | alternative r&b | 2019 | 144000 | 48 | 0.666 | 0.851 | 0.42 | 0.534 | 0.11 | -6.699 | 0.0829 | 133.015 | 5 |
| 1 | shuga rush | EVERYTHING YOU HEARD IS TRUE | Odunsi (The Engine) | afropop | 2020 | 89488 | 30 | 0.71 | 0.0822 | 0.683 | 0.000169 | 0.101 | -5.64 | 0.36 | 129.993 | 3 |
| 2 | LITT! | LITT! | AYLØ | indie r&b | 2018 | 207758 | 40 | 0.836 | 0.272 | 0.564 | 0.000537 | 0.11 | -7.127 | 0.0424 | 130.005 | 4 |
| 3 | Confident / Feeling Cool | Enjoy Your Life | Lady Donli | nigerian pop | 2019 | 175135 | 14 | 0.894 | 0.798 | 0.611 | 0.000187 | 0.0964 | -4.961 | 0.113 | 111.087 | 4 |
| 4 | wanted you | rare. | Odunsi (The Engine) | afropop | 2018 | 152049 | 25
## [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/28/)
## 復習と自主学習
クラスタリングアルゴリズムを適用する前に、データセットの性質を理解することが重要です。このトピックについてもっと知りたい方は[こちら](https://www.kdnuggets.com/2019/10/right-clustering-algorithm.html)をご覧ください。
[この役立つ記事](https://www.freecodecamp.org/news/8-clustering-algorithms-in-machine-learning-that-all-data-scientists-should-know/)では、さまざまなデータ形状に応じた異なるクラスタリングアルゴリズムの挙動について説明しています。
## 課題
[クラスタリングの他の可視化方法を調査する](assignment.md)
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳にはエラーや不正確さが含まれる場合がありますのでご注意ください。元の言語での原文が権威ある情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解について、当社は責任を負いません。

14
translations/ja/5-Clustering/1-Visualize/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# クラスタリングのための他の視覚化手法の調査
## 指示
このレッスンでは、データをプロットしてクラスタリングの準備をするためのいくつかの視覚化手法について学びました。特に散布図は、オブジェクトのグループを見つけるのに役立ちます。散布図を作成するための異なる方法や異なるライブラリを調査し、その作業をノートブックに記録してください。このレッスンのデータ、他のレッスンのデータ、または自分で調達したデータを使用できます（ただし、ノートブックにはその出典を明記してください）。散布図を使用してデータをプロットし、発見したことを説明してください。
## ルーブリック
| 基準 | 模範的なもの | 適切なもの | 改善が必要なもの |
| -------- | ---------------------------------------------------------- | -------------------------------------------------------------------------- | ----------------------------------- |
| | 五つの十分に文書化された散布図を含むノートブックが提示される | 五つ未満の散布図を含むノートブックが提示され、文書化が不十分である | 不完全なノートブックが提示される |
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。権威ある情報源としては、原文の母国語の文書を考慮すべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解について、当社は一切の責任を負いません。

4
translations/ja/5-Clustering/1-Visualize/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期しておりますが、自動翻訳には誤りや不正確な点が含まれる場合があります。元の言語の文書を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いかねます。

250
translations/ja/5-Clustering/2-K-Means/README.md
Unescape View File

@ -1,250 +0,0 @@
# K-Means クラスタリング
## [事前講義クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/29/)
このレッスンでは、以前にインポートしたナイジェリア音楽データセットを使用して、Scikit-learnを使ったクラスタリングの作成方法を学びます。K-Meansクラスタリングの基本について説明します。前のレッスンで学んだように、クラスタリングには多くの方法があり、使用する方法はデータに依存します。K-Meansは最も一般的なクラスタリング技術なので、これを試してみましょう！
学ぶ用語:
- シルエットスコア
- エルボー法
- 慣性
- 分散
## 導入
[K-Meansクラスタリング](https://wikipedia.org/wiki/K-means_clustering)は、信号処理の分野から派生した手法です。データのグループを 'k' クラスターに分割し、観察を通じてクラスタリングを行います。各観察は、与えられたデータポイントを最も近い '平均'、つまりクラスターの中心点にグループ化するために機能します。
クラスタは、点（または '種子'）とその対応する領域を含む[ボロノイ図](https://wikipedia.org/wiki/Voronoi_diagram)として視覚化できます。
![voronoi diagram](../../../../translated_images/voronoi.1dc1613fb0439b9564615eca8df47a4bcd1ce06217e7e72325d2406ef2180795.ja.png)
> インフォグラフィック by [Jen Looper](https://twitter.com/jenlooper)
K-Meansクラスタリングのプロセスは[3ステップで実行されます](https://scikit-learn.org/stable/modules/clustering.html#k-means):
1. アルゴリズムはデータセットからサンプリングしてk個の中心点を選択します。その後、以下をループします:
1. 各サンプルを最も近いセントロイドに割り当てます。
2. 前のセントロイドに割り当てられたすべてのサンプルの平均値を取って新しいセントロイドを作成します。
3. その後、新旧のセントロイドの差を計算し、セントロイドが安定するまで繰り返します。
K-Meansの使用には、 'k' 、つまりセントロイドの数を設定する必要があるという欠点があります。幸いにも、 'エルボー法' は 'k' の適切な開始値を推定するのに役立ちます。すぐに試してみましょう。
## 前提条件
このレッスンの[_notebook.ipynb_](https://github.com/microsoft/ML-For-Beginners/blob/main/5-Clustering/2-K-Means/notebook.ipynb)ファイルで作業します。このファイルには、前のレッスンで行ったデータのインポートと事前クリーニングが含まれています。
## 演習 - 準備
もう一度、曲のデータを見てみましょう。
1. 各列に対して `boxplot()` を呼び出してボックスプロットを作成します:
```python
plt.figure(figsize=(20,20), dpi=200)
plt.subplot(4,3,1)
sns.boxplot(x = 'popularity', data = df)
plt.subplot(4,3,2)
sns.boxplot(x = 'acousticness', data = df)
plt.subplot(4,3,3)
sns.boxplot(x = 'energy', data = df)
plt.subplot(4,3,4)
sns.boxplot(x = 'instrumentalness', data = df)
plt.subplot(4,3,5)
sns.boxplot(x = 'liveness', data = df)
plt.subplot(4,3,6)
sns.boxplot(x = 'loudness', data = df)
plt.subplot(4,3,7)
sns.boxplot(x = 'speechiness', data = df)
plt.subplot(4,3,8)
sns.boxplot(x = 'tempo', data = df)
plt.subplot(4,3,9)
sns.boxplot(x = 'time_signature', data = df)
plt.subplot(4,3,10)
sns.boxplot(x = 'danceability', data = df)
plt.subplot(4,3,11)
sns.boxplot(x = 'length', data = df)
plt.subplot(4,3,12)
sns.boxplot(x = 'release_date', data = df)
```
このデータは少しノイズが多いです: 各列をボックスプロットとして観察すると、外れ値が見えます。
![outliers](../../../../translated_images/boxplots.8228c29dabd0f29227dd38624231a175f411f1d8d4d7c012cb770e00e4fdf8b6.ja.png)
データセットを通じてこれらの外れ値を削除することもできますが、それではデータが非常に少なくなります。
1. クラスタリング演習に使用する列を選択します。範囲が似ているものを選び、 `artist_top_genre` 列を数値データとしてエンコードします:
```python
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
X = df.loc[:, ('artist_top_genre','popularity','danceability','acousticness','loudness','energy')]
y = df['artist_top_genre']
X['artist_top_genre'] = le.fit_transform(X['artist_top_genre'])
y = le.transform(y)
```
1. 次に、ターゲットとするクラスタ数を選択する必要があります。データセットから3つの曲のジャンルがあることがわかっているので、3つを試してみましょう:
```python
from sklearn.cluster import KMeans
nclusters = 3
seed = 0
km = KMeans(n_clusters=nclusters, random_state=seed)
km.fit(X)
# Predict the cluster for each data point
y_cluster_kmeans = km.predict(X)
y_cluster_kmeans
```
データフレームの各行に対して予測されたクラスタ（0, 1, 2）が含まれた配列が表示されます。
1. この配列を使用して 'シルエットスコア' を計算します:
```python
from sklearn import metrics
score = metrics.silhouette_score(X, y_cluster_kmeans)
score
```
## シルエットスコア
シルエットスコアは1に近いほど良いです。このスコアは-1から1まで変動し、スコアが1の場合、クラスターは密集しており他のクラスターとよく分離されています。0に近い値は、隣接するクラスターの決定境界に非常に近いサンプルを持つオーバーラップするクラスターを表します。 [(ソース)](https://dzone.com/articles/kmeans-silhouette-score-explained-with-python-exam)
私たちのスコアは**.53**ですので、中間です。これは、このタイプのクラスタリングにデータが特に適していないことを示していますが、続けてみましょう。
### 演習 - モデルの構築
1. `KMeans` をインポートし、クラスタリングプロセスを開始します。
```python
from sklearn.cluster import KMeans
wcss = []
for i in range(1, 11):
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
kmeans.fit(X)
wcss.append(kmeans.inertia_)
```
ここには説明する価値のあるいくつかの部分があります。
> 🎓 range: クラスタリングプロセスの反復回数です
> 🎓 random_state: "セントロイドの初期化のための乱数生成を決定します。" [ソース](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.KMeans.html#sklearn.cluster.KMeans)
> 🎓 WCSS: "within-cluster sums of squares" は、クラスター内のすべてのポイントのクラスターセントロイドへの平均距離の平方を測定します。 [ソース](https://medium.com/@ODSC/unsupervised-learning-evaluating-clusters-bd47eed175ce).
> 🎓 Inertia: K-Meansアルゴリズムは 'inertia' を最小化するセントロイドを選択しようとします。これは、"クラスターが内部的にどれだけ一貫しているかを測定するものです。" [ソース](https://scikit-learn.org/stable/modules/clustering.html). この値は各反復でwcss変数に追加されます。
> 🎓 k-means++: [Scikit-learn](https://scikit-learn.org/stable/modules/clustering.html#k-means) では、'k-means++' 最適化を使用できます。これは、"セントロイドをお互いに（一般的に）遠くに初期化し、ランダムな初期化よりもおそらく良い結果をもたらします。
### エルボー法
以前、3つの曲のジャンルをターゲットにしているため、3つのクラスターを選択するべきだと推測しました。しかし、それは本当でしょうか？
1. 'エルボー法' を使用して確認します。
```python
plt.figure(figsize=(10,5))
sns.lineplot(x=range(1, 11), y=wcss, marker='o', color='red')
plt.title('Elbow')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()
```
前のステップで構築した `wcss` 変数を使用して、クラスターの最適な数を示す 'エルボー' の曲がりを示すチャートを作成します。おそらくそれは **3** です！
![elbow method](../../../../translated_images/elbow.72676169eed744ff03677e71334a16c6b8f751e9e716e3d7f40dd7cdef674cca.ja.png)
## 演習 - クラスタを表示する
1. 今度は3つのクラスターを設定してプロセスを再試行し、クラスタを散布図として表示します:
```python
from sklearn.cluster import KMeans
kmeans = KMeans(n_clusters = 3)
kmeans.fit(X)
labels = kmeans.predict(X)
plt.scatter(df['popularity'],df['danceability'],c = labels)
plt.xlabel('popularity')
plt.ylabel('danceability')
plt.show()
```
1. モデルの精度を確認します:
```python
labels = kmeans.labels_
correct_labels = sum(y == labels)
print("Result: %d out of %d samples were correctly labeled." % (correct_labels, y.size))
print('Accuracy score: {0:0.2f}'. format(correct_labels/float(y.size)))
```
このモデルの精度はあまり良くなく、クラスタの形状がその理由を示しています。
![clusters](../../../../translated_images/clusters.b635354640d8e4fd4a49ef545495518e7be76172c97c13bd748f5b79f171f69a.ja.png)
このデータは不均衡で、相関が少なく、列の値の間に大きなばらつきがあり、うまくクラスタリングできません。実際、形成されるクラスタは、上で定義した3つのジャンルカテゴリに大きく影響されているか、偏っている可能性があります。これは学習プロセスでした！
Scikit-learnのドキュメントでは、このようにクラスタがあまりよく区別されていないモデルは '分散' の問題があるとされています:
![problem models](../../../../translated_images/problems.f7fb539ccd80608e1f35c319cf5e3ad1809faa3c08537aead8018c6b5ba2e33a.ja.png)
> Infographic from Scikit-learn
## 分散
分散は "平均からの平方の差の平均" と定義されます [(ソース)](https://www.mathsisfun.com/data/standard-deviation.html). このクラスタリング問題の文脈では、データセットの数値が平均から少し離れすぎることを指します。
✅ これは、この問題を解決するためのすべての方法を考える良い機会です。データをもう少し調整しますか？他の列を使用しますか？別のアルゴリズムを使用しますか？ヒント: [データをスケーリング](https://www.mygreatlearning.com/blog/learning-data-science-with-k-means-clustering/) して正規化し、他の列をテストしてみてください。
> この '[分散計算機](https://www.calculatorsoup.com/calculators/statistics/variance-calculator.php)' を試して、概念をもう少し理解してください。
---
## 🚀チャレンジ
このノートブックでパラメータを調整してみてください。データをさらにクリーニングすることでモデルの精度を向上させることができますか（たとえば、外れ値を削除するなど）？特定のデータサンプルに重みをつけることもできます。他にどのようにしてより良いクラスタを作成できますか？
ヒント: データをスケーリングしてみてください。ノートブックには、データ列が範囲の点で互いにより似るように標準スケーリングを追加するコメント付きのコードがあります。シルエットスコアは下がりますが、エルボーグラフの '曲がり' が滑らかになります。これは、データをスケーリングせずに放置すると、分散が少ないデータがより多くの重みを持つことになるためです。この問題についてさらに読みたい場合は、[こちら](https://stats.stackexchange.com/questions/21222/are-mean-normalization-and-feature-scaling-needed-for-k-means-clustering/21226#21226)を参照してください。
## [事後講義クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/30/)
## レビューと自主学習
このK-Meansシミュレーター[こちら](https://user.ceng.metu.edu.tr/~akifakkus/courses/ceng574/k-means/)を見てみてください。このツールを使用して、サンプルデータポイントを視覚化し、そのセントロイドを決定できます。データのランダム性、クラスタの数、セントロイドの数を編集できます。これにより、データがどのようにグループ化されるかのアイデアが得られますか？
また、スタンフォードの[K-Meansに関するハンドアウト](https://stanford.edu/~cpiech/cs221/handouts/kmeans.html)も見てみてください。
## 課題
[さまざまなクラスタリング手法を試してみてください](assignment.md)
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すよう努めておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。原文が記載された母国語の文書が信頼できる情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用により生じる誤解や誤認について、当社は一切の責任を負いません。

13
translations/ja/5-Clustering/2-K-Means/assignment.md
Unescape View File

@ -1,13 +0,0 @@
# 異なるクラスタリング手法を試す
## 指示
このレッスンでは、K-Meansクラスタリングについて学びました。時には、K-Meansがあなたのデータに適していない場合もあります。これらのレッスンや他の場所からデータを使用して（ソースを明記してください）、K-Meansを使用しない別のクラスタリング手法を示すノートブックを作成してください。何を学びましたか？
## 評価基準
| 基準 | 優秀 | 適切 | 改善の余地あり |
| -------- | ------------------------------------------------------------- | -------------------------------------------------------------------- | ---------------------------- |
| | よく文書化されたクラスタリングモデルが提示されている | 十分な文書化がない、または不完全なノートブックが提示されている | 不完全な作業が提出されている |
**免責事項**:
この文書は、機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期すために努力していますが、自動翻訳には誤りや不正確さが含まれる場合があります。権威ある情報源として、元の言語で書かれた原文を参照してください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切責任を負いません。

4
translations/ja/5-Clustering/2-K-Means/solution/Julia/README.md
Unescape View File

@ -1,4 +0,0 @@
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語での文書が信頼できる情報源と見なされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤訳について、当社は一切の責任を負いません。

31
translations/ja/5-Clustering/README.md
Unescape View File

@ -1,31 +0,0 @@
# 機械学習のためのクラスタリングモデル
クラスタリングは、互いに似たオブジェクトを見つけ、それらをクラスタと呼ばれるグループにまとめる機械学習のタスクです。クラスタリングが他の機械学習のアプローチと異なるのは、すべてが自動的に行われる点です。実際、これは教師あり学習とは対極にあると言えます。
## 地域トピック: ナイジェリアの聴衆の音楽の好みに基づくクラスタリングモデル 🎧
ナイジェリアの多様な聴衆には、多様な音楽の好みがあります。Spotifyからスクレイピングされたデータを使用して（[この記事](https://towardsdatascience.com/country-wise-visual-analysis-of-music-taste-using-spotify-api-seaborn-in-python-77f5b749b421)に触発されて）、ナイジェリアで人気のある音楽を見てみましょう。このデータセットには、さまざまな曲の「ダンスしやすさ」スコア、「アコースティック性」、音量、「スピーチ性」、人気度、エネルギーに関するデータが含まれています。このデータの中にどのようなパターンが見つかるか、興味深いところです！
![ターンテーブル](../../../translated_images/turntable.f2b86b13c53302dc106aa741de9dc96ac372864cf458dd6f879119857aab01da.ja.jpg)
> 写真提供：<a href="https://unsplash.com/@marcelalaskoski?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Marcela Laskoski</a> on <a href="https://unsplash.com/s/photos/nigerian-music?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
この一連のレッスンでは、クラスタリング技術を使用してデータを分析する新しい方法を発見します。クラスタリングは、データセットにラベルがない場合に特に有用です。ラベルがある場合は、前のレッスンで学んだような分類技術の方が役立つかもしれません。しかし、ラベルのないデータをグループ化しようとしている場合、クラスタリングはパターンを発見するための優れた方法です。
> クラスタリングモデルを扱うための学習に役立つローコードツールがあります。試してみてください [Azure ML for this task](https://docs.microsoft.com/learn/modules/create-clustering-model-azure-machine-learning-designer/?WT.mc_id=academic-77952-leestott)
## レッスン
1. [クラスタリングの紹介](1-Visualize/README.md)
2. [K-Meansクラスタリング](2-K-Means/README.md)
## クレジット
これらのレッスンは🎶を持つ[Jen Looper](https://www.twitter.com/jenlooper)によって書かれ、[Rishit Dagli](https://rishit_dagli)と[Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan)の役立つレビューがありました。
[Nigerian Songs](https://www.kaggle.com/sootersaalu/nigerian-songs-spotify)データセットは、SpotifyからスクレイピングされたものとしてKaggleから入手しました。
このレッスンの作成に役立った有用なK-Meansの例には、この[iris exploration](https://www.kaggle.com/bburns/iris-exploration-pca-k-means-and-gmm-clustering)、この[introductory notebook](https://www.kaggle.com/prashant111/k-means-clustering-with-python)、およびこの[hypothetical NGO example](https://www.kaggle.com/ankandash/pca-k-means-clustering-hierarchical-clustering)が含まれています。
**免責事項**：
この文書は、機械翻訳AIサービスを使用して翻訳されています。正確性を期しておりますが、自動翻訳には誤りや不正確さが含まれる場合がありますのでご注意ください。元の言語の文書が権威ある情報源とみなされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤認について、当社は一切の責任を負いません。

168
translations/ja/6-NLP/1-Introduction-to-NLP/README.md
Unescape View File

@ -1,168 +0,0 @@
# 自然言語処理の入門
このレッスンでは、*計算言語学*の一分野である*自然言語処理*の簡単な歴史と重要な概念を紹介します。
## [講義前のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/31/)
## はじめに
NLP（自然言語処理）は、機械学習が適用され、実際のソフトウェアで使用されている最もよく知られた分野の一つです。
✅ 日常的に使用しているソフトウェアの中で、NLPが組み込まれているものを考えてみてください。例えば、ワードプロセッサやモバイルアプリなど。
このレッスンで学ぶこと：
- **言語の概念**。言語がどのように発展し、主要な研究分野が何であったか。
- **定義と概念**。コンピュータがテキストを処理する方法に関する定義と概念、例えばパーシング、文法、名詞と動詞の識別などを学びます。このレッスンにはいくつかのコーディングタスクが含まれており、次のレッスンでコーディングを学ぶための重要な概念がいくつか紹介されます。
## 計算言語学
計算言語学は、何十年にもわたる研究と開発の分野で、コンピュータが言語をどのように扱い、さらには理解し、翻訳し、コミュニケーションできるかを研究します。自然言語処理（NLP）は、コンピュータが「自然」な、つまり人間の言語をどのように処理できるかに焦点を当てた関連分野です。
### 例 - 音声入力
もし、タイピングの代わりに電話に向かって話したり、仮想アシスタントに質問をしたことがあるなら、その音声はテキスト形式に変換され、話した言語から処理または*パース*されました。検出されたキーワードは、その後、電話やアシスタントが理解し、実行できる形式に処理されました。
![理解](../../../../translated_images/comprehension.619708fc5959b0f6a24ebffba2ad7b0625391a476141df65b43b59de24e45c6f.ja.png)
> 本当の言語理解は難しい！画像提供：[Jen Looper](https://twitter.com/jenlooper)
### この技術はどのように実現されているのか？
これは、誰かがこのためのコンピュータプログラムを書いたからです。数十年前、一部のSF作家は、人々が主にコンピュータに話しかけ、コンピュータが常に彼らの意味を正確に理解するだろうと予測しました。残念ながら、これは多くの人が想像したよりも難しい問題であることが判明しました。今日では、問題ははるかに理解されていますが、文の意味を理解する際に「完璧な」自然言語処理を達成するには重大な課題があります。特に、ユーモアや皮肉などの感情を理解することは非常に難しい問題です。
この時点で、学校の授業で先生が文の文法の部分を教えたことを思い出すかもしれません。いくつかの国では、学生は文法や言語学を専用の科目として教えられますが、多くの国では、これらのトピックは言語を学ぶ一環として含まれています：小学校での最初の言語（読み書きを学ぶ）や、中学校や高校での第二言語などです。名詞と動詞や副詞と形容詞を区別するのが苦手でも心配しないでください！
*現在形*と*現在進行形*の違いに苦労している場合、それはあなた一人ではありません。これは多くの人、特にその言語のネイティブスピーカーにとっても難しいことです。良いニュースは、コンピュータは形式的なルールを適用するのが非常に得意であり、人間と同じように文を*パース*するコードを書くことを学ぶことができるということです。後で検討する大きな課題は、文の*意味*や*感情*を理解することです。
## 前提条件
このレッスンの主な前提条件は、このレッスンの言語を読んで理解できることです。数学の問題や方程式を解く必要はありません。元の著者はこのレッスンを英語で書きましたが、他の言語にも翻訳されているため、翻訳を読んでいる可能性もあります。異なる言語の文法ルールを比較するために、いくつかの異なる言語が使用される例があります。これらは翻訳されていませんが、説明文は翻訳されているため、意味は明確です。
コーディングタスクでは、Pythonを使用し、例はPython 3.8を使用しています。
このセクションで必要なのは：
- **Python 3の理解**。Python 3でのプログラミング言語の理解。このレッスンでは、入力、ループ、ファイルの読み取り、配列を使用します。
- **Visual Studio Code + 拡張機能**。Visual Studio CodeとそのPython拡張機能を使用します。または、お好みのPython IDEを使用することもできます。
- **TextBlob**。 [TextBlob](https://github.com/sloria/TextBlob) はPythonの簡易テキスト処理ライブラリです。TextBlobのサイトの指示に従ってシステムにインストールしてください（以下のようにコーパスもインストールします）：
```bash
pip install -U textblob
python -m textblob.download_corpora
```
> 💡 Tip: VS Code環境でPythonを直接実行できます。詳細は[docs](https://code.visualstudio.com/docs/languages/python?WT.mc_id=academic-77952-leestott)を参照してください。
## 機械との対話
コンピュータが人間の言語を理解しようとする歴史は数十年にわたり、自然言語処理を考えた最初の科学者の一人は*アラン・チューリング*です。
### 'チューリングテスト'
チューリングが1950年代に*人工知能*を研究していたとき、人間とコンピュータ（タイプされた通信を介して）に会話テストを行い、人間が他の人間と会話しているのかコンピュータと会話しているのかを確信できない場合を考えました。
一定の会話時間の後、人間が回答がコンピュータからのものであるかどうかを判断できなかった場合、そのコンピュータは*考えている*と言えるのでしょうか？
### インスピレーション - '模倣ゲーム'
このアイデアは、*模倣ゲーム*と呼ばれるパーティーゲームから来ました。このゲームでは、尋問者が一人部屋にいて、別の部屋にいる二人の人物（男性と女性）を識別する任務を負います。尋問者はメモを送ることができ、書かれた回答から謎の人物の性別を明らかにする質問を考えなければなりません。もちろん、別の部屋にいるプレイヤーたちは、正直に答えているように見せながら、尋問者を誤解させたり混乱させたりするような回答をすることで、尋問者を欺こうとします。
### エリザの開発
1960年代、MITの科学者*ジョセフ・ワイゼンバウム*は、[エリザ](https://wikipedia.org/wiki/ELIZA)というコンピュータ「セラピスト」を開発しました。エリザは人間に質問をし、彼らの回答を理解しているかのように見せかけました。しかし、エリザは文を解析し、特定の文法構造やキーワードを識別して合理的な回答をすることができましたが、文を*理解*しているとは言えませんでした。例えば、エリザが「**私は** <u>悲しい</u>」という形式の文を提示された場合、エリザは文の単語を並べ替え、置き換えて「**あなたは** <u>悲しい</u> 期間はどれくらいですか？」という回答を形成するかもしれません。
これは、エリザが文を理解し、続けて質問をしているかのような印象を与えましたが、実際には時制を変更し、いくつかの単語を追加していただけでした。エリザが回答するキーワードを識別できない場合、代わりに多くの異なる文に適用できるランダムな回答を返すことになります。例えば、ユーザーが「**あなたは** <u>自転車</u>」と書いた場合、エリザは「**私は** <u>自転車</u> 期間はどれくらいですか？」と回答するかもしれません。もっと合理的な回答ではなく。
[![エリザとのチャット](https://img.youtube.com/vi/RMK9AphfLco/0.jpg)](https://youtu.be/RMK9AphfLco "エリザとのチャット")
> 🎥 上の画像をクリックして、オリジナルのELIZAプログラムについてのビデオをご覧ください
> 注：1966年に公開された[エリザ](https://cacm.acm.org/magazines/1966/1/13317-elizaa-computer-program-for-the-study-of-natural-language-communication-between-man-and-machine/abstract)のオリジナルの説明を読むことができます。ACMアカウントを持っている場合、または[wikipedia](https://wikipedia.org/wiki/ELIZA)でエリザについて読むこともできます。
## 演習 - 基本的な会話ボットのコーディング
エリザのような会話ボットは、ユーザー入力を引き出し、理解しているかのように見せかけて応答するプログラムです。エリザとは異なり、私たちのボットは知的な会話をしているように見せかけるためのいくつかのルールを持っていません。代わりに、私たちのボットは、ほぼどんな些細な会話にも使えるランダムな応答を持つだけです。
### 計画
会話ボットを作成する際のステップ：
1. ユーザーにボットとの対話方法を指示するテキストを表示
2. ループを開始
1. ユーザー入力を受け取る
2. ユーザーが終了を求めた場合は終了する
3. ユーザー入力を処理し、応答を決定する（この場合、応答は可能な一般的な応答のリストからランダムに選ばれる）
4. 応答を表示する
3. ステップ2に戻る
### ボットの作成
次にボットを作成しましょう。まず、いくつかのフレーズを定義します。
1. 次のランダムな応答を持つPythonでこのボットを作成します：
```python
random_responses = ["That is quite interesting, please tell me more.",
"I see. Do go on.",
"Why do you say that?",
"Funny weather we've been having, isn't it?",
"Let's change the subject.",
"Did you catch the game last night?"]
```
以下は、参考のためのサンプル出力です（ユーザー入力は`>`で始まる行です）：
```output
Hello, I am Marvin, the simple robot.
You can end this conversation at any time by typing 'bye'
After typing each answer, press 'enter'
How are you today?
> I am good thanks
That is quite interesting, please tell me more.
> today I went for a walk
Did you catch the game last night?
> I did, but my team lost
Funny weather we've been having, isn't it?
> yes but I hope next week is better
Let's change the subject.
> ok, lets talk about music
Why do you say that?
> because I like music!
Why do you say that?
> bye
It was nice talking to you, goodbye!
```
タスクの一つの可能な解決策は[こちら](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/1-Introduction-to-NLP/solution/bot.py)です
✅ 考えてみてください
1. ランダムな応答がボットが実際に理解していると思わせることができると思いますか？
2. ボットがより効果的になるためにはどんな機能が必要ですか？
3. ボットが本当に文の意味を理解できるなら、会話の前の文の意味も「覚えて」おく必要があるでしょうか？
---
## 🚀チャレンジ
上記の「考えてみてください」の要素の一つを選び、それをコードに実装するか、擬似コードを使用して紙に解決策を書いてみてください。
次のレッスンでは、自然言語のパースと機械学習の他のアプローチについて学びます。
## [講義後のクイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/32/)
## 復習と自己学習
以下の参考文献をさらに読み進める機会としてご覧ください。
### 参考文献
1. Schubert, Lenhart, "Computational Linguistics", *The Stanford Encyclopedia of Philosophy* (Spring 2020 Edition), Edward N. Zalta (ed.), URL = <https://plato.stanford.edu/archives/spr2020/entries/computational-linguistics/>.
2. Princeton University "About WordNet." [WordNet](https://wordnet.princeton.edu/). Princeton University. 2010.
## 課題
[ボットを探す](assignment.md)
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期すよう努めておりますが、自動翻訳には誤りや不正確さが含まれる可能性があります。権威ある情報源としては、原文の言語の文書を参照してください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用により生じる誤解や誤訳については、当社は一切の責任を負いません。

14
translations/ja/6-NLP/1-Introduction-to-NLP/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# ボットを探す
## 手順
ボットはあらゆる場所に存在します。あなたの課題は、ボットを見つけて採用することです！ウェブサイト、銀行アプリケーション、そして電話で見つけることができます。例えば、金融サービス会社にアドバイスやアカウント情報を求めて電話をかけるときなどです。ボットを分析して、混乱させることができるか試してみてください。もしボットを混乱させることができたら、なぜそうなったのかを考えてみてください。その経験について短いレポートを書いてください。
## 採点基準
| 基準 | 優秀 | 適切 | 改善が必要 |
| ------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------- | --------------------- |
| | ボットのアーキテクチャを推測し、その経験を詳細に説明した1ページのレポートが書かれている | レポートが不完全であったり、十分に調査されていない | レポートが提出されていない |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確さを期していますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語で書かれた原文を権威ある情報源とみなしてください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤認については、一切の責任を負いかねます。

217
translations/ja/6-NLP/2-Tasks/README.md
Unescape View File

@ -1,217 +0,0 @@
# 一般的な自然言語処理タスクと技術
ほとんどの*自然言語処理*タスクでは、処理するテキストを分解し、調査し、その結果をルールやデータセットと照合する必要があります。これらのタスクにより、プログラマーはテキスト内の用語や単語の_意味_や_意図_、または単に_頻度_を導き出すことができます。
## [事前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/33/)
テキスト処理に使用される一般的な技術を見てみましょう。これらの技術は機械学習と組み合わせることで、大量のテキストを効率的に分析するのに役立ちます。しかし、これらのタスクにMLを適用する前に、NLPの専門家が直面する問題を理解しておきましょう。
## NLPに共通するタスク
作業中のテキストを分析する方法はいくつかあります。これらのタスクを実行することで、テキストの理解を深め、結論を導き出すことができます。通常、これらのタスクは一連の手順で行います。
### トークン化
おそらくほとんどのNLPアルゴリズムが最初に行うことは、テキストをトークンや単語に分割することです。これが簡単に思えるかもしれませんが、句読点や異なる言語の単語や文の区切りを考慮する必要があるため、難しくなることがあります。区切りを判断するためにさまざまな方法を使用する必要があるかもしれません。
![tokenization](../../../../translated_images/tokenization.1641a160c66cd2d93d4524e8114e93158a9ce0eba3ecf117bae318e8a6ad3487.ja.png)
> **高慢と偏見**からの文をトークン化する。インフォグラフィック提供：[Jen Looper](https://twitter.com/jenlooper)
### 埋め込み
[単語の埋め込み](https://wikipedia.org/wiki/Word_embedding)は、テキストデータを数値的に変換する方法です。埋め込みは、意味が似ている単語や一緒に使われる単語がクラスターとして集まるように行われます。
![word embeddings](../../../../translated_images/embedding.2cf8953c4b3101d188c2f61a5de5b6f53caaa5ad4ed99236d42bc3b6bd6a1fe2.ja.png)
> "I have the highest respect for your nerves, they are my old friends." - **高慢と偏見**の文に対する単語の埋め込み。インフォグラフィック提供：[Jen Looper](https://twitter.com/jenlooper)
✅ [この興味深いツール](https://projector.tensorflow.org/)を試して、単語の埋め込みを実験してみてください。ある単語をクリックすると、似た単語のクラスターが表示されます：'toy'は'disney', 'lego', 'playstation', 'console'とクラスターを形成します。
### 解析と品詞タグ付け
トークン化されたすべての単語は、名詞、動詞、形容詞などの品詞としてタグ付けされます。文 `the quick red fox jumped over the lazy brown dog` は、fox = 名詞、jumped = 動詞として品詞タグ付けされるかもしれません。
![parsing](../../../../translated_images/parse.d0c5bbe1106eae8fe7d60a183cd1736c8b6cec907f38000366535f84f3036101.ja.png)
> **高慢と偏見**からの文を解析する。インフォグラフィック提供：[Jen Looper](https://twitter.com/jenlooper)
解析とは、文中のどの単語が互いに関連しているかを認識することです。例えば、`the quick red fox jumped` は形容詞-名詞-動詞のシーケンスであり、`lazy brown dog` シーケンスとは別です。
### 単語とフレーズの頻度
大規模なテキストを分析する際に有用な手法は、興味のあるすべての単語やフレーズの辞書を作成し、それがどのくらいの頻度で出現するかを記録することです。フレーズ `the quick red fox jumped over the lazy brown dog` は、the の単語頻度が2です。
単語の頻度をカウントする例文を見てみましょう。ラドヤード・キップリングの詩「The Winners」には次の節があります：
```output
What the moral? Who rides may read.
When the night is thick and the tracks are blind
A friend at a pinch is a friend, indeed,
But a fool to wait for the laggard behind.
Down to Gehenna or up to the Throne,
He travels the fastest who travels alone.
```
フレーズの頻度は、大文字小文字を区別する場合や区別しない場合があります。フレーズ `a friend` has a frequency of 2 and `the` has a frequency of 6, and `travels` は2です。
### N-gram
テキストは、一定の長さの単語のシーケンスに分割できます。単一の単語（ユニグラム）、2つの単語（バイグラム）、3つの単語（トライグラム）または任意の数の単語（n-gram）です。
例えば、`the quick red fox jumped over the lazy brown dog` を2-gramスコアで分割すると、次のn-gramが生成されます：
1. the quick
2. quick red
3. red fox
4. fox jumped
5. jumped over
6. over the
7. the lazy
8. lazy brown
9. brown dog
これは文の上にスライドするボックスとして視覚化するのが簡単かもしれません。3単語のn-gramの場合、各文でn-gramが太字で示されています：
1. <u>**the quick red**</u> fox jumped over the lazy brown dog
2. the **<u>quick red fox</u>** jumped over the lazy brown dog
3. the quick **<u>red fox jumped</u>** over the lazy brown dog
4. the quick red **<u>fox jumped over</u>** the lazy brown dog
5. the quick red fox **<u>jumped over the</u>** lazy brown dog
6. the quick red fox jumped **<u>over the lazy</u>** brown dog
7. the quick red fox jumped over <u>**the lazy brown**</u> dog
8. the quick red fox jumped over the **<u>lazy brown dog</u>**
![n-grams sliding window](../../../../6-NLP/2-Tasks/images/n-grams.gif)
> N-gram値3: インフォグラフィック提供：[Jen Looper](https://twitter.com/jenlooper)
### 名詞句抽出
ほとんどの文には、主語または目的語としての名詞があります。英語では、しばしば 'a' や 'an' または 'the' が前に置かれていることで識別できます。文の意味を理解しようとする際に、名詞句を抽出して文の主語または目的語を特定することは、NLPで一般的なタスクです。
✅ "I cannot fix on the hour, or the spot, or the look or the words, which laid the foundation. It is too long ago. I was in the middle before I knew that I had begun." という文で、名詞句を特定できますか？
文 `the quick red fox jumped over the lazy brown dog` には、2つの名詞句があります：**quick red fox** と **lazy brown dog**。
### 感情分析
文やテキストは、その*ポジティブ*または*ネガティブ*な感情を分析することができます。感情は*極性*および*客観性/主観性*で測定されます。極性は-1.0から1.0（ネガティブからポジティブ）で測定され、0.0から1.0（最も客観的から最も主観的）で測定されます。
✅ 後で、機械学習を使用して感情を判定するさまざまな方法を学びますが、一つの方法は、ポジティブまたはネガティブに分類された単語やフレーズのリストを人間の専門家が作成し、そのモデルをテキストに適用して極性スコアを計算することです。この方法がどのように機能するか、またはうまく機能しない場合があるかを理解できますか？
### 屈折
屈折は、単語を取り、その単語の単数形または複数形を取得することを可能にします。
### レンマ化
*レンマ*は、一連の単語の根本または主要な単語です。例えば、*flew*, *flies*, *flying* は動詞 *fly* のレンマです。
NLP研究者にとって有用なデータベースもあります。特に：
### WordNet
[WordNet](https://wordnet.princeton.edu/)は、異なる言語のすべての単語の同義語、反義語、およびその他の詳細を含むデータベースです。翻訳、スペルチェッカー、または任意の種類の言語ツールを構築する際に非常に役立ちます。
## NLPライブラリ
幸いなことに、これらの技術をすべて自分で構築する必要はありません。自然言語処理や機械学習に特化していない開発者にもアクセスしやすくする優れたPythonライブラリがあります。次のレッスンではこれらの例をさらに紹介しますが、ここでは次のタスクに役立ついくつかの有用な例を学びます。
### 演習 - `TextBlob` library
Let's use a library called TextBlob as it contains helpful APIs for tackling these types of tasks. TextBlob "stands on the giant shoulders of [NLTK](https://nltk.org) and [pattern](https://github.com/clips/pattern), and plays nicely with both." It has a considerable amount of ML embedded in its API.
> Note: A useful [Quick Start](https://textblob.readthedocs.io/en/dev/quickstart.html#quickstart) guide is available for TextBlob that is recommended for experienced Python developers
When attempting to identify *noun phrases*, TextBlob offers several options of extractors to find noun phrases.
1. Take a look at `ConllExtractor`を使用する
```python
from textblob import TextBlob
from textblob.np_extractors import ConllExtractor
# import and create a Conll extractor to use later
extractor = ConllExtractor()
# later when you need a noun phrase extractor:
user_input = input("> ")
user_input_blob = TextBlob(user_input, np_extractor=extractor) # note non-default extractor specified
np = user_input_blob.noun_phrases
```
> ここで何が起こっているのか？ [ConllExtractor](https://textblob.readthedocs.io/en/dev/api_reference.html?highlight=Conll#textblob.en.np_extractors.ConllExtractor) は「ConLL-2000トレーニングコーパスで訓練されたチャンク解析を使用する名詞句抽出器」です。ConLL-2000は、2000年の計算言語学学習に関する会議を指します。毎年、この会議は難解なNLP問題に取り組むワークショップを開催しており、2000年には名詞チャンクに焦点を当てました。モデルはWall Street Journalで訓練され、「セクション15-18を訓練データ（211727トークン）として使用し、セクション20をテストデータ（47377トークン）として使用しました」。使用された手順は[こちら](https://www.clips.uantwerpen.be/conll2000/chunking/)で、[結果](https://ifarm.nl/erikt/research/np-chunking.html)を確認できます。
### チャレンジ - NLPでボットを改良する
前のレッスンでは、非常にシンプルなQ&Aボットを作成しました。今回は、入力の感情を分析して感情に応じた応答を出力することで、マーヴィンを少し共感的にします。また、`noun_phrase`を特定し、そのトピックについてさらに入力を求める必要があります。
より良い会話ボットを構築する際の手順：
1. ユーザーにボットとの対話方法を指示する
2. ループを開始する
1. ユーザー入力を受け取る
2. ユーザーが終了を求めた場合は終了する
3. ユーザー入力を処理し、適切な感情応答を決定する
4. 感情に名詞句が含まれている場合、その名詞句を複数形にしてそのトピックについてさらに入力を求める
5. 応答を出力する
3. ステップ2に戻る
TextBlobを使用して感情を判定するコードスニペットはこちらです。感情応答の*勾配*は4つしかありません（もっと増やしても構いません）：
```python
if user_input_blob.polarity <= -0.5:
response = "Oh dear, that sounds bad. "
elif user_input_blob.polarity <= 0:
response = "Hmm, that's not great. "
elif user_input_blob.polarity <= 0.5:
response = "Well, that sounds positive. "
elif user_input_blob.polarity <= 1:
response = "Wow, that sounds great. "
```
以下は参考となるサンプル出力です（ユーザー入力は>で始まる行です）：
```output
Hello, I am Marvin, the friendly robot.
You can end this conversation at any time by typing 'bye'
After typing each answer, press 'enter'
How are you today?
> I am ok
Well, that sounds positive. Can you tell me more?
> I went for a walk and saw a lovely cat
Well, that sounds positive. Can you tell me more about lovely cats?
> cats are the best. But I also have a cool dog
Wow, that sounds great. Can you tell me more about cool dogs?
> I have an old hounddog but he is sick
Hmm, that's not great. Can you tell me more about old hounddogs?
> bye
It was nice talking to you, goodbye!
```
タスクの一つの解決策は[こちら](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/2-Tasks/solution/bot.py)です。
✅ 知識チェック
1. 共感的な応答が、ボットが実際に理解していると人を「騙す」ことができると思いますか？
2. 名詞句を特定することで、ボットがより「信じられる」ものになりますか？
3. 文から名詞句を抽出することが有用な理由は何ですか？
---
前の知識チェックでボットを実装し、友人にテストしてみてください。それが彼らを騙すことができますか？ボットをもっと「信じられる」ものにすることができますか？
## 🚀チャレンジ
前の知識チェックでのタスクを実装してみてください。ボットを友人にテストしてみてください。それが彼らを騙すことができますか？ボットをもっと「信じられる」ものにすることができますか？
## [事後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/34/)
## レビュー＆自習
次のいくつかのレッスンでは、感情分析についてさらに学びます。この記事のようなものを読んで、この興味深い技術を研究してみてください。[KDNuggets](https://www.kdnuggets.com/tag/nlp)
## 課題
[Make a bot talk back](assignment.md)
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期しておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご理解ください。権威ある情報源としては、元の言語で書かれた原文を参照してください。重要な情報については、専門の人間による翻訳を推奨します。この翻訳の使用に起因する誤解や誤認については、当方は一切の責任を負いません。

14
translations/ja/6-NLP/2-Tasks/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# ボットに返答させる
## 手順
過去のレッスンで、チャットするための基本的なボットをプログラムしました。このボットは「bye」と言うまでランダムな返答をします。返答を少しだけランダムでなくし、「why」や「how」のような特定の言葉を言った場合に返答をトリガーすることはできますか？ボットを拡張する際に、このタイプの作業をいかに機械学習が手動でなくするかを少し考えてみてください。NLTKやTextBlobライブラリを使用してタスクを簡単にすることができます。
## 評価基準
| 基準 | 優秀 | 適切 | 改善が必要 |
| -------- | --------------------------------------------- | ---------------------------------------------- | ----------------------- |
| | 新しいbot.pyファイルが提示され、文書化されている | 新しいボットファイルが提示されているがバグが含まれている | ファイルが提示されていない |
**免責事項**：
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期すよう努めておりますが、自動翻訳には誤りや不正確さが含まれる可能性があることをご承知おきください。原文の言語で書かれた文書が正式な情報源とみなされるべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解について、当社は責任を負いません。

188
translations/ja/6-NLP/3-Translation-Sentiment/README.md
Unescape View File

@ -1,188 +0,0 @@
# 機械学習を使った翻訳と感情分析
前回のレッスンでは、`TextBlob` を使って基本的なボットを構築する方法を学びました。このライブラリは、名詞句の抽出などの基本的な自然言語処理タスクを実行するために、裏で機械学習を利用しています。計算言語学におけるもう一つの重要な課題は、ある言語から別の言語への正確な _翻訳_ です。
## [講義前クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/35/)
翻訳は非常に難しい問題であり、これは数千もの言語が存在し、それぞれが非常に異なる文法規則を持つためです。一つのアプローチは、英語のような言語の正式な文法規則を非言語依存の構造に変換し、次に別の言語に変換することです。このアプローチでは、次のステップを踏むことになります：
1. **識別**。入力言語の単語を名詞、動詞などにタグ付けする。
2. **翻訳の作成**。ターゲット言語の形式で各単語の直接的な翻訳を生成する。
### 英語からアイルランド語への例文
英語では、_I feel happy_ という文は次の3つの単語で構成されています：
- **主語** (I)
- **動詞** (feel)
- **形容詞** (happy)
しかし、アイルランド語では、同じ文は非常に異なる文法構造を持っています。感情は「*あなたの上に*」あると表現されます。
英語のフレーズ `I feel happy` をアイルランド語にすると `Tá athas orm` となります。*直訳* すると `Happy is upon me` です。
アイルランド語の話者が英語に翻訳する場合、`I feel happy` と言うでしょう。`Happy is upon me` とは言いません。なぜなら、彼らは文の意味を理解しているからです。単語や文の構造が異なっていてもです。
アイルランド語の文の正式な順序は：
- **動詞** (Tá または is)
- **形容詞** (athas または happy)
- **主語** (orm または upon me)
## 翻訳
単純な翻訳プログラムは、文の構造を無視して単語だけを翻訳するかもしれません。
✅ 第二言語（または第三言語以上）を大人になってから学んだことがある場合、最初は母国語で考え、概念を頭の中で一語ずつ第二言語に翻訳し、それを話すことから始めたかもしれません。これは単純な翻訳コンピュータープログラムが行っていることと似ています。この段階を超えて流暢さを達成することが重要です！
単純な翻訳は、悪い（時には面白い）誤訳を引き起こします。`I feel happy` はアイルランド語では `Mise bhraitheann athas` と直訳されます。これは（直訳すると）`me feel happy` という意味で、有効なアイルランド語の文ではありません。英語とアイルランド語は隣接する島で話される言語ですが、非常に異なる文法構造を持っています。
> アイルランドの言語伝統についてのビデオをいくつか見ることができます。例えば [こちら](https://www.youtube.com/watch?v=mRIaLSdRMMs)
### 機械学習のアプローチ
これまでのところ、自然言語処理の形式的な規則アプローチについて学びました。もう一つのアプローチは、単語の意味を無視し、_代わりにパターンを検出するために機械学習を使用する_ ことです。これには、元の言語とターゲット言語の両方で大量のテキスト（*コーパス*）またはテキスト（*コーパス*）が必要です。
例えば、1813年にジェーン・オースティンによって書かれた有名な英語の小説『高慢と偏見』を考えてみましょう。英語の本とその*フランス語*の人間による翻訳を参照すると、ある言語のフレーズが他の言語に*イディオム的に*翻訳されていることがわかります。すぐにそれを行います。
例えば、英語のフレーズ `I have no money` をフランス語に直訳すると、`Je n'ai pas de monnaie` になるかもしれません。"Monnaie" はフランス語の 'false cognate' で、'money' と 'monnaie' は同義ではありません。人間が行うより良い翻訳は `Je n'ai pas d'argent` で、これはお金がないという意味をよりよく伝えます（'monnaie' の意味は '小銭' です）。
![monnaie](../../../../translated_images/monnaie.606c5fa8369d5c3b3031ef0713e2069485c87985dd475cd9056bdf4c76c1f4b8.ja.png)
> 画像提供 [Jen Looper](https://twitter.com/jenlooper)
十分な人間による翻訳がある場合、MLモデルは以前に専門家の人間が翻訳したテキストの一般的なパターンを特定することにより、翻訳の精度を向上させることができます。
### 演習 - 翻訳
`TextBlob` を使用して文章を翻訳できます。**高慢と偏見**の有名な最初の一文を試してみてください：
```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` は翻訳でかなり良い仕事をします："C'est une vérité universellement reconnue, qu'un homme célibataire en possession d'une bonne fortune doit avoir besoin d'une femme!"。
`TextBlob` の翻訳は、実際には1932年にV. Leconteと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 egard, 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."
この場合、機械学習による翻訳は、原作者の言葉を不必要に追加している人間の翻訳者よりも良い仕事をしています。
> ここで何が起こっているのでしょうか？そしてなぜ`TextBlob`は翻訳がこんなに上手いのでしょうか？実は、背後ではGoogle翻訳を使用しており、何百万ものフレーズを解析して最適な文字列を予測する高度なAIが動作しています。ここでは手動の操作は一切行われておらず、`blob.translate` を使用するにはインターネット接続が必要です。
## 感情分析
次に、機械学習を使用してテキストの感情を分析する方法を見てみましょう。
> **例**: "Great, that was a wonderful waste of time, I'm glad we are lost on this dark road" は皮肉で否定的な感情の文ですが、単純なアルゴリズムは 'great', 'wonderful', 'glad' を肯定的として検出し、'waste', 'lost' および 'dark' を否定的として検出します。全体の感情はこれらの相反する単語によって揺れ動きます。
✅ 人間の話者として皮肉をどのように伝えるかについて少し考えてみてください。声のイントネーションが大きな役割を果たします。"Well, that film was awesome" というフレーズを異なる方法で言ってみて、声がどのように意味を伝えるかを発見してみてください。
### 機械学習のアプローチ
機械学習のアプローチは、否定的および肯定的なテキストのコーパスを手動で収集することです。ツイート、映画のレビュー、または人間がスコアと意見を書いたものなら何でも構いません。その後、意見とスコアにNLP技術を適用し、パターンを見つけます（例えば、肯定的な映画レビューには 'Oscar worthy' というフレーズが否定的な映画レビューよりも多く含まれる傾向がある、または肯定的なレストランレビューには 'gourmet' という言葉が 'disgusting' よりも多く含まれる）。
> ⚖️ **例**: 政治家のオフィスで働いていて、新しい法律が議論されている場合、有権者はその特定の新しい法律を支持するメールや反対するメールをオフィスに送るかもしれません。あなたがそのメールを読んで、*賛成* と *反対* に分けるように任命されたとしましょう。メールがたくさんあれば、すべてを読むのは大変です。ボットがすべてのメールを読んで、理解し、どの山に属するかを教えてくれたら素晴らしいと思いませんか？
>
> これを実現する一つの方法は、機械学習を使用することです。モデルを*反対*のメールの一部と*賛成*のメールの一部で訓練します。モデルは、反対側または賛成側のメールに特定のフレーズや単語が現れる可能性が高いことを関連付ける傾向がありますが、*内容を理解することはありません*。モデルを訓練に使用していないメールでテストし、同じ結論に達するかどうかを確認できます。モデルの精度に満足したら、今後のメールを読むことなく処理できます。
✅ 以前のレッスンで使用したプロセスと似ていると思いますか？
## 演習 - 感情的な文章
感情は -1 から 1 の*極性*で測定されます。-1 は最も否定的な感情を示し、1 は最も肯定的な感情を示します。また、感情は客観性 (0) と主観性 (1) のスコアで測定されます。
ジェーン・オースティンの『高慢と偏見』をもう一度見てみましょう。テキストは [Project Gutenberg](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) で利用可能です。以下のサンプルは、本の最初と最後の文章の感情を分析し、その感情の極性と主観性/客観性のスコアを表示する短いプログラムを示しています。
以下のタスクでは、`sentiment` を決定するために `TextBlob` ライブラリ（上記で説明）を使用する必要があります（独自の感情計算機を書く必要はありません）。
```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))
```
次のような出力が表示されます：
```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)
```
## チャレンジ - 感情の極性をチェック
あなたのタスクは、感情の極性を使用して、『高慢と偏見』が絶対的に肯定的な文章が絶対的に否定的な文章より多いかどうかを判断することです。このタスクでは、極性スコアが 1 または -1 である場合、それぞれ絶対的に肯定的または否定的であると仮定できます。
**ステップ:**
1. Project Gutenberg から [高慢と偏見のコピー](https://www.gutenberg.org/files/1342/1342-h/1342-h.htm) を .txt ファイルとしてダウンロードします。ファイルの最初と最後のメタデータを削除し、元のテキストのみを残します。
2. Pythonでファイルを開き、内容を文字列として抽出します。
3. 本の文字列を使用して TextBlob を作成します。
4. 本の各文章をループで分析します。
1. 極性が 1 または -1 の場合、文章を肯定的または否定的なメッセージの配列またはリストに保存します。
5. 最後に、肯定的な文章と否定的な文章（別々に）およびそれぞれの数を出力します。
サンプルの[解決策](https://github.com/microsoft/ML-For-Beginners/blob/main/6-NLP/3-Translation-Sentiment/solution/notebook.ipynb)はこちらです。
✅ 知識チェック
1. 感情は文中で使用される単語に基づいていますが、コードは単語を*理解*していますか？
2. 感情の極性が正確だと思いますか、つまり、スコアに*同意*しますか？
1. 特に、次の文章の絶対的な**肯定的**極性に同意しますか、それとも反対しますか？
* “What an excellent father you have, girls!” said she, when the door was shut.
* “Your examination of Mr. Darcy is over, I presume,” said Miss Bingley; “and pray what is the result?” “I am perfectly convinced by it that Mr. Darcy has no defect.
* How wonderfully these sort of things occur!
* I have the greatest dislike in the world to that sort of thing.
* Charlotte is an excellent manager, I dare say.
* “This is delightful indeed!
* I am so happy!
* Your idea of the ponies is delightful.
2. 次の3つの文章は絶対的に肯定的な感情でスコアリングされましたが、よく読むと肯定的な文章ではありません。なぜ感情分析はそれらを肯定的な文章だと思ったのでしょうか？
* Happy shall I be, when his stay at Netherfield is over!” “I wish I could say anything to comfort you,” replied Elizabeth; “but it is wholly out of my power.
* If I could but see you as happy!
* Our distress, my dear Lizzy, is very great.
3. 次の文章の絶対的な**否定的**極性に同意しますか、それとも反対しますか？
- Everybody is disgusted with his pride.
- “I should like to know how he behaves among strangers.” “You shall hear then—but prepare yourself for something very dreadful.
- The pause was to Elizabeth’s feelings dreadful.
- It would be dreadful!
✅ ジェーン・オースティンのファンなら、彼女がしばしば自分の本を使ってイギリスのリージェンシー社会のより滑稽な側面を批判していることを理解しているでしょう。『高慢と偏見』の主人公であるエリザベス・ベネットは、鋭い社会観察者であり（著者と同様）、彼女の言葉はしばしば非常に微妙です。物語のラブインタレストであるダルシー氏でさえ、エリザベスの遊び心とからかいの言葉の使い方に気づいています。「あなたが時折、自分の意見ではないことを表明することを楽しんでいることを知っています。」
---
## 🚀チャレンジ
ユーザー入力から他の特徴を抽出して、Marvinをさらに改善できますか？
## [講義後クイズ](https://gray-sand-07a10f403.1.azurestaticapps.net/quiz/36/)
## 復習 & 自習
テキストから感情を抽出する方法はたくさんあります。この技術を利用するビジネスアプリケーションについて考えてみてください。また、どのように誤って使用される可能性があるかについても考えてみてください。感情を分析する洗練されたエンタープライズ対応のシステムについてさらに詳しく読みましょう。例えば、[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) などです。上記の『高慢と偏見』の文章のいくつかをテストして、ニュアンスを検出できるかどうかを確認してみてください。
## 課題
[Poetic license](assignment.md)
**免責事項**:
この文書は機械翻訳AIサービスを使用して翻訳されています。正確さを期すよう努めていますが、自動翻訳には誤りや不正確さが含まれる可能性があります。元の言語で書かれた原文を信頼できる情報源としてください。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用により生じた誤解や誤認について、当方は一切の責任を負いません。

14
translations/ja/6-NLP/3-Translation-Sentiment/assignment.md
Unescape View File

@ -1,14 +0,0 @@
# 詩的ライセンス
## 指示
[このノートブック](https://www.kaggle.com/jenlooper/emily-dickinson-word-frequency)では、Azureテキスト分析を使用して感情分析された500以上のエミリー・ディキンソンの詩を見つけることができます。このデータセットを使用して、レッスンで説明された技術を使用して分析してください。詩の推奨される感情は、より高度なAzureサービスの判断と一致しますか？あなたの意見では、なぜそうなのか、なぜそうでないのか？何か驚いたことはありますか？
## ルーブリック
| 基準 | 模範的 | 適切 | 改善が必要 |
| -------- | -------------------------------------------------------------------------- | --------------------------------------------------- | ------------------------ |
| | 著者のサンプル出力のしっかりとした分析が含まれるノートブックが提示されている | ノートブックが不完全または分析を行っていない | ノートブックが提示されていない |
**免責事項**:
この文書は機械ベースのAI翻訳サービスを使用して翻訳されています。正確性を期していますが、自動翻訳には誤りや不正確さが含まれる場合があります。元の言語で書かれた文書を権威ある情報源と見なすべきです。重要な情報については、専門の人間による翻訳をお勧めします。この翻訳の使用に起因する誤解や誤解について、当社は一切の責任を負いません。

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save