Shimon Lyons
4 years ago
committed by
GitHub
commit
8f4dfeef3f
@ -0,0 +1,109 @@
|
|||||||
|
# Introduction au machine learning
|
||||||
|
|
||||||
|
[](https://youtu.be/lTd9RSxS9ZE "ML, AI, deep learning - What's the difference?")
|
||||||
|
|
||||||
|
> 🎥 Cliquer sur l'image ci-dessus afin de regarder une vidéo expliquant la différence entre machine learning, AI et deep learning.
|
||||||
|
|
||||||
|
## [Quiz préalable](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/1?loc=fr)
|
||||||
|
|
||||||
|
### Introduction
|
||||||
|
|
||||||
|
Bienvenue à ce cours sur le machine learning classique pour débutant ! Que vous soyez complètement nouveau sur ce sujet ou que vous soyez un professionnel du ML expérimenté cherchant à peaufiner vos connaissances, nous sommes heureux de vous avoir avec nous ! Nous voulons créer un tremplin chaleureux pour vos études en ML et serions ravis d'évaluer, de répondre et d'apprendre de vos retours d'[expériences](https://github.com/microsoft/ML-For-Beginners/discussions).
|
||||||
|
|
||||||
|
[](https://youtu.be/h0e2HAPTGF4 "Introduction to ML")
|
||||||
|
|
||||||
|
> 🎥 Cliquer sur l'image ci-dessus afin de regarder une vidéo: John Guttag du MIT introduit le machine learning
|
||||||
|
### Débuter avec le machine learning
|
||||||
|
|
||||||
|
Avant de commencer avec ce cours, vous aurez besoin d'un ordinateur configuré et prêt à faire tourner des notebooks (jupyter) localement.
|
||||||
|
|
||||||
|
- **Configurer votre ordinateur avec ces vidéos**. Apprendre comment configurer votre ordinateur avec cette [série de vidéos](https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6).
|
||||||
|
- **Apprendre Python**. Il est aussi recommandé d'avoir une connaissance basique de [Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-15963-cxa), un langage de programmaton utile pour les data scientist que nous utilisons tout au long de ce cours.
|
||||||
|
- **Apprendre Node.js et Javascript**. Nous utilisons aussi Javascript par moment dans ce cours afin de construire des applications WEB, vous aurez donc besoin de [node](https://nodejs.org) et [npm](https://www.npmjs.com/) installé, ainsi que de [Visual Studio Code](https://code.visualstudio.com/) pour développer en Python et Javascript.
|
||||||
|
- **Créer un compte GitHub**. Comme vous nous avez trouvé sur [GitHub](https://github.com), vous y avez sûrement un compte, mais si non, créez en un et répliquez ce cours afin de l'utiliser à votre grés. (N'oublier pas de nous donner une étoile aussi 😊)
|
||||||
|
- **Explorer Scikit-learn**. Familiariser vous avec [Scikit-learn](https://scikit-learn.org/stable/user_guide.html), un ensemble de librairies ML que nous mentionnons dans nos leçons.
|
||||||
|
|
||||||
|
### Qu'est-ce que le machine learning
|
||||||
|
|
||||||
|
Le terme `machine learning` est un des mots les plus populaire et le plus utilisé ces derniers temps. Il y a une probabilité accrue que vous l'ayez entendu au moins une fois si vous avez une appétence pour la technologie indépendamment du domaine dans lequel vous travaillez. Le fonctionnement du machine learning, cependant, reste un mystère pour la plupart des personnes. Pour un débutant en machine learning, le sujet peut nous submerger. Ainsi, il est important de comprendre ce qu'est le machine learning et de l'apprendre petit à petit au travers d'exemples pratiques.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> Google Trends montre la récente 'courbe de popularité' pour le mot 'machine learning'
|
||||||
|
|
||||||
|
Nous vivons dans un univers rempli de mystères fascinants. De grands scientifiques comme Stephen Hawking, Albert Einstein et pleins d'autres ont dévoués leur vie à la recherche d'informations utiles afin de dévoiler les mystères qui nous entourent. C'est la condition humaine pour apprendre : un enfant apprend de nouvelles choses et découvre la structure du monde année après année jusqu'à qu'ils deviennent adultes.
|
||||||
|
|
||||||
|
Le cerveau d'un enfant et ses sens perçoivent l'environnement qui les entourent et apprennent graduellement des schémas non observés de la vie qui vont l'aider à fabriquer des règles logiques afin d'identifier les schémas appris. Le processus d'apprentissage du cerveau humain est ce que rend les hommes comme la créature la plus sophistiquée du monde vivant. Apprendre continuellement par la découverte de schémas non observés et ensuite innover sur ces schémas nous permet de nous améliorer tout au long de notre vie. Cette capacité d'apprendre et d'évoluer est liée au concept de [plasticité neuronale](https://www.simplypsychology.org/brain-plasticity.html), nous pouvons tirer quelques motivations similaires entre le processus d'apprentissage du cerveau humain et le concept de machine learning.
|
||||||
|
|
||||||
|
Le [cerveau humain](https://www.livescience.com/29365-human-brain.html) perçoit des choses du monde réel, assimile les informations perçues, fait des décisions rationnelles et entreprend certaines actions selon le contexte. C'est ce que l'on appelle se comporter intelligemment. Lorsque nous programmons une reproduction du processus de ce comportement à une machine, c'est ce que l'on appelle intelligence artificielle (IA).
|
||||||
|
|
||||||
|
Bien que le terme peut être confu, machine learning (ML) est un important sous-ensemble de l'intelligence artificielle. **ML se réfère à l'utilisation d'algorithmes spécialisés afin de découvrir des informations utiles et de trouver des schémas non observés depuis des données perçues pour corroborer un processus de décision rationnel**.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> Un diagramme montrant les relations entre AI, ML, deep learning et data science. Infographie par [Jen Looper](https://twitter.com/jenlooper) et inspiré par [ce graphique](https://softwareengineering.stackexchange.com/questions/366996/distinction-between-ai-ml-neural-networks-deep-learning-and-data-mining)
|
||||||
|
|
||||||
|
## Ce que vous allez apprendre dans ce cours
|
||||||
|
|
||||||
|
Dans ce cours, nous allons nous concentrer sur les concepts clés du machine learning qu'un débutant se doit de connaître. Nous parlerons de ce que l'on appelle le 'machine learning classique' en utilisant principalement Scikit-learn, une excellente librairie que beaucoup d'étudiants utilisent afin d'apprendre les bases. Afin de comprendre les concepts plus larges de l'intelligence artificielle ou du deep learning, une profonde connaissance en machine learning est indispensable, et c'est ce que nous aimerions fournir ici.
|
||||||
|
|
||||||
|
Dans ce cours, vous allez apprendre :
|
||||||
|
|
||||||
|
- Les concepts clés du machine learning
|
||||||
|
- L'histoire du ML
|
||||||
|
- ML et équité (fairness)
|
||||||
|
- Les techniques de régression ML
|
||||||
|
- Les techniques de classification ML
|
||||||
|
- Les techniques de regroupement (clustering) ML
|
||||||
|
- Les techniques du traitement automatique des langues (NLP) ML
|
||||||
|
- Les techniques de prédictions à partir de séries chronologiques ML
|
||||||
|
- Apprentissage renforcé
|
||||||
|
- D'applications réels du ML
|
||||||
|
|
||||||
|
## Ce que nous ne couvrirons pas
|
||||||
|
|
||||||
|
- Deep learning
|
||||||
|
- Neural networks
|
||||||
|
- IA
|
||||||
|
|
||||||
|
Afin d'avoir la meilleur expérience d'apprentissage, nous éviterons les complexités des réseaux neuronaux, du 'deep learning' (construire un modèle utilisant plusieurs couches de réseaux neuronaux) et IA, dont nous parlerons dans un cours différent. Nous offirons aussi un cours à venir sur la data science pour concentrer sur cet aspect de champs très large.
|
||||||
|
|
||||||
|
## Pourquoi etudier le machine learning ?
|
||||||
|
|
||||||
|
Le machine learning, depuis une perspective systémique, est défini comme la création de systèmes automatiques pouvant apprendre des schémas non observés depuis des données afin d'aider à prendre des décisions intelligentes.
|
||||||
|
|
||||||
|
Ce but est faiblement inspiré de la manière dont le cerveau humain apprend certaines choses depuis les données qu'il perçoit du monde extérieur.
|
||||||
|
|
||||||
|
✅ Penser une minute aux raisons qu'une entreprise aurait d'essayer d'utiliser des stratégies de machine learning au lieu de créer des règles codés en dur.
|
||||||
|
|
||||||
|
### Les applications du machine learning
|
||||||
|
|
||||||
|
Les applications du machine learning sont maintenant pratiquement partout, et sont aussi omniprésentes que les données qui circulent autour de notre société (générés par nos smartphones, appareils connectés ou autres systèmes). En prenant en considération l'immense potentiel des algorithmes dernier cri de machine learning, les chercheurs ont pu exploités leurs capacités afin de résoudre des problèmes multidimensionnels et interdisciplinaires de la vie avec d'important retours positifs
|
||||||
|
|
||||||
|
**Vous pouvez utiliser le machine learning de plusieurs manières** :
|
||||||
|
|
||||||
|
- Afin de prédire la possibilité d'avoir une maladie à partir des données médicales d'un patient.
|
||||||
|
- Pour tirer parti des données météorologiques afin de prédire les événements météorologiques.
|
||||||
|
- Afin de comprendre le sentiment d'un texte.
|
||||||
|
- Afin de détecter les fake news pour stopper la propagation de la propagande.
|
||||||
|
|
||||||
|
La finance, l'économie, les sciences de la terre, l'exploration spatiale, le génie biomédical, les sciences cognitives et même les domaines des sciences humaines ont adapté le machine learning pour résoudre les problèmes ardus et lourds de traitement des données dans leur domaine respectif.
|
||||||
|
|
||||||
|
Le machine learning automatise le processus de découverte de modèles en trouvant des informations significatives à partir de données réelles ou générées. Il s'est avéré très utile dans les applications commerciales, de santé et financières, entre autres.
|
||||||
|
|
||||||
|
Dans un avenir proche, comprendre les bases du machine learning sera indispensable pour les personnes de tous les domaines en raison de son adoption généralisée.
|
||||||
|
|
||||||
|
---
|
||||||
|
## 🚀 Challenge
|
||||||
|
|
||||||
|
Esquisser, sur papier ou à l'aide d'une application en ligne comme [Excalidraw](https://excalidraw.com/), votre compréhension des différences entre l'IA, le ML, le deep learning et la data science. Ajouter quelques idées de problèmes que chacune de ces techniques est bonne à résoudre.
|
||||||
|
|
||||||
|
## [Quiz de validation des connaissances](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/2?loc=fr)
|
||||||
|
|
||||||
|
## Révision et auto-apprentissage
|
||||||
|
|
||||||
|
Pour en savoir plus sur la façon dont vous pouvez utiliser les algorithmes de ML dans le cloud, suivez ce [Parcours d'apprentissage](https://docs.microsoft.com/learn/paths/create-no-code-predictive-models-azure-machine-learning/?WT.mc_id=academic-15963-cxa).
|
||||||
|
|
||||||
|
## Devoir
|
||||||
|
|
||||||
|
[Être opérationnel](assignment.fr.md)
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
# Être opérationnel
|
||||||
|
|
||||||
|
|
||||||
|
## Instructions
|
||||||
|
|
||||||
|
Dans ce devoir non noté, vous devez vous familiariser avec Python et rendre votre environnement opérationnel et capable d'exécuter des notebook.
|
||||||
|
|
||||||
|
Suivez ce [parcours d'apprentissage Python](https://docs.microsoft.com/learn/paths/python-language/?WT.mc_id=academic-15963-cxa), puis configurez votre système en parcourant ces vidéos introductives :
|
||||||
|
|
||||||
|
https://www.youtube.com/playlist?list=PLlrxD0HtieHhS8VzuMCfQD4uJ9yne1mE6
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
# Créer une frise chronologique
|
||||||
|
|
||||||
|
## Instructions
|
||||||
|
|
||||||
|
Utiliser [ce repo](https://github.com/Digital-Humanities-Toolkit/timeline-builder), créer une frise chronologique de certains aspects de l'histoire des algorithmes, des mathématiques, des statistiques, de l'IA ou du machine learning, ou une combinaison de ceux-ci. Vous pouvez vous concentrer sur une personne, une idée ou une longue période d'innovations. Assurez-vous d'ajouter des éléments multimédias.
|
||||||
|
|
||||||
|
## Rubrique
|
||||||
|
|
||||||
|
| Critères | Exemplaire | Adéquate | A améliorer |
|
||||||
|
| -------- | ---------------------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------ |
|
||||||
|
| | Une chronologie déployée est présentée sous forme de page GitHub | Le code est incomplet et non déployé | La chronologie est incomplète, pas bien recherchée et pas déployée |
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
# 建立一个时间轴
|
||||||
|
|
||||||
|
## 说明
|
||||||
|
|
||||||
|
使用这个 [仓库](https://github.com/Digital-Humanities-Toolkit/timeline-builder)，创建一个关于算法、数学、统计学、人工智能、机器学习的某个方面或者可以综合多个以上学科来讲。你可以着重介绍某个人，某个想法，或者一个经久不衰的思想。请确保添加了多媒体元素在你的时间线中。
|
||||||
|
|
||||||
|
## 评判标准
|
||||||
|
|
||||||
|
| 标准 | 优秀 | 中规中矩 | 仍需努力 |
|
||||||
|
| ------------ | ---------------------------------- | ---------------------- | ------------------------------------------ |
|
||||||
|
| | 有一个用 GitHub page 展示的 timeline | 代码还不完整并且没有部署 | 时间线不完整，没有经过充分的研究，并且没有部署 |
|
||||||
@ -0,0 +1,211 @@
|
|||||||
|
# Iniziare con Python e Scikit-learn per i modelli di regressione
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> Sketchnote di [Tomomi Imura](https://www.twitter.com/girlie_mac)
|
||||||
|
|
||||||
|
## [Qui Pre-lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/9/)
|
||||||
|
|
||||||
|
## Introduzione
|
||||||
|
|
||||||
|
In queste quattro lezioni, si scoprirà come costruire modelli di regressione. Si discuterà di cosa siano fra breve.
|
||||||
|
Prima di tutto, ci si deve assicurare di avere a disposizione gli strumenti adatti per far partire il processo!
|
||||||
|
|
||||||
|
In questa lezione, si imparerà come:
|
||||||
|
|
||||||
|
- Configurare il proprio computer per attività locali di machine learning.
|
||||||
|
- Lavorare con i Jupyter notebook.
|
||||||
|
- Usare Scikit-learn, compresa l'installazione.
|
||||||
|
- Esplorare la regressione lineare con un esercizio pratico.
|
||||||
|
|
||||||
|
## Installazioni e configurazioni
|
||||||
|
|
||||||
|
[](https://youtu.be/7EXd4_ttIuw "Using Python with Visual Studio Code")
|
||||||
|
|
||||||
|
> 🎥 Fare click sull'immagine qui sopra per un video: usare Python all'interno di VS Code.
|
||||||
|
|
||||||
|
1. **Installare Python**. Assicurarsi che [Python](https://www.python.org/downloads/) sia installato nel proprio computer. Si userà Python for per molte attività di data science e machine learning. La maggior parte dei sistemi già include una installazione di Python. Ci sono anche utili [Pacchetti di Codice Python](https://code.visualstudio.com/learn/educators/installers?WT.mc_id=academic-15963-cxa) disponbili, per facilitare l'installazione per alcuni utenti.
|
||||||
|
|
||||||
|
Alcuni utilizzi di Python, tuttavia, richiedono una versione del software, laddove altri ne richiedono un'altra differente. Per questa ragione, è utile lavorare con un [ambiente virtuale](https://docs.python.org/3/library/venv.html).
|
||||||
|
|
||||||
|
2. **Installare Visual Studio Code**. Assicurarsi di avere installato Visual Studio Code sul proprio computer. Si seguano queste istruzioni per [installare Visual Studio Code](https://code.visualstudio.com/) per l'installazione basica. Si userà Python in Visual Studio Code in questo corso, quindi meglio rinfrescarsi le idee su come [configurare Visual Studio Code](https://docs.microsoft.com/learn/modules/python-install-vscode?WT.mc_id=academic-15963-cxa) per lo sviluppo in Python.
|
||||||
|
|
||||||
|
> Si prenda confidenza con Python tramite questa collezione di [moduli di apprendimento](https://docs.microsoft.com/users/jenlooper-2911/collections/mp1pagggd5qrq7?WT.mc_id=academic-15963-cxa)
|
||||||
|
|
||||||
|
3. **Installare Scikit-learn**, seguendo [queste istruzioni](https://scikit-learn.org/stable/install.html). Visto che ci si deve assicurare di usare Python 3, ci si raccomanda di usare un ambiente virtuale. Si noti che se si installa questa libreria in un M1 Mac, ci sono istruzioni speciali nella pagina di cui al riferimento qui sopra.
|
||||||
|
|
||||||
|
1. **Installare Jupyter Notebook**. Servirà [installare il pacchetto Jupyter](https://pypi.org/project/jupyter/).
|
||||||
|
|
||||||
|
## Ambiente di creazione ML
|
||||||
|
|
||||||
|
Si useranno **notebook** per sviluppare il codice Python e creare modelli di machine learning. Questo tipo di file è uno strumento comune per i data scientist, e viene identificato dal suffisso o estensione `.ipynb`.
|
||||||
|
|
||||||
|
I notebook sono un ambiente interattivo che consente allo sviluppatore di scrivere codice, aggiungere note e scrivere documentazione attorno al codice il che è particolarmente utile per progetti sperimentali o orientati alla ricerca.
|
||||||
|
|
||||||
|
### Esercizio - lavorare con un notebook
|
||||||
|
|
||||||
|
In questa cartella, si troverà il file _notebook.ipynb_.
|
||||||
|
|
||||||
|
1. Aprire _notebook.ipynb_ in Visual Studio Code.
|
||||||
|
|
||||||
|
Un server Jupyter verrà lanciato con Python 3+. Si troveranno aree del notebook che possono essere `eseguite`, pezzi di codice. Si può eseguire un blocco di codice selezionando l'icona che assomiglia a un bottone di riproduzione.
|
||||||
|
|
||||||
|
1. Selezionare l'icona `md` e aggiungere un poco di markdown, e il seguente testo **# Benvenuto nel tuo notebook**.
|
||||||
|
|
||||||
|
Poi, aggiungere un blocco di codice Python.
|
||||||
|
|
||||||
|
1. Digitare **print('hello notebook')** nell'area riservata al codice.
|
||||||
|
1. Selezionare la freccia per eseguire il codice.
|
||||||
|
|
||||||
|
Si dovrebbe vedere stampata la seguente frase:
|
||||||
|
|
||||||
|
```output
|
||||||
|
hello notebook
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Si può inframezzare il codice con commenti per auto documentare il notebook.
|
||||||
|
|
||||||
|
✅ Si pensi per un minuto all'ambiente di lavoro di uno sviluppatore web rispetto a quello di un data scientist.
|
||||||
|
|
||||||
|
## Scikit-learn installato e funzionante
|
||||||
|
|
||||||
|
Adesso che Python è impostato nel proprio ambiente locale, e si è familiari con i notebook Jupyter, si acquisterà ora confidenza con Scikit-learn (si pronuncia con la `si` della parola inglese `science`). Scikit-learn fornisce una [API estensiva](https://scikit-learn.org/stable/modules/classes.html#api-ref) che aiuta a eseguire attività ML.
|
||||||
|
|
||||||
|
Stando al loro [sito web](https://scikit-learn.org/stable/getting_started.html), "Scikit-learn è una libreria di machine learning open source che supporta l'apprendimento assistito (supervised learning) e non assistito (unsuperivised learnin). Fornisce anche strumenti vari per l'adattamento del modello, la pre-elaborazione dei dati, la selezione e la valutazione dei modelli e molte altre utilità."
|
||||||
|
|
||||||
|
In questo corso, si userà Scikit-learn e altri strumenti per costruire modelli di machine learning per eseguire quelle che vengono chiamate attività di 'machine learning tradizionale'. Si sono deliberamente evitate le reti neurali e il deep learning visto che saranno meglio trattati nel prossimo programma di studi 'AI per Principianti'.
|
||||||
|
|
||||||
|
Scikit-learn rende semplice costruire modelli e valutarli per l'uso. Si concentra principalmente sull'utilizzo di dati numerici e contiene diversi insiemi di dati già pronti per l'uso come strumenti di apprendimento. Include anche modelli pre-costruiti per gli studenti da provare. Si esplora ora il processo di caricamento dei dati preconfezionati, e, utilizzando un modello di stimatore incorporato, un primo modello ML con Scikit-Learn con alcuni dati di base.
|
||||||
|
|
||||||
|
## Esercizio - Il Primo notebook Scikit-learn
|
||||||
|
|
||||||
|
> Questo tutorial è stato ispirato dall'[esempio di regressione lineare](https://scikit-learn.org/stable/auto_examples/linear_model/plot_ols.html#sphx-glr-auto-examples-linear-model-plot-ols-py) nel sito web di Scikit-learn.
|
||||||
|
|
||||||
|
Nel file _notebook.ipynb_ associato a questa lezione, svuotare tutte le celle usando l'icona cestino ('trash can').
|
||||||
|
|
||||||
|
In questa sezione, di lavorerà con un piccolo insieme di dati sul diabete che è incorporato in Scikit-learn per scopi di apprendimento. Si immagini di voler testare un trattamento per i pazienti diabetici. I modelli di machine learning potrebbero essere di aiuto nel determinare quali pazienti risponderebbero meglio al trattamento, in base a combinazioni di variabili. Anche un modello di regressione molto semplice, quando visualizzato, potrebbe mostrare informazioni sulle variabili che aiuteranno a organizzare le sperimentazioni cliniche teoriche.
|
||||||
|
|
||||||
|
✅ Esistono molti tipi di metodi di regressione e quale scegliere dipende dalla risposta che si sta cercando. Se si vuole prevedere l'altezza probabile per una persona di una data età, si dovrebbe usare la regressione lineare, visto che si sta cercando un **valore numerico**. Se si è interessati a scoprire se un tipo di cucina dovrebbe essere considerato vegano o no, si sta cercando un'**assegnazione di categoria** quindi si dovrebbe usare la regressione logistica. Si imparerà di più sulla regressione logistica in seguito. Si pensi ad alcune domande che si possono chiedere ai dati e quale di questi metodi sarebbe più appropriato.
|
||||||
|
|
||||||
|
Si inizia con questa attività.
|
||||||
|
|
||||||
|
### Importare le librerie
|
||||||
|
|
||||||
|
Per questo compito verranno importate alcune librerie:
|
||||||
|
|
||||||
|
- **matplotlib**. E' un utile [strumento grafico](https://matplotlib.org/) e verrà usato per creare una trama a linee.
|
||||||
|
- **numpy**. [numpy](https://numpy.org/doc/stable/user/whatisnumpy.html) è una libreira utile per gestire i dati numerici in Python.
|
||||||
|
- **sklearn**. Questa è la libreria Scikit-learn.
|
||||||
|
|
||||||
|
Importare alcune librerie che saranno di aiuto per le proprie attività.
|
||||||
|
|
||||||
|
1. Con il seguente codice si aggiungono le importazioni:
|
||||||
|
|
||||||
|
```python
|
||||||
|
import matplotlib.pyplot as plt
|
||||||
|
import numpy as np
|
||||||
|
from sklearn import datasets, linear_model, model_selection
|
||||||
|
```
|
||||||
|
|
||||||
|
Qui sopra vengono importati `matplottlib`, e `numpy`, da `sklearn` si importa `datasets`, `linear_model` e `model_selection`. `model_selection` viene usato per dividere i dati negli insiemi di addestramento e test.
|
||||||
|
|
||||||
|
### L'insieme di dati riguardante il diabete
|
||||||
|
|
||||||
|
L'[insieme dei dati sul diabete](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) include 442 campioni di dati sul diabete, con 10 variabili caratteristiche, alcune delle quali includono:
|
||||||
|
|
||||||
|
- age (età): età in anni
|
||||||
|
- bmi: indice di massa corporea (body mass index)
|
||||||
|
- bp: media pressione sanguinea
|
||||||
|
- s1 tc: Cellule T (un tipo di leucocito)
|
||||||
|
|
||||||
|
✅ Questo insieme di dati include il concetto di "sesso" come caratteristica variabile importante per la ricerca sul diabete. Molti insiemi di dati medici includono questo tipo di classificazione binaria. Si rifletta su come categorizzazioni come questa potrebbe escludere alcune parti di una popolazione dai trattamenti.
|
||||||
|
|
||||||
|
Ora si caricano i dati di X e y.
|
||||||
|
|
||||||
|
> 🎓 Si ricordi, questo è apprendimento supervisionato (supervised learning), e serve dare un nome all'obiettivo 'y'.
|
||||||
|
|
||||||
|
In una nuova cella di codice, caricare l'insieme di dati sul diabete chiamando `load_diabetes()`. Il parametro `return_X_y=True` segnala che `X` sarà una matrice di dati e `y` sarà l'obiettivo della regressione.
|
||||||
|
|
||||||
|
1. Si aggiungono alcuni comandi di stampa per msotrare la forma della matrice di dati e i suoi primi elementi:
|
||||||
|
|
||||||
|
```python
|
||||||
|
X, y = datasets.load_diabetes(return_X_y=True)
|
||||||
|
print(X.shape)
|
||||||
|
print(X[0])
|
||||||
|
```
|
||||||
|
|
||||||
|
Quella che viene ritornata è una tuple. Quello che si sta facento è assegnare i primi due valori della tupla a `X` e `y` rispettivamente. Per saperne di più sulle [tuples](https://wikipedia.org/wiki/Tuple).
|
||||||
|
|
||||||
|
Si può vedere che questi dati hanno 442 elementi divisi in array di 10 elementi:
|
||||||
|
|
||||||
|
```text
|
||||||
|
(442, 10)
|
||||||
|
[ 0.03807591 0.05068012 0.06169621 0.02187235 -0.0442235 -0.03482076
|
||||||
|
-0.04340085 -0.00259226 0.01990842 -0.01764613]
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ Si rifletta sulla relazione tra i dati e l'obiettivo di regressione. La regressione lineare prevede le relazioni tra la caratteristica X e la variabile di destinazione y. Si può trovare l'[obiettivo](https://scikit-learn.org/stable/datasets/toy_dataset.html#diabetes-dataset) per l'insieme di dati sul diabete nella documentazione? Cosa dimostra questo insieme di dati, dato quell'obiettivo?
|
||||||
|
|
||||||
|
2. Successivamente, selezionare una porzione di questo insieme di dati da tracciare sistemandola in un nuovo array usando la funzione di numpy's `newaxis`. Verrà usata la regressione lineare per generare una linea tra i valori in questi dati secondo il modello che determina.
|
||||||
|
|
||||||
|
```python
|
||||||
|
X = X[:, np.newaxis, 2]
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ A piacere, stampare i dati per verificarne la forma.
|
||||||
|
|
||||||
|
3. Ora che si hanno dei dati pronti per essere tracciati, è possibile vedere se una macchina può aiutare a determinare una divisione logica tra i numeri in questo insieme di dati. Per fare ciò, è necessario dividere sia i dati (X) che l'obiettivo (y) in insiemi di test e addestamento. Scikit-learn ha un modo semplice per farlo; si possono dividere i dati di prova in un determinato punto.
|
||||||
|
|
||||||
|
```python
|
||||||
|
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.33)
|
||||||
|
```
|
||||||
|
|
||||||
|
4. Ora si è pronti ad addestare il modello! Caricare il modello di regressione lineare e addestrarlo con i propri insiemi di addestramento X e y usando `model.fit()`:
|
||||||
|
|
||||||
|
```python
|
||||||
|
model = linear_model.LinearRegression()
|
||||||
|
model.fit(X_train, y_train)
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ `model.fit()` è una funzione che si vedrà in molte librerie ML tipo TensorFlow
|
||||||
|
|
||||||
|
5. Successivamente creare una previsione usando i dati di test, con la funzione `predict()`. Questo servirà per tracciare la linea tra i gruppi di dati
|
||||||
|
|
||||||
|
```python
|
||||||
|
y_pred = model.predict(X_test)
|
||||||
|
```
|
||||||
|
|
||||||
|
6. Ora è il momento di mostrare i dati in un tracciato. Matplotlib è uno strumento molto utile per questo compito. Si crei un grafico a dispersione (scatterplot) di tutti i dati del test X e y e si utilizzi la previsione per disegnare una linea nel luogo più appropriato, tra i raggruppamenti dei dati del modello.
|
||||||
|
|
||||||
|
```python
|
||||||
|
plt.scatter(X_test, y_test, color='black')
|
||||||
|
plt.plot(X_test, y_pred, color='blue', linewidth=3)
|
||||||
|
plt.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
✅ Si pensi a cosa sta succedendo qui. Una linea retta scorre attraverso molti piccoli punti dati, ma cosa sta facendo esattamente? Si può capire come si dovrebbe utilizzare questa linea per prevedere dove un nuovo punto di dati non noto dovrebbe adattarsi alla relazione con l'asse y del tracciato? Si cerchi di mettere in parole l'uso pratico di questo modello.
|
||||||
|
|
||||||
|
Congratulazioni, si è costruito il primo modello di regressione lineare, creato una previsione con esso, e visualizzata in una tracciato!
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🚀Sfida
|
||||||
|
|
||||||
|
Tracciare una variabile diversa da questo insieme di dati. Suggerimento: modificare questa riga: `X = X[:, np.newaxis, 2]`. Dato l'obiettivo di questo insieme di dati, cosa si potrebbe riuscire a scoprire circa la progressione del diabete come matattia?
|
||||||
|
|
||||||
|
## [Qui post-lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/10/)
|
||||||
|
|
||||||
|
## Riepilogo e Auto Apprendimento
|
||||||
|
|
||||||
|
In questo tutorial, si è lavorato con una semplice regressione lineare, piuttosto che una regressione univariata o multipla. Ci so informi circa le differenze tra questi metodi oppure si dia uno sguardo a [questo video](https://www.coursera.org/lecture/quantifying-relationships-regression-models/linear-vs-nonlinear-categorical-variables-ai2Ef)
|
||||||
|
|
||||||
|
Si legga di più sul concetto di regressione e si pensi a quale tipo di domande potrebbero trovare risposta con questa tecnica. Seguire questo [tutorial](https://docs.microsoft.com/learn/modules/train-evaluate-regression-models?WT.mc_id=academic-15963-cxa) per approfondire la propria conoscenza.
|
||||||
|
|
||||||
|
## Compito
|
||||||
|
|
||||||
|
[Un insieme di dati diverso](assignment.it.md)
|
||||||
|
|
||||||
@ -0,0 +1,13 @@
|
|||||||
|
# Regressione con Scikit-learn
|
||||||
|
|
||||||
|
## Istruzioni
|
||||||
|
|
||||||
|
Dare un'occhiata all'[insieme di dati Linnerud](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_linnerud.html#sklearn.datasets.load_linnerud) in Scikit-learn. Questo insieme di dati ha [obiettivi](https://scikit-learn.org/stable/datasets/toy_dataset.html#linnerrud-dataset) multipli: "Consiste di tre variabili di esercizio (dati) e tre variabili fisiologiche (obiettivo) raccolte da venti uomini di mezza età in un fitness club".
|
||||||
|
|
||||||
|
Con parole proprie, descrivere come creare un modello di Regressione che tracci la relazione tra il punto vita e il numero di addominali realizzati. Fare lo stesso per gli altri punti dati in questo insieme di dati.
|
||||||
|
|
||||||
|
## Rubrica
|
||||||
|
|
||||||
|
| Criteri | Ottimo | Adeguato | Necessita miglioramento |
|
||||||
|
| ------------------------------ | ----------------------------------- | ----------------------------- | -------------------------- |
|
||||||
|
| Inviare un paragrafo descrittivo | Viene presentato un paragrafo ben scritto | Vengono inviate alcune frasi | Non viene fornita alcuna descrizione |
|
||||||
@ -0,0 +1,201 @@
|
|||||||
|
# Costruire un modello di regressione usando Scikit-learn: preparare e visualizzare i dati
|
||||||
|
|
||||||
|
> 
|
||||||
|
> Infografica di [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||||
|
|
||||||
|
## [Quiz Pre-Lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/11/)
|
||||||
|
|
||||||
|
## Introduzione
|
||||||
|
|
||||||
|
Ora che si hanno a disposizione gli strumenti necessari per iniziare ad affrontare la creazione di modelli di machine learning con Scikit-learn, si è pronti per iniziare a porre domande sui propri dati. Mentre si lavora con i dati e si applicano soluzioni ML, è molto importante capire come porre la domanda giusta per sbloccare correttamente le potenzialità del proprio insieme di dati.
|
||||||
|
|
||||||
|
In questa lezione, si imparerà:
|
||||||
|
|
||||||
|
- Come preparare i dati per la creazione del modello.
|
||||||
|
- Come utilizzare Matplotlib per la visualizzazione dei dati.
|
||||||
|
|
||||||
|
## Fare la domanda giusta ai propri dati
|
||||||
|
|
||||||
|
La domanda a cui si deve rispondere determinerà il tipo di algoritmi ML che verranno utilizzati. La qualità della risposta che si riceverà dipenderà fortemente dalla natura dei propri dati.
|
||||||
|
|
||||||
|
Si dia un'occhiata ai [dati](../../data/US-pumpkins.csv) forniti per questa lezione. Si può aprire questo file .csv in VS Code. Una rapida scrematura mostra immediatamente che ci sono spazi vuoti e un mix di stringhe e dati numerici. C'è anche una strana colonna chiamata "Package" (pacchetto) in cui i dati sono un mix tra "sacks" (sacchi), "bins" (contenitori) e altri valori. I dati, infatti, sono un po' un pasticcio.
|
||||||
|
|
||||||
|
In effetti, non è molto comune ricevere un insieme di dati completamente pronto per creare un modello ML pronto all'uso. In questa lezione si imparerà come preparare un insieme di dati non elaborato utilizzando le librerie standard di Python. Si impareranno anche varie tecniche per visualizzare i dati.
|
||||||
|
|
||||||
|
## Caso di studio: 'il mercato della zucca'
|
||||||
|
|
||||||
|
In questa cartella si troverà un file .csv nella cartella `data` radice chiamato [US-pumpkins.csv](../../data/US-pumpkins.csv) che include 1757 righe di dati sul mercato delle zucche, ordinate in raggruppamenti per città. Si tratta di dati grezzi estratti dai [Report Standard dei Mercati Terminali delle Colture Speciali](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuiti dal Dipartimento dell'Agricoltura degli Stati Uniti.
|
||||||
|
|
||||||
|
### Preparazione dati
|
||||||
|
|
||||||
|
Questi dati sono di pubblico dominio. Possono essere scaricati in molti file separati, per città, dal sito web dell'USDA. Per evitare troppi file separati, sono stati concatenati tutti i dati della città in un unico foglio di calcolo, quindi un po' i dati sono già stati _preparati_ . Successivamente, si darà un'occhiata più da vicino ai dati.
|
||||||
|
|
||||||
|
### I dati della zucca - prime conclusioni
|
||||||
|
|
||||||
|
Cosa si nota riguardo a questi dati? Si è già visto che c'è un mix di stringhe, numeri, spazi e valori strani a cui occorre dare un senso.
|
||||||
|
|
||||||
|
Che domanda si puà fare a questi dati, utilizzando una tecnica di Regressione? Che dire di "Prevedere il prezzo di una zucca in vendita durante un dato mese". Esaminando nuovamente i dati, ci sono alcune modifiche da apportare per creare la struttura dati necessaria per l'attività.
|
||||||
|
|
||||||
|
## Esercizio: analizzare i dati della zucca
|
||||||
|
|
||||||
|
Si usa [Pandas](https://pandas.pydata.org/), (il nome sta per `Python Data Analysis`) uno strumento molto utile per dare forma ai dati, per analizzare e preparare questi dati sulla zucca.
|
||||||
|
|
||||||
|
### Innanzitutto, controllare le date mancanti
|
||||||
|
|
||||||
|
Prima si dovranno eseguire i passaggi per verificare le date mancanti:
|
||||||
|
|
||||||
|
1. Convertire le date in un formato mensile (queste sono date statunitensi, quindi il formato è `MM/GG/AAAA`).
|
||||||
|
2. Estrarre il mese in una nuova colonna.
|
||||||
|
|
||||||
|
Aprire il file _notebook.ipynb_ in Visual Studio Code e importare il foglio di calcolo in un nuovo dataframe Pandas.
|
||||||
|
|
||||||
|
1. Usare la funzione `head()` per visualizzare le prime cinque righe.
|
||||||
|
|
||||||
|
```python
|
||||||
|
import pandas as pd
|
||||||
|
pumpkins = pd.read_csv('../data/US-pumpkins.csv')
|
||||||
|
pumpkins.head()
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ Quale funzione si userebbe per visualizzare le ultime cinque righe?
|
||||||
|
|
||||||
|
1. Controllare se mancano dati nel dataframe corrente:
|
||||||
|
|
||||||
|
```python
|
||||||
|
pumpkins.isnull().sum()
|
||||||
|
```
|
||||||
|
|
||||||
|
Ci sono dati mancanti, ma forse non avrà importanza per l'attività da svolgere.
|
||||||
|
|
||||||
|
1. Per rendere più facile lavorare con il dataframe, si scartano molte delle sue colonne, usando `drop()`, mantenendo solo le colonne di cui si ha bisogno:
|
||||||
|
|
||||||
|
```python
|
||||||
|
new_columns = ['Package', 'Month', 'Low Price', 'High Price', 'Date']
|
||||||
|
pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
|
||||||
|
```
|
||||||
|
|
||||||
|
### Secondo, determinare il prezzo medio della zucca
|
||||||
|
|
||||||
|
Si pensi a come determinare il prezzo medio di una zucca in un dato mese. Quali colonne si sceglierebbero per questa attività? Suggerimento: serviranno 3 colonne.
|
||||||
|
|
||||||
|
Soluzione: prendere la media delle colonne `Low Price` e `High Price` per popolare la nuova colonna Price e convertire la colonna Date per mostrare solo il mese. Fortunatamente, secondo il controllo di cui sopra, non mancano dati per date o prezzi.
|
||||||
|
|
||||||
|
1. Per calcolare la media, aggiungere il seguente codice:
|
||||||
|
|
||||||
|
```python
|
||||||
|
price = (pumpkins['Low Price'] + pumpkins['High Price']) / 2
|
||||||
|
|
||||||
|
month = pd.DatetimeIndex(pumpkins['Date']).month
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ Si possono di stampare tutti i dati che si desidera controllare utilizzando `print(month)`.
|
||||||
|
|
||||||
|
2. Ora copiare i dati convertiti in un nuovo dataframe Pandas:
|
||||||
|
|
||||||
|
```python
|
||||||
|
new_pumpkins = pd.DataFrame({'Month': month, 'Package': pumpkins['Package'], 'Low Price': pumpkins['Low Price'],'High Price': pumpkins['High Price'], 'Price': price})
|
||||||
|
```
|
||||||
|
|
||||||
|
La stampa del dataframe mostrerà un insieme di dati pulito e ordinato su cui si può costruire il nuovo modello di regressione.
|
||||||
|
|
||||||
|
### Ma non è finita qui! C'è qualcosa di strano qui.
|
||||||
|
|
||||||
|
Osservando la colonna `Package`, le zucche sono vendute in molte configurazioni diverse. Alcune sono venduti in misure '1 1/9 bushel' (bushel = staio) e alcuni in misure '1/2 bushel', alcuni per zucca, alcuni per libbra e alcuni in grandi scatole con larghezze variabili.
|
||||||
|
|
||||||
|
> Le zucche sembrano molto difficili da pesare in modo coerente
|
||||||
|
|
||||||
|
Scavando nei dati originali, è interessante notare che qualsiasi cosa con `Unit of Sale` (Unità di vendita) uguale a 'EACH' o 'PER BIN' ha anche il tipo di `Package` per 'inch' (pollice), per 'bin' (contenitore) o 'each' (entrambi). Le zucche sembrano essere molto difficili da pesare in modo coerente, quindi si filtrano selezionando solo zucche con la stringa "bushel" nella colonna `Package`.
|
||||||
|
|
||||||
|
1. Aggiungere un filtro nella parte superiore del file, sotto l'importazione .csv iniziale:
|
||||||
|
|
||||||
|
```python
|
||||||
|
pumpkins = pumpkins[pumpkins['Package'].str.contains('bushel', case=True, regex=True)]
|
||||||
|
```
|
||||||
|
|
||||||
|
Se si stampano i dati ora, si può vedere che si stanno ricevendo solo le circa 415 righe di dati contenenti zucche per bushel.
|
||||||
|
|
||||||
|
### Ma non è finita qui! C'è un'altra cosa da fare.
|
||||||
|
|
||||||
|
Si è notato che la quantità di bushel varia per riga? Si deve normalizzare il prezzo in modo da mostrare il prezzo per bushel, quindi si facciano un po' di calcoli per standardizzarlo.
|
||||||
|
|
||||||
|
1. Aggiungere queste righe dopo il blocco che crea il dataframe new_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)
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ Secondo [The Spruce Eats](https://www.thespruceeats.com/how-much-is-a-bushel-1389308), il peso di un bushel dipende dal tipo di prodotto, poiché è una misura di volume. "Un bushel di pomodori, per esempio, dovrebbe pesare 56 libbre... Foglie e verdure occupano più spazio con meno peso, quindi un bushel di spinaci è solo 20 libbre". È tutto piuttosto complicato! Non occorre preoccuparsi di fare una conversione da bushel a libbra, e invece si valuta a bushel. Tutto questo studio sui bushel di zucche, però, dimostra quanto sia importante capire la natura dei propri dati!
|
||||||
|
|
||||||
|
Ora si può analizzare il prezzo per unità in base alla misurazione del bushel. Se si stampano i dati ancora una volta, si può vedere come sono standardizzati.
|
||||||
|
|
||||||
|
✅ Si è notato che le zucche vendute a metà bushel sono molto costose? Si riesce a capire perché? Suggerimento: le zucche piccole sono molto più costose di quelle grandi, probabilmente perché ce ne sono molte di più per bushel, dato lo spazio inutilizzato occupato da una grande zucca cava.
|
||||||
|
|
||||||
|
## Strategie di Visualizzazione
|
||||||
|
|
||||||
|
Parte del ruolo del data scientist è dimostrare la qualità e la natura dei dati con cui sta lavorando. Per fare ciò, si creano spesso visualizzazioni interessanti o tracciati, grafici e diagrammi, che mostrano diversi aspetti dei dati. In questo modo, sono in grado di mostrare visivamente relazioni e lacune altrimenti difficili da scoprire.
|
||||||
|
|
||||||
|
Le visualizzazioni possono anche aiutare a determinare la tecnica di machine learning più appropriata per i dati. Un grafico a dispersione che sembra seguire una linea, ad esempio, indica che i dati sono un buon candidato per un esercizio di regressione lineare.
|
||||||
|
|
||||||
|
Una libreria di visualizzazione dei dati che funziona bene nei notebook Jupyter è [Matplotlib](https://matplotlib.org/) (che si è visto anche nella lezione precedente).
|
||||||
|
|
||||||
|
> Per fare più esperienza con la visualizzazione dei dati si seguano [questi tutorial](https://docs.microsoft.com/learn/modules/explore-analyze-data-with-python?WT.mc_id=academic-15963-cxa).
|
||||||
|
|
||||||
|
## Esercizio - sperimentare con Matplotlib
|
||||||
|
|
||||||
|
Provare a creare alcuni grafici di base per visualizzare il nuovo dataframe appena creato. Cosa mostrerebbe un grafico a linee di base?
|
||||||
|
|
||||||
|
1. Importare Matplotlib nella parte superiore del file, sotto l'importazione di Pandas:
|
||||||
|
|
||||||
|
```python
|
||||||
|
import matplotlib.pyplot as plt
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Rieseguire l'intero notebook per aggiornare.
|
||||||
|
1. Nella parte inferiore del notebook, aggiungere una cella per tracciare i dati come una casella:
|
||||||
|
|
||||||
|
```python
|
||||||
|
price = new_pumpkins.Price
|
||||||
|
month = new_pumpkins.Month
|
||||||
|
plt.scatter(price, month)
|
||||||
|
plt.show()
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
È un tracciato utile? C'è qualcosa che sorprende?
|
||||||
|
|
||||||
|
Non è particolarmente utile in quanto tutto ciò che fa è visualizzare nei propri dati come una diffusione di punti in un dato mese.
|
||||||
|
|
||||||
|
### Renderlo utile
|
||||||
|
|
||||||
|
Per fare in modo che i grafici mostrino dati utili, di solito è necessario raggruppare i dati in qualche modo. Si prova a creare un grafico che mostra la distribuzione dei dati dove l'asse x mostra i mesi.
|
||||||
|
|
||||||
|
1. Aggiungere una cella per creare un grafico a barre raggruppato:
|
||||||
|
|
||||||
|
```python
|
||||||
|
new_pumpkins.groupby(['Month'])['Price'].mean().plot(kind='bar')
|
||||||
|
plt.ylabel("Pumpkin Price")
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Questa è una visualizzazione dei dati più utile! Sembra indicare che il prezzo più alto per le zucche si verifica a settembre e ottobre. Questo soddisfa le proprie aspettative? Perché o perché no?
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🚀 Sfida
|
||||||
|
|
||||||
|
Esplorare i diversi tipi di visualizzazione offerti da Matplotlib. Quali tipi sono più appropriati per i problemi di regressione?
|
||||||
|
|
||||||
|
## [Quiz post-lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/12/)
|
||||||
|
|
||||||
|
## Revisione e Auto Apprendimento
|
||||||
|
|
||||||
|
Dare un'occhiata ai molti modi per visualizzare i dati. Fare un elenco delle varie librerie disponibili e annotare quali sono le migliori per determinati tipi di attività, ad esempio visualizzazioni 2D rispetto a visualizzazioni 3D. Cosa si è scoperto?
|
||||||
|
|
||||||
|
## Compito
|
||||||
|
|
||||||
|
[Esplorazione della visualizzazione](assignment.it.md)
|
||||||
@ -0,0 +1,9 @@
|
|||||||
|
# Esplorazione delle visualizzazioni
|
||||||
|
|
||||||
|
Sono disponibili diverse librerie per la visualizzazione dei dati. Creare alcune visualizzazioni utilizzando i dati della zucca in questa lezione con matplotlib e seaborn in un notebook di esempio. Con quali librerie è più facile lavorare?
|
||||||
|
|
||||||
|
## Rubrica
|
||||||
|
|
||||||
|
| Criteri | Ottimo | Adeguato | Necessita miglioramento |
|
||||||
|
| -------- | --------- | -------- | ----------------- |
|
||||||
|
| | Viene inviato un notebook con due esplorazioni/visualizzazioni | Viene inviato un notebook con una esplorazione/visualizzazione | Non è stato inviato un notebook |
|
||||||
@ -0,0 +1,9 @@
|
|||||||
|
# 探索数据可视化
|
||||||
|
|
||||||
|
有好几个库都可以进行数据可视化。用 matplotlib 和 seaborn 对本课中涉及的 Pumpkin 数据集创建一些数据可视化的图标。并思考哪个库更容易使用？
|
||||||
|
|
||||||
|
## 评判标准
|
||||||
|
|
||||||
|
| 标准 | 优秀 | 中规中矩 | 仍需努力 |
|
||||||
|
| -------- | --------- | -------- | ----------------- |
|
||||||
|
| | 提交了含有两种探索可视化方法的notebook工程文件 | 提交了只包含有一种探索可视化方法的notebook工程文件 | 没提交 notebook 工程文件 |
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
# Creare un Modello di Regressione
|
||||||
|
|
||||||
|
## Istruzioni
|
||||||
|
|
||||||
|
In questa lezione è stato mostrato come costruire un modello utilizzando sia la Regressione Lineare che Polinomiale. Usando questa conoscenza, trovare un insieme di dati o utilizzare uno degli insiemi integrati di Scikit-Learn per costruire un modello nuovo. Spiegare nel proprio notebook perché si è scelto una determinata tecnica e dimostrare la precisione del modello. Se non è accurato, spiegare perché.
|
||||||
|
|
||||||
|
## Rubrica
|
||||||
|
|
||||||
|
| Criteri | Ottimo | Adeguato | Necessita miglioramento |
|
||||||
|
| -------- | ------------------------------------------------------------ | -------------------------- | ------------------------------- |
|
||||||
|
| | presenta un notebook completo con una soluzione ben documentata | La soluzione è incompleta | La soluzione è difettosa o contiene bug |
|
||||||
@ -0,0 +1,12 @@
|
|||||||
|
# 创建自己的回归模型
|
||||||
|
|
||||||
|
## 说明
|
||||||
|
|
||||||
|
在这节课中你学到了如何用线性回归和多项式回归建立一个模型。利用这些只是，找到一个你感兴趣的数据集或者是 Scikit-learn 内置的数据集来建立一个全新的模型。用你的 notebook 来解释为什么用了这种技术来对这个数据集进行建模，并且证明出你的模型的准确度。如果它没你想象中准确，请思考一下并解释一下原因。
|
||||||
|
|
||||||
|
## 评判标准
|
||||||
|
|
||||||
|
| 标准 | 优秀 | 中规中矩 | 仍需努力 |
|
||||||
|
| -------- | ------------------------------------------------------------ | -------------------------- | ------------------------------- |
|
||||||
|
| | 提交了一个完整的 notebook 工程文件，其中包含了解集，并且可读性良好 | 不完整的解集 | 解集是有缺陷或者有错误的 |
|
||||||
|
|
||||||
@ -0,0 +1,299 @@
|
|||||||
|
# Regressione logistica per prevedere le categorie
|
||||||
|
|
||||||
|
|
||||||
|
> Infografica di [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||||
|
|
||||||
|
## [Quiz Pre-Lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/15/)
|
||||||
|
|
||||||
|
## Introduzione
|
||||||
|
|
||||||
|
In questa lezione finale sulla Regressione, una delle tecniche _classiche_ di base di machine learning, si darà un'occhiata alla Regressione Logistica. Si dovrebbe utilizzare questa tecnica per scoprire modelli per prevedere le categorie binarie. Questa caramella è al cioccolato o no? Questa malattia è contagiosa o no? Questo cliente sceglierà questo prodotto o no?
|
||||||
|
|
||||||
|
In questa lezione, si imparerà:
|
||||||
|
|
||||||
|
- Una nuova libreria per la visualizzazione dei dati
|
||||||
|
- Tecniche per la regressione logistica
|
||||||
|
|
||||||
|
✅ Con questo [modulo di apprendimento](https://docs.microsoft.com/learn/modules/train-evaluate-classification-models?WT.mc_id=academic-15963-cxa) si potrà approfondire la comprensione del lavoro con questo tipo di regressione
|
||||||
|
## Prerequisito
|
||||||
|
|
||||||
|
Avendo lavorato con i dati della zucca, ora si ha abbastanza familiarità con essi per rendersi conto che esiste una categoria binaria con cui è possibile lavorare: `Color` (Colore).
|
||||||
|
|
||||||
|
Si costruisce un modello di regressione logistica per prevedere, date alcune variabili, di _che colore sarà probabilmente una data zucca_ (arancione 🎃 o bianca 👻).
|
||||||
|
|
||||||
|
> Perché si parla di classificazione binaria in un gruppo di lezioni sulla regressione? Solo per comodità linguistica, poiché la regressione logistica è in [realtà un metodo di classificazione](https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression), anche se lineare. Si scopriranno altri modi per classificare i dati nel prossimo gruppo di lezioni.
|
||||||
|
|
||||||
|
## Definire la domanda
|
||||||
|
|
||||||
|
Allo scopo, verrà espressa come binaria: 'Arancio' o 'Non Arancio'. C'è anche una categoria "striped" (a strisce) nell'insieme di dati, ma ci sono pochi casi, quindi non verrà presa in considerazione. Comunque scompare una volta rimossi i valori null dall'insieme di dati.
|
||||||
|
|
||||||
|
> 🎃 Fatto divertente, a volte le zucche bianche vengono chiamate zucche "fantasma" Non sono molto facili da intagliare, quindi non sono così popolari come quelle arancioni ma hanno un bell'aspetto!
|
||||||
|
|
||||||
|
## Informazioni sulla regressione logistica
|
||||||
|
|
||||||
|
La regressione logistica differisce dalla regressione lineare, che si è appresa in precedenza, in alcuni importanti modi.
|
||||||
|
|
||||||
|
### Classificazione Binaria
|
||||||
|
|
||||||
|
La regressione logistica non offre le stesse caratteristiche della regressione lineare. La prima offre una previsione su una categoria binaria ("arancione o non arancione") mentre la seconda è in grado di prevedere valori continui, ad esempio data l'origine di una zucca e il momento del raccolto, di _quanto aumenterà il suo prezzo_.
|
||||||
|
|
||||||
|
|
||||||
|
> Infografica di [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||||
|
### Altre classificazioni:
|
||||||
|
|
||||||
|
Esistono altri tipi di regressione logistica, inclusi multinomiale e ordinale:
|
||||||
|
|
||||||
|
- **Multinomiale**, che implica avere più di una categoria: "arancione, bianco e a strisce".
|
||||||
|
- **Ordinale**, che coinvolge categorie ordinate, utile se si volessero ordinare i risultati in modo logico, come le zucche che sono ordinate per un numero finito di dimensioni (mini,sm,med,lg,xl,xxl).
|
||||||
|
|
||||||
|
|
||||||
|
> Infografica di [Dasani Madipalli](https://twitter.com/dasani_decoded)
|
||||||
|
|
||||||
|
### È ancora lineare
|
||||||
|
|
||||||
|
Anche se questo tipo di Regressione riguarda le "previsioni di categoria", funziona ancora meglio quando esiste una chiara relazione lineare tra la variabile dipendente (colore) e le altre variabili indipendenti (il resto dell'insieme di dati, come il nome della città e le dimensioni) . È bene avere un'idea se c'è qualche linearità che divide queste variabili o meno.
|
||||||
|
|
||||||
|
### Le variabili NON devono essere correlate
|
||||||
|
|
||||||
|
Si ricorda come la regressione lineare ha funzionato meglio con più variabili correlate? La regressione logistica è l'opposto: le variabili non devono essere allineate. Funziona per questi dati che hanno correlazioni alquanto deboli.
|
||||||
|
|
||||||
|
### Servono molti dati puliti
|
||||||
|
|
||||||
|
La regressione logistica fornirà risultati più accurati se si utilizzano più dati; quindi si tenga a mente che, essendo l'insieme di dati sulla zucca piccolo, non è ottimale per questo compito
|
||||||
|
|
||||||
|
✅ Si pensi ai tipi di dati che si prestano bene alla regressione logistica
|
||||||
|
|
||||||
|
## Esercizio: riordinare i dati
|
||||||
|
|
||||||
|
Innanzitutto, si puliscono un po 'i dati, eliminando i valori null e selezionando solo alcune delle colonne:
|
||||||
|
|
||||||
|
1. Aggiungere il seguente codice:
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.preprocessing import LabelEncoder
|
||||||
|
|
||||||
|
new_columns = ['Color','Origin','Item Size','Variety','City Name','Package']
|
||||||
|
|
||||||
|
new_pumpkins = pumpkins.drop([c for c in pumpkins.columns if c not in new_columns], axis=1)
|
||||||
|
|
||||||
|
new_pumpkins.dropna(inplace=True)
|
||||||
|
|
||||||
|
new_pumpkins = new_pumpkins.apply(LabelEncoder().fit_transform)
|
||||||
|
```
|
||||||
|
|
||||||
|
Si può sempre dare un'occhiata al nuovo dataframe:
|
||||||
|
|
||||||
|
```python
|
||||||
|
new_pumpkins.info
|
||||||
|
```
|
||||||
|
|
||||||
|
### Visualizzazione - griglia affiancata
|
||||||
|
|
||||||
|
A questo punto si è caricato di nuovo il [notebook iniziale](../notebook.ipynb) con i dati della zucca e lo si è pulito in modo da preservare un insieme di dati contenente alcune variabili, incluso `Color`. Si visualizza il dataframe nel notebook utilizzando una libreria diversa: [Seaborn](https://seaborn.pydata.org/index.html), che è costruita su Matplotlib, usata in precedenza.
|
||||||
|
|
||||||
|
Seaborn offre alcuni modi accurati per visualizzare i dati. Ad esempio, si possono confrontare le distribuzioni dei dati per ogni punto in una griglia affiancata.
|
||||||
|
|
||||||
|
1. Si crea una griglia di questo tipo istanziando `PairGrid`, usando i dati della zucca `new_pumpkins`, poi chiamando `map()`:
|
||||||
|
|
||||||
|
```python
|
||||||
|
import seaborn as sns
|
||||||
|
|
||||||
|
g = sns.PairGrid(new_pumpkins)
|
||||||
|
g.map(sns.scatterplot)
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Osservando i dati fianco a fianco, si può vedere come i dati di Color si riferiscono alle altre colonne.
|
||||||
|
|
||||||
|
✅ Data questa griglia del grafico a dispersione, quali sono alcune esplorazioni interessanti che si possono immaginare?
|
||||||
|
|
||||||
|
### Usare un grafico a sciame
|
||||||
|
|
||||||
|
Poiché Color è una categoria binaria (arancione o no), viene chiamata "dati categoriali" e richiede "un [approccio più specializzato](https://seaborn.pydata.org/tutorial/categorical.html?highlight=bar) alla visualizzazione". Esistono altri modi per visualizzare la relazione di questa categoria con altre variabili.
|
||||||
|
|
||||||
|
È possibile visualizzare le variabili fianco a fianco con i grafici di Seaborn.
|
||||||
|
|
||||||
|
1. Si provi un grafico a "sciame" per mostrare la distribuzione dei valori:
|
||||||
|
|
||||||
|
```python
|
||||||
|
sns.swarmplot(x="Color", y="Item Size", data=new_pumpkins)
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
### Grafico violino
|
||||||
|
|
||||||
|
Un grafico di tipo "violino" è utile in quanto è possibile visualizzare facilmente il modo in cui sono distribuiti i dati nelle due categorie. I grafici di tipo violino non funzionano così bene con insieme di dati più piccoli poiché la distribuzione viene visualizzata in modo più "liscio".
|
||||||
|
|
||||||
|
1. Chiamare `catplot()` passando i parametri `x=Color`, `kind="violin"` :
|
||||||
|
|
||||||
|
```python
|
||||||
|
sns.catplot(x="Color", y="Item Size",
|
||||||
|
kind="violin", data=new_pumpkins)
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
✅ Provare a creare questo grafico e altri grafici Seaborn, utilizzando altre variabili.
|
||||||
|
|
||||||
|
Ora che si ha un'idea della relazione tra le categorie binarie di colore e il gruppo più ampio di dimensioni, si esplora la regressione logistica per determinare il probabile colore di una data zucca.
|
||||||
|
|
||||||
|
> **🧮 Mostrami la matematica**
|
||||||
|
>
|
||||||
|
> Si ricorda come la regressione lineare usava spesso i minimi quadrati ordinari per arrivare a un valore? La regressione logistica si basa sul concetto di "massima verosimiglianza" utilizzando [le funzioni sigmoidi](https://wikipedia.org/wiki/Sigmoid_function). Una "Funzione Sigmoide" su un grafico ha l'aspetto di una forma a "S". Prende un valore e lo mappa da qualche parte tra 0 e 1. La sua curva è anche chiamata "curva logistica". La sua formula si presenta così:
|
||||||
|
>
|
||||||
|
> 
|
||||||
|
>
|
||||||
|
> dove il punto medio del sigmoide si trova nel punto 0 di x, L è il valore massimo della curva e k è la pendenza della curva. Se l'esito della funzione è maggiore di 0,5, all'etichetta in questione verrà assegnata la classe '1' della scelta binaria. In caso contrario, sarà classificata come '0'.
|
||||||
|
|
||||||
|
## Costruire il modello
|
||||||
|
|
||||||
|
Costruire un modello per trovare queste classificazioni binarie è sorprendentemente semplice in Scikit-learn.
|
||||||
|
|
||||||
|
1. Si selezionano le variabili da utilizzare nel modello di classificazione e si dividono gli insiemi di training e test chiamando `train_test_split()`:
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.model_selection import train_test_split
|
||||||
|
|
||||||
|
Selected_features = ['Origin','Item Size','Variety','City Name','Package']
|
||||||
|
|
||||||
|
X = new_pumpkins[Selected_features]
|
||||||
|
y = new_pumpkins['Color']
|
||||||
|
|
||||||
|
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Ora si può addestrare il modello, chiamando `fit()` con i dati di addestramento e stamparne il risultato:
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.model_selection import train_test_split
|
||||||
|
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))
|
||||||
|
```
|
||||||
|
|
||||||
|
Si dia un'occhiata al tabellone segnapunti del modello. Non è male, considerando che si hanno solo circa 1000 righe di dati:
|
||||||
|
|
||||||
|
```output
|
||||||
|
precision recall f1-score support
|
||||||
|
|
||||||
|
0 0.85 0.95 0.90 166
|
||||||
|
1 0.38 0.15 0.22 33
|
||||||
|
|
||||||
|
accuracy 0.82 199
|
||||||
|
macro avg 0.62 0.55 0.56 199
|
||||||
|
weighted avg 0.77 0.82 0.78 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 0 0 0 0 0 0 0 0 0 0 1 0 0 0
|
||||||
|
0 0 0 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 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 0 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 0 0 0 0 0 0 0 0 0 0 0 0 1 1 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 0 0 0 0 0 0 0 0 0 0 0 0
|
||||||
|
0 0 0 1 0 1 0 0 1 0 0 0 1 0]
|
||||||
|
```
|
||||||
|
|
||||||
|
## Migliore comprensione tramite una matrice di confusione
|
||||||
|
|
||||||
|
Sebbene si possano ottenere [i termini](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.classification_report.html?highlight=classification_report#sklearn.metrics.classification_report) del rapporto dei punteggi stampando gli elementi di cui sopra, si potrebbe essere in grado di comprendere più facilmente il modello utilizzando una [matrice di confusione](https://scikit-learn.org/stable/modules/model_evaluation.html#confusion-matrix) che aiuti a capire come lo stesso sta funzionando.
|
||||||
|
|
||||||
|
> 🎓 Una '[matrice di confusione](https://it.wikipedia.org/wiki/Matrice_di_confusione)' (o 'matrice di errore') è una tabella che esprime i veri contro i falsi positivi e negativi del modello, misurando così l'accuratezza delle previsioni.
|
||||||
|
|
||||||
|
1. Per utilizzare una metrica di confusione, si `chiama confusion_matrix()`:
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.metrics import confusion_matrix
|
||||||
|
confusion_matrix(y_test, predictions)
|
||||||
|
```
|
||||||
|
|
||||||
|
Si dia un'occhiata alla matrice di confusione del modello:
|
||||||
|
|
||||||
|
```output
|
||||||
|
array([[162, 4],
|
||||||
|
[ 33, 0]])
|
||||||
|
```
|
||||||
|
|
||||||
|
Cosa sta succedendo qui? Si supponga che al modello venga chiesto di classificare gli elementi tra due categorie binarie, la categoria "zucca" e la categoria "non una zucca".
|
||||||
|
|
||||||
|
- Se il modello prevede qualcosa come una zucca e appartiene alla categoria 'zucca' in realtà lo si chiama un vero positivo, mostrato dal numero in alto a sinistra.
|
||||||
|
- Se il modello prevede qualcosa come non una zucca e appartiene alla categoria 'zucca' in realtà si chiama falso positivo, mostrato dal numero in alto a destra.
|
||||||
|
- Se il modello prevede qualcosa come una zucca e appartiene alla categoria 'non-una-zucca' in realtà si chiama falso negativo, mostrato dal numero in basso a sinistra.
|
||||||
|
- Se il modello prevede qualcosa come non una zucca e appartiene alla categoria 'non-una-zucca' in realtà lo si chiama un vero negativo, mostrato dal numero in basso a destra.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
> Infografica di [Jen Looper](https://twitter.com/jenlooper)
|
||||||
|
|
||||||
|
Come si sarà intuito, è preferibile avere un numero maggiore di veri positivi e veri negativi e un numero inferiore di falsi positivi e falsi negativi, il che implica che il modello funziona meglio.
|
||||||
|
|
||||||
|
✅ Domanda: Secondo la matrice di confusione, come si è comportato il modello? Risposta: Non male; ci sono un buon numero di veri positivi ma anche diversi falsi negativi.
|
||||||
|
|
||||||
|
I termini visti in precedenza vengono rivisitati con l'aiuto della mappatura della matrice di confusione di TP/TN e FP/FN:
|
||||||
|
|
||||||
|
🎓 Precisione: TP/(TP + FN) La frazione di istanze rilevanti tra le istanze recuperate (ad es. quali etichette erano ben etichettate)
|
||||||
|
|
||||||
|
🎓 Richiamo: TP/(TP + FP) La frazione di istanze rilevanti che sono state recuperate, ben etichettate o meno
|
||||||
|
|
||||||
|
🎓 f1-score: (2 * precisione * richiamo)/(precisione + richiamo) Una media ponderata della precisione e del richiamo, dove il migliore è 1 e il peggiore è 0
|
||||||
|
|
||||||
|
🎓 Supporto: il numero di occorrenze di ciascuna etichetta recuperata
|
||||||
|
|
||||||
|
🎓 Accuratezza: (TP + TN)/(TP + TN + FP + FN) La percentuale di etichette prevista accuratamente per un campione.
|
||||||
|
|
||||||
|
🎓 Macro Media: il calcolo delle metriche medie non ponderate per ciascuna etichetta, senza tener conto dello squilibrio dell'etichetta.
|
||||||
|
|
||||||
|
🎓 Media ponderata: il calcolo delle metriche medie per ogni etichetta, tenendo conto dello squilibrio dell'etichetta pesandole in base al loro supporto (il numero di istanze vere per ciascuna etichetta).
|
||||||
|
|
||||||
|
✅ Si riesce a pensare a quale metrica si dovrebbe guardare se si vuole che il modello riduca il numero di falsi negativi?
|
||||||
|
|
||||||
|
## Visualizzare la curva ROC di questo modello
|
||||||
|
|
||||||
|
Questo non è un cattivo modello; la sua precisione è nell'intervallo dell'80%, quindi idealmente si potrebbe usare per prevedere il colore di una zucca dato un insieme di variabili.
|
||||||
|
|
||||||
|
Si rende un'altra visualizzazione per vedere il cosiddetto punteggio 'ROC':
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.metrics import roc_curve, roc_auc_score
|
||||||
|
|
||||||
|
y_scores = model.predict_proba(X_test)
|
||||||
|
# calculate ROC curve
|
||||||
|
fpr, tpr, thresholds = roc_curve(y_test, y_scores[:,1])
|
||||||
|
sns.lineplot([0, 1], [0, 1])
|
||||||
|
sns.lineplot(fpr, tpr)
|
||||||
|
```
|
||||||
|
Usando di nuovo Seaborn, si traccia la [Caratteristica Operativa di Ricezione](https://scikit-learn.org/stable/auto_examples/model_selection/plot_roc.html?highlight=roc) o il ROC del modello. Le curve ROC vengono spesso utilizzate per ottenere una visualizzazione dell'output di un classificatore in termini di veri e falsi positivi. "Le curve ROC in genere presentano un tasso di veri positivi sull'asse Y e un tasso di falsi positivi sull'asse X". Pertanto, la ripidità della curva e lo spazio tra la linea del punto medio e la curva contano: si vuole una curva che si sposti rapidamente verso l'alto e oltre la linea. In questo caso, ci sono falsi positivi con cui iniziare, quindi la linea si dirige correttamente:
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Infine, si usa l'[`API roc_auc_score`](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html?highlight=roc_auc#sklearn.metrics.roc_auc_score) di Scikit-learn per calcolare l'effettiva "Area sotto la curva" (AUC):
|
||||||
|
|
||||||
|
```python
|
||||||
|
auc = roc_auc_score(y_test,y_scores[:,1])
|
||||||
|
print(auc)
|
||||||
|
```
|
||||||
|
Il risultato è `0.6976998904709748`. Dato che l'AUC varia da 0 a 1, si desidera un punteggio elevato, poiché un modello corretto al 100% nelle sue previsioni avrà un AUC di 1; in questo caso, il modello è _abbastanza buono_.
|
||||||
|
|
||||||
|
Nelle lezioni future sulle classificazioni si imparerà come eseguire l'iterazione per migliorare i punteggi del modello. Ma per ora, congratulazioni! Si sono completate queste lezioni di regressione!
|
||||||
|
|
||||||
|
---
|
||||||
|
## 🚀 Sfida
|
||||||
|
|
||||||
|
C'è molto altro da svelare riguardo alla regressione logistica! Ma il modo migliore per imparare è sperimentare. Trovare un insieme di dati che si presti a questo tipo di analisi e costruire un modello con esso. Cosa si è appreso? suggerimento: provare [Kaggle](https://kaggle.com) per ottenere insiemi di dati interessanti.
|
||||||
|
|
||||||
|
## [Quiz post-lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/16/)
|
||||||
|
|
||||||
|
## Revisione e Auto Apprendimento
|
||||||
|
|
||||||
|
Leggere le prime pagine di [questo articolo da Stanford](https://web.stanford.edu/~jurafsky/slp3/5.pdf) su alcuni usi pratici della regressione logistica. Si pensi alle attività più adatte per l'uno o l'altro tipo di attività di regressione studiate fino a questo punto. Cosa funzionerebbe meglio?
|
||||||
|
|
||||||
|
## Compito
|
||||||
|
|
||||||
|
[Ritentare questa regressione](assignment.it.md)
|
||||||
@ -0,0 +1,10 @@
|
|||||||
|
# Riprovare un po' di Regressione
|
||||||
|
|
||||||
|
## Istruzioni
|
||||||
|
|
||||||
|
Nella lezione è stato usato un sottoinsieme dei dati della zucca. Ora si torna ai dati originali e si prova a usarli tutti, puliti e standardizzati, per costruire un modello di regressione logistica.
|
||||||
|
## Rubrica
|
||||||
|
|
||||||
|
| Criteri | Ottimo | Adeguato | Necessita miglioramento |
|
||||||
|
| -------- | ----------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
|
||||||
|
| | Un notebook viene presentato con un modello ben spiegato con buone prestazioni | Un notebook viene presentato con un modello dalle prestazioni minime | Un notebook viene presentato con un modello con scarse o nessuna prestazione |
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
# 再探回归模型
|
||||||
|
|
||||||
|
## 说明
|
||||||
|
|
||||||
|
在这节课中，你使用了 pumpkin 数据集的子集。现在，让我们回到原始数据，并尝试使用所有数据。经过了数据清理和标准化，建立一个逻辑回归模型。
|
||||||
|
|
||||||
|
## 评判标准
|
||||||
|
|
||||||
|
| 标准 | 优秀 | 中规中矩 | 仍需努力 |
|
||||||
|
| -------- | ----------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------------------- |
|
||||||
|
| | 用notebook呈现了一个解释性和性能良好的模型 | 用notebook呈现了一个性能一般的模型 | 用notebook呈现了一个性能差的模型或根本没有模型 |
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
# Modelli di regressione per machine learning
|
||||||
|
|
||||||
|
## Argomento regionale: modelli di Regressione per i prezzi della zucca in Nord America 🎃
|
||||||
|
|
||||||
|
In Nord America, le zucche sono spesso intagliate in facce spaventose per Halloween. Si scoprirà di più su queste affascinanti verdure!
|
||||||
|
|
||||||
|
|
||||||
|
> Foto di <a href="https://unsplash.com/@teutschmann?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Beth Teutschmann</a> su <a href="https://unsplash.com/s/photos/jack-o-lanterns?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||||
|
|
||||||
|
## Cosa si imparerà
|
||||||
|
|
||||||
|
Le lezioni in questa sezione riguardano i tipi di regressione nel contesto di machine learning. I modelli di regressione possono aiutare a determinare la _relazione_ tra le variabili. Questo tipo di modello può prevedere valori come lunghezza, temperatura o età, scoprendo così le relazioni tra le variabili mentre analizza i punti dati.
|
||||||
|
|
||||||
|
In questa serie di lezioni si scoprirà la differenza tra regressione lineare e regressione logistica e quando si dovrebbe usare l'una o l'altra.
|
||||||
|
|
||||||
|
In questo gruppo di lezioni si imposterà una configurazione per iniziare le attività di machine learning, inclusa la configurazione di Visual Studio Code per gestire i notebook, l'ambiente comune per i data scientist. Si scoprirà Scikit-learn, una libreria per machine learning, e si creeranno i primi modelli, concentrandosi in questo capitolo sui modelli di Regressione.
|
||||||
|
|
||||||
|
> Esistono utili strumenti a basso codice che possono aiutare a imparare a lavorare con i modelli di regressione. Si provi [Azure Machine Learning per questa attività](https://docs.microsoft.com/learn/modules/create-regression-model-azure-machine-learning-designer/?WT.mc_id=academic-15963-cxa)
|
||||||
|
|
||||||
|
### Lezioni
|
||||||
|
|
||||||
|
1. [Gli Attrezzi Necessari](1-Tools/README.md)
|
||||||
|
2. [Gestione dati](2-Data/README.md)
|
||||||
|
3. [Regressione lineare e polinomiale](3-Linear/README.md)
|
||||||
|
4. [Regressione logistica](4-Logistic/README.md)
|
||||||
|
|
||||||
|
---
|
||||||
|
### Crediti
|
||||||
|
|
||||||
|
"ML con regressione" scritto con ♥️ da [Jen Looper](https://twitter.com/jenlooper)
|
||||||
|
|
||||||
|
♥️ I collaboratori del quiz includono: [Muhammad Sakib Khan Inan](https://twitter.com/Sakibinan) e [Ornella Altunyan](https://twitter.com/ornelladotcom)
|
||||||
|
|
||||||
|
L'insieme di dati relativi alla zucca è suggerito da [questo progetto su](https://www.kaggle.com/usda/a-year-of-pumpkin-prices) Kaggle e i suoi dati provengono dai [Rapporti Standard sui Mercati Terminali delle Colture Speciali](https://www.marketnews.usda.gov/mnp/fv-report-config-step1?type=termPrice) distribuiti dal Dipartimento dell'Agricoltura degli Stati Uniti. Sono stati aggiunti alcuni punti intorno al colore in base alla varietà per normalizzare la distribuzione. Questi dati sono di pubblico dominio.
|
||||||
@ -0,0 +1,347 @@
|
|||||||
|
# Crearere un'app web per utilizzare un modello ML
|
||||||
|
|
||||||
|
In questa lezione, si addestrerà un modello ML su un insieme di dati fuori dal mondo: _avvistamenti di UFO nel secolo scorso_, provenienti dal [database di NUFORC](https://www.nuforc.org).
|
||||||
|
|
||||||
|
Si imparerà:
|
||||||
|
|
||||||
|
- Come "scapigliare" un modello addestrato
|
||||||
|
- Come usare quel modello in un'app Flask
|
||||||
|
|
||||||
|
Si continuerà a utilizzare i notebook per pulire i dati e addestrare il modello, ma si può fare un ulteriore passo avanti esplorando il processo utilizzando un modello "in the wild", per così dire: in un'app web.
|
||||||
|
|
||||||
|
Per fare ciò, è necessario creare un'app Web utilizzando Flask.
|
||||||
|
|
||||||
|
## [Quiz Pre-Lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/17/)
|
||||||
|
|
||||||
|
## Costruire un'app
|
||||||
|
|
||||||
|
Esistono diversi modi per creare app Web per utilizzare modelli di machine learning. L'architettura web può influenzare il modo in cui il modello viene addestrato. Si immagini di lavorare in un'azienda in cui il gruppo di data science ha addestrato un modello che vogliono che venga utilizzato in un'app.
|
||||||
|
|
||||||
|
### Considerazioni
|
||||||
|
|
||||||
|
Ci sono molte domande da porsi:
|
||||||
|
|
||||||
|
- **È un'app Web o un'app mobile?** Se si sta creando un'app mobile o si deve usare il modello in un contesto IoT, ci si può avvalere [di TensorFlow Lite](https://www.tensorflow.org/lite/) e usare il modello in un'app Android o iOS.
|
||||||
|
- **Dove risiederà il modello**? E' utilizzato in cloud o in locale?
|
||||||
|
- **Supporto offline**. L'app deve funzionare offline?
|
||||||
|
- **Quale tecnologia è stata utilizzata per addestrare il modello?** La tecnologia scelta può influenzare gli strumenti che è necessario utilizzare.
|
||||||
|
- **Utilizzare** TensorFlow Se si sta addestrando un modello utilizzando TensorFlow, ad esempio, tale ecosistema offre la possibilità di convertire un modello TensorFlow per l'utilizzo in un'app Web utilizzando [TensorFlow.js](https://www.tensorflow.org/js/).
|
||||||
|
- **Utilizzare PyTorch**. Se stai costruendo un modello utilizzando una libreria come PyTorch[,](https://pytorch.org/) si ha la possibilità di esportarlo in formato [ONNX](https://onnx.ai/) ( Open Neural Network Exchange) per l'utilizzo in app Web JavaScript che possono utilizzare il motore di esecuzione [Onnx](https://www.onnxruntime.ai/). Questa opzione verrà esplorata in una lezione futura per un modello addestrato da Scikit-learn
|
||||||
|
- **Utilizzo di Lobe.ai o Azure Custom vision**. Se si sta usando un sistema ML SaaS (Software as a Service) come [Lobe.ai](https://lobe.ai/) o [Azure Custom Vision](https://azure.microsoft.com/services/cognitive-services/custom-vision-service/?WT.mc_id=academic-15963-cxa) per addestrare un modello, questo tipo di software fornisce modi per esportare il modello per molte piattaforme, inclusa la creazione di un'API su misura da interrogare nel cloud dalla propria applicazione online.
|
||||||
|
|
||||||
|
Si hai anche l'opportunità di creare un'intera app Web Flask in grado di addestrare il modello stesso in un browser Web. Questo può essere fatto anche usando TensorFlow.js in un contesto JavaScript.
|
||||||
|
|
||||||
|
Per i nostri scopi, poiché si è lavorato con i notebook basati su Python, verranno esplorati i passaggi necessari per esportare un modello addestrato da un tale notebook in un formato leggibile da un'app Web creata in Python.
|
||||||
|
|
||||||
|
## Strumento
|
||||||
|
|
||||||
|
Per questa attività sono necessari due strumenti: Flask e Pickle, entrambi eseguiti su Python.
|
||||||
|
|
||||||
|
✅ Cos'è [Flask](https://palletsprojects.com/p/flask/)? Definito come un "micro-framework" dai suoi creatori, Flask fornisce le funzionalità di base dei framework web utilizzando Python e un motore di modelli per creare pagine web. Si dia un'occhiata a [questo modulo di apprendimento](https://docs.microsoft.com/learn/modules/python-flask-build-ai-web-app?WT.mc_id=academic-15963-cxa) per esercitarsi a costruire con Flask.
|
||||||
|
|
||||||
|
✅ Cos'è [Pickle](https://docs.python.org/3/library/pickle.html)? Pickle 🥒 è un modulo Python che serializza e de-serializza una struttura di oggetti Python. Quando si utilizza pickle in un modello, si serializza o si appiattisce la sua struttura per l'uso sul web. Cautela: pickle non è intrinsecamente sicuro, quindi si faccia attenzione se viene chiesto di de-serializzare un file. Un file creato con pickle ha il suffisso `.pkl`.
|
||||||
|
|
||||||
|
## Esercizio: pulire i dati
|
||||||
|
|
||||||
|
In questa lezione verranno utilizzati i dati di 80.000 avvistamenti UFO, raccolti da [NUFORC](https://nuforc.org) (The National UFO Reporting Center). Questi dati hanno alcune descrizioni interessanti di avvistamenti UFO, ad esempio:
|
||||||
|
|
||||||
|
- **Descrizione di esempio lunga**. "Un uomo emerge da un raggio di luce che di notte brilla su un campo erboso e corre verso il parcheggio della Texas Instruments".
|
||||||
|
- **Descrizione di esempio breve**. "le luci ci hanno inseguito".
|
||||||
|
|
||||||
|
Il [foglio](./data/ufos.csv) di calcolo ufos.csv include colonne sulla `città`, `lo stato` e il `paese` in cui è avvenuto l'avvistamento, la `forma dell'oggetto e la` sua `latitudine` e `longitudine`.
|
||||||
|
|
||||||
|
Nel [notebook](notebook.ipynb) vuoto incluso in questa lezione:
|
||||||
|
|
||||||
|
1. importare `pandas`, `matplotlib` e numpy `come` fatto nelle lezioni precedenti e importare il foglio di calcolo ufos. Si può dare un'occhiata a un insieme di dati di esempio:
|
||||||
|
|
||||||
|
```python
|
||||||
|
import pandas as pd
|
||||||
|
import numpy as np
|
||||||
|
|
||||||
|
ufos = pd.read_csv('../data/ufos.csv')
|
||||||
|
ufos.head()
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Convertire i dati ufos in un piccolo dataframe con nuove intestazioni Controllare i valori univoci nel campo `Country` .
|
||||||
|
|
||||||
|
```python
|
||||||
|
ufos = pd.DataFrame({'Seconds': ufos['duration (seconds)'], 'Country': ufos['country'],'Latitude': ufos['latitude'],'Longitude': ufos['longitude']})
|
||||||
|
|
||||||
|
ufos.Country.unique()
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Ora si può ridurre la quantità di dati da gestire eliminando qualsiasi valore nullo e importando solo avvistamenti tra 1-60 secondi:
|
||||||
|
|
||||||
|
```python
|
||||||
|
ufos.dropna(inplace=True)
|
||||||
|
|
||||||
|
ufos = ufos[(ufos['Seconds'] >= 1) & (ufos['Seconds'] <= 60)]
|
||||||
|
|
||||||
|
ufos.info()
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Importare la libreria LabelEncoder `di` Scikit-learn per convertire i valori di testo per i paesi in un numero:
|
||||||
|
|
||||||
|
✅ LabelEncoder codifica i dati in ordine alfabetico
|
||||||
|
|
||||||
|
```python
|
||||||
|
from sklearn.preprocessing import LabelEncoder
|
||||||
|
|
||||||
|
ufos['Country'] = LabelEncoder().fit_transform(ufos['Country'])
|
||||||
|
|
||||||
|
ufos.head()
|
||||||
|
```
|
||||||
|
|
||||||
|
I dati dovrebbero assomigliare a questo:
|
||||||
|
|
||||||
|
```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
|
||||||
|
```
|
||||||
|
|
||||||
|
## Esercizio: costruire il proprio modello
|
||||||
|
|
||||||
|
Ora ci si può preparare per addestrare un modello portando i dati nel gruppo di addestramento e test.
|
||||||
|
|
||||||
|
1. Selezionare le tre caratteristiche su cui lo si vuole allenare come vettore X mentre il vettore y sarà `Country` Se deve essere in grado di inserire `Secondi`, `Latitudine` e `Longitudine` e ottenere un ID nazione da restituire.
|
||||||
|
|
||||||
|
```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. Addestrare il modello usando la regressione logistica:
|
||||||
|
|
||||||
|
```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))
|
||||||
|
```
|
||||||
|
|
||||||
|
La precisione non è male **(circa il 95%)**, non sorprende che `Country` e `Latitude/Longitude` siano correlati.
|
||||||
|
|
||||||
|
Il modello creato non è molto rivoluzionario in quanto si dovrebbe essere in grado di dedurre una `nazione` dalla sua `latitudine` e `longitudine`, ma è un buon esercizio provare ad allenare dai dati grezzi che sono stati puliti ed esportati, e quindi utilizzare questo modello in una app web.
|
||||||
|
|
||||||
|
## Esercizio: usare pickle con il modello
|
||||||
|
|
||||||
|
Ora è il momento di utilizzare pickle _con_ il modello! Lo si può fare in poche righe di codice. Una volta che è stato serializzato con pickle_,_ caricare il modello e testarlo rispetto a un array di dati di esempio contenente valori per secondi, latitudine e longitudine,
|
||||||
|
|
||||||
|
```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]]))
|
||||||
|
```
|
||||||
|
|
||||||
|
Il modello restituisce **"3"**, che è il codice paese per il Regno Unito. Jolly 👽
|
||||||
|
|
||||||
|
## Esercizio: creare un'app Flask
|
||||||
|
|
||||||
|
Ora si può creare un'app Flask per chiamare il modello e restituire risultati simili, ma in un modo visivamente più gradevole.
|
||||||
|
|
||||||
|
1. Iniziare creando una cartella chiamata web-app **a** livello del _file_ notebook.ipynb dove risiede _il_ file ufo-model.pkl.
|
||||||
|
|
||||||
|
1. In quella cartella creare altre tre cartelle: **static**, con una cartella **css** al suo interno e **templates**. Ora si dovrebbero avere i seguenti file e directory:
|
||||||
|
|
||||||
|
```output
|
||||||
|
web-app/
|
||||||
|
static/
|
||||||
|
css/
|
||||||
|
templates/
|
||||||
|
notebook.ipynb
|
||||||
|
ufo-model.pkl
|
||||||
|
```
|
||||||
|
|
||||||
|
✅ Fare riferimento alla cartella della soluzione per una visualizzazione dell'app finita
|
||||||
|
|
||||||
|
1. Il primo file da creare nella cartella dell'_app_ Web è **il** file requirements.txt. Come _package.json_ in un'app JavaScript, questo file elenca le dipendenze richieste dall'app. In **requirements.txt** aggiungere le righe:
|
||||||
|
|
||||||
|
```text
|
||||||
|
scikit-learn
|
||||||
|
pandas
|
||||||
|
numpy
|
||||||
|
flask
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Ora, eseguire questo file portandosi su _web-app_:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
cd web-app
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Aprire una finestra di terminale dove risiede requirements.txt e digitare `pip install`, per installare le librerie elencate in _reuirements.txt_:
|
||||||
|
|
||||||
|
```bash
|
||||||
|
pip install -r requirements.txt
|
||||||
|
```
|
||||||
|
|
||||||
|
1. Ora si è pronti per creare altri tre file per completare l'app:
|
||||||
|
|
||||||
|
1. Crea **app.py** nella directory radice
|
||||||
|
2. Creare **index.html** nella directory _templates_ .
|
||||||
|
3. Crea **sytles.css** nella directory _static/css_ .
|
||||||
|
|
||||||
|
1. Inserire nel _file_ styles.css alcuni stili:
|
||||||
|
|
||||||
|
```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. Quindi, creare il file _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>
|
||||||
|
```
|
||||||
|
|
||||||
|
Dare un'occhiata al modello in questo file. Notare la sintassi con le parentesi graffe attorno alle variabili che verranno fornite dall'app, come il testo di previsione: `{{}}`. C'è anche un modulo che invia una previsione al percorso `/` predict.
|
||||||
|
|
||||||
|
Infine, si è pronti per creare il file python che guida il consumo del modello e la visualizzazione delle previsioni:
|
||||||
|
|
||||||
|
1. In `app.py` aggiungere:
|
||||||
|
|
||||||
|
```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)
|
||||||
|
```
|
||||||
|
|
||||||
|
> 💡 Suggerimento: quando si aggiunge [`debug=True`](https://www.askpython.com/python-modules/flask/flask-debug-mode) durante l'esecuzione dell'app Web utilizzando Flask, qualsiasi modifica apportata all'applicazione verrà applicata immediatamente senza la necessità di riavviare il server. Attenzione! Non abilitare questa modalità in un'app di produzione.
|
||||||
|
|
||||||
|
Se si esegue `python app.py` o `python3 app.py` , il server web si avvia, localmente, e si può compilare un breve modulo per ottenere una risposta alla domanda scottante su dove sono stati avvistati gli UFO!
|
||||||
|
|
||||||
|
Prima di farlo, dare un'occhiata alle parti di `app.py`:
|
||||||
|
|
||||||
|
1. Innanzitutto, le dipendenze vengono caricate e l'app si avvia.
|
||||||
|
1. Quindi, il modello viene importato.
|
||||||
|
1. Quindi, index.html viene visualizzato sulla rotta home.
|
||||||
|
|
||||||
|
Sulla rotta `/predict` , accadono diverse cose quando il modulo viene inviato:
|
||||||
|
|
||||||
|
1. Le variabili del modulo vengono raccolte e convertite in un array numpy. Vengono quindi inviati al modello e viene restituita una previsione.
|
||||||
|
2. Le nazioni che si vogliono visualizzare vengono nuovamente esposte come testo leggibile dal loro codice paese previsto e tale valore viene inviato a index.html per essere visualizzato nel modello.
|
||||||
|
|
||||||
|
Usare un modello in questo modo, con Flask e un modello serializzato è relativamente semplice. La cosa più difficile è capire che forma hanno i dati che devono essere inviati al modello per ottenere una previsione. Tutto dipende da come è stato addestrato il modello. Questo ha tre punti dati da inserire per ottenere una previsione.
|
||||||
|
|
||||||
|
In un ambiente professionale, si può vedere quanto sia necessaria una buona comunicazione tra le persone che addestrano il modello e coloro che lo consumano in un'app Web o mobile. In questo caso, si ricoprono entrambi i ruoli!
|
||||||
|
|
||||||
|
---
|
||||||
|
|
||||||
|
## 🚀 Sfida
|
||||||
|
|
||||||
|
Invece di lavorare su un notebook e importare il modello nell'app Flask, si può addestrare il modello direttamente nell'app Flask! Provare a convertire il codice Python nel notebook, magari dopo che i dati sono stati puliti, per addestrare il modello dall'interno dell'app su un percorso chiamato /`train`. Quali sono i pro e i contro di seguire questo metodo?
|
||||||
|
|
||||||
|
## [Quiz post-lezione](https://jolly-sea-0a877260f.azurestaticapps.net/quiz/18/)
|
||||||
|
|
||||||
|
## Revisione e Auto Apprendimento
|
||||||
|
|
||||||
|
Esistono molti modi per creare un'app Web per utilizzare i modelli ML. Elencare dei modi in cui si potrebbe utilizzare JavaScript o Python per creare un'app Web per sfruttare machine learning. Considerare l'architettura: il modello dovrebbe rimanere nell'app o risiedere nel cloud? Se quest'ultimo, come accedervi? Disegnare un modello architettonico per una soluzione web ML applicata.
|
||||||
|
|
||||||
|
## Compito
|
||||||
|
|
||||||
|
[Provare un modello diverso](assignment.md)
|
||||||
|
|
||||||
|
|
||||||
@ -0,0 +1,11 @@
|
|||||||
|
# Provare un modello diverso
|
||||||
|
|
||||||
|
## Istruzioni
|
||||||
|
|
||||||
|
Ora che si è creato un'app Web utilizzando un modello di regressione addestrato, usare uno dei modelli di una lezione precedente sulla regressione per ripetere questa app Web. Si può mantenere lo stile o progettarla in modo diverso per riflettere i dati della zucca. Fare attenzione a modificare gli input in modo che riflettano il metodo di addestramento del proprio modello.
|
||||||
|
|
||||||
|
## Rubrica
|
||||||
|
|
||||||
|
| Criteri | Ottimo | Adeguato | Necessita miglioramento |
|
||||||
|
| -------------------------- | --------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------- |
|
||||||
|
| | L'app Web funziona come previsto e viene distribuita nel cloud | L'app Web contiene difetti o mostra risultati imprevisti | L'app web non funziona correttamente |
|
||||||
@ -0,0 +1,22 @@
|
|||||||
|
# Creare un'app Web per utilizzare il modello ML
|
||||||
|
|
||||||
|
In questa sezione del programma di studi, verrà presentato un argomento ML applicato: come salvare il modello di Scikit-learn come file che può essere utilizzato per fare previsioni all'interno di un'applicazione web. Una volta salvato il modello, si imparerà come utilizzarlo in un'app Web integrata in Flask. Per prima cosa si creerà un modello utilizzando alcuni dati che riguardano gli avvistamenti di UFO! Quindi, si creerà un'app Web che consentirà di inserire un numero di secondi con un valore di latitudine e longitudine per prevedere quale paese ha riferito di aver visto un UFO.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
Foto di <a href="https://unsplash.com/@mdherren?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Michael Herren</a> su <a href="https://unsplash.com/s/photos/ufo?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
|
||||||
|
|
||||||
|
|
||||||
|
## Lezioni
|
||||||
|
|
||||||
|
1. [Costruire un'app Web](1-Web-App/README.md)
|
||||||
|
|
||||||
|
## Crediti
|
||||||
|
|
||||||
|
"Costruire un'app web" è stato scritto con ♥️ da [Jen Looper](https://twitter.com/jenlooper).
|
||||||
|
|
||||||
|
♥️ I quiz sono stati scritti da Rohan Raj.
|
||||||
|
|
||||||
|
L'insieme di dati proviene da [Kaggle](https://www.kaggle.com/NUFORC/ufo-sightings).
|
||||||
|
|
||||||
|
L'architettura dell'app web è stata suggerita in parte da [questo articolo](https://towardsdatascience.com/how-to-easily-deploy-machine-learning-models-using-flask-b95af8fe34d4) e da [questo](https://github.com/abhinavsagar/machine-learning-deployment) repository di Abhinav Sagar.
|
||||||
|
Can't render this file because it is too large.
|
File diff suppressed because it is too large
Load Diff
@ -1,12 +1,14 @@
|
|||||||
// index.js
|
// index.js
|
||||||
import en from './en.json';
|
import en from './en.json';
|
||||||
import tr from './tr.json';
|
import tr from './tr.json';
|
||||||
|
import fr from './fr.json';
|
||||||
|
|
||||||
//export const defaultLocale = 'en';
|
//export const defaultLocale = 'en';
|
||||||
|
|
||||||
const messages = {
|
const messages = {
|
||||||
en: en[0],
|
en: en[0],
|
||||||
tr: tr[0],
|
tr: tr[0],
|
||||||
|
fr: fr[0]
|
||||||
};
|
};
|
||||||
|
|
||||||
export default messages;
|
export default messages;
|
||||||
|
|||||||
Loading…
Reference in new issue