15 KiB

Raw Blame History

Introduzione alla classificazione

In queste quattro lezioni, esplorerai un aspetto fondamentale del machine learning classico: la classificazione. Utilizzeremo vari algoritmi di classificazione con un dataset che riguarda tutte le brillanti cucine dell'Asia e dell'India. Speriamo che tu abbia fame!

Celebra le cucine pan-asiatiche in queste lezioni! Immagine di Jen Looper

La classificazione è una forma di apprendimento supervisionato che ha molto in comune con le tecniche di regressione. Se il machine learning riguarda la previsione di valori o nomi utilizzando dataset, allora la classificazione si divide generalmente in due gruppi: classificazione binaria e classificazione multiclass.

🎥 Clicca sull'immagine sopra per un video: John Guttag del MIT introduce la classificazione

Ricorda:

La regressione lineare ti ha aiutato a prevedere le relazioni tra variabili e a fare previsioni accurate su dove un nuovo punto dati si posizionerebbe rispetto a quella linea. Ad esempio, potresti prevedere quanto costerà una zucca a settembre rispetto a dicembre.
La regressione logistica ti ha aiutato a scoprire "categorie binarie": a questo prezzo, questa zucca è arancione o non arancione?

La classificazione utilizza vari algoritmi per determinare altri modi di assegnare un'etichetta o una classe a un punto dati. Lavoriamo con questi dati sulle cucine per vedere se, osservando un gruppo di ingredienti, possiamo determinare la cucina di origine.

Quiz pre-lezione

Questa lezione è disponibile in R!

Introduzione

La classificazione è una delle attività fondamentali per i ricercatori di machine learning e i data scientist. Dalla classificazione di base di un valore binario ("questa email è spam o no?") alla classificazione e segmentazione complessa di immagini utilizzando la visione artificiale, è sempre utile poter ordinare i dati in classi e porre domande su di essi.

Per esprimere il processo in modo più scientifico, il tuo metodo di classificazione crea un modello predittivo che ti consente di mappare la relazione tra variabili di input e variabili di output.

Problemi binari vs. multiclass per gli algoritmi di classificazione. Infografica di Jen Looper

Prima di iniziare il processo di pulizia dei dati, visualizzarli e prepararli per i nostri compiti di ML, impariamo un po' sui vari modi in cui il machine learning può essere utilizzato per classificare i dati.

Derivata dalla statistica, la classificazione utilizzando il machine learning classico utilizza caratteristiche come smoker, weight e age per determinare la probabilità di sviluppare X malattia. Come tecnica di apprendimento supervisionato simile agli esercizi di regressione che hai svolto in precedenza, i tuoi dati sono etichettati e gli algoritmi di ML utilizzano quelle etichette per classificare e prevedere classi (o 'caratteristiche') di un dataset e assegnarle a un gruppo o risultato.

✅ Prenditi un momento per immaginare un dataset sulle cucine. A cosa potrebbe rispondere un modello multiclass? E un modello binario? E se volessi determinare se una determinata cucina utilizza probabilmente il fieno greco? E se volessi vedere se, dato un sacchetto di generi alimentari contenente anice stellato, carciofi, cavolfiori e rafano, potresti creare un tipico piatto indiano?

🎥 Clicca sull'immagine sopra per un video. L'intero concetto dello show 'Chopped' è il 'cestino misterioso', dove gli chef devono creare un piatto con una scelta casuale di ingredienti. Sicuramente un modello di ML avrebbe aiutato!

Ciao 'classificatore'

La domanda che vogliamo porre a questo dataset sulle cucine è in realtà una domanda multiclass, poiché abbiamo diverse potenziali cucine nazionali con cui lavorare. Dato un gruppo di ingredienti, a quale di queste molte classi appartiene il dato?

Scikit-learn offre diversi algoritmi per classificare i dati, a seconda del tipo di problema che vuoi risolvere. Nelle prossime due lezioni, imparerai alcuni di questi algoritmi.

Esercizio - pulire e bilanciare i dati

Il primo compito, prima di iniziare questo progetto, è pulire e bilanciare i dati per ottenere risultati migliori. Inizia con il file vuoto notebook.ipynb nella radice di questa cartella.

La prima cosa da installare è imblearn. Questo è un pacchetto di Scikit-learn che ti permetterà di bilanciare meglio i dati (imparerai di più su questo compito tra un momento).

Per installare imblearn, esegui pip install, come segue:
```
pip install imblearn
```

Importa i pacchetti necessari per importare i dati e visualizzarli, e importa anche SMOTE da imblearn.

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE

Ora sei pronto per importare i dati.

Il prossimo compito sarà importare i dati:
```
df  = pd.read_csv('../data/cuisines.csv')
```
Utilizzando read_csv() leggerai il contenuto del file csv cusines.csv e lo posizionerai nella variabile df.

Controlla la forma dei dati:

df.head()

Le prime cinque righe appaiono così:

|     | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0   | 65         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 1   | 66         | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 2   | 67         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 3   | 68         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 4   | 69         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |

Ottieni informazioni su questi dati chiamando info():

df.info()

Il tuo output sarà simile a:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2448 entries, 0 to 2447
Columns: 385 entries, Unnamed: 0 to zucchini
dtypes: int64(384), object(1)
memory usage: 7.2+ MB

Esercizio - scoprire le cucine

Ora il lavoro inizia a diventare più interessante. Scopriamo la distribuzione dei dati per cucina.

Traccia i dati come barre chiamando barh():
```
df.cuisine.value_counts().plot.barh()
```
Ci sono un numero finito di cucine, ma la distribuzione dei dati è disomogenea. Puoi risolvere questo problema! Prima di farlo, esplora un po' di più.

Scopri quanta quantità di dati è disponibile per ogni cucina e stampala:

thai_df = df[(df.cuisine == "thai")]
japanese_df = df[(df.cuisine == "japanese")]
chinese_df = df[(df.cuisine == "chinese")]
indian_df = df[(df.cuisine == "indian")]
korean_df = df[(df.cuisine == "korean")]

print(f'thai df: {thai_df.shape}')
print(f'japanese df: {japanese_df.shape}')
print(f'chinese df: {chinese_df.shape}')
print(f'indian df: {indian_df.shape}')
print(f'korean df: {korean_df.shape}')

L'output appare così:

thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)

Scoprire gli ingredienti

Ora puoi approfondire i dati e scoprire quali sono gli ingredienti tipici per ogni cucina. Dovresti eliminare i dati ricorrenti che creano confusione tra le cucine, quindi impariamo a conoscere questo problema.

Crea una funzione create_ingredient() in Python per creare un dataframe di ingredienti. Questa funzione inizierà eliminando una colonna non utile e ordinando gli ingredienti in base al loro conteggio:

def create_ingredient_df(df):
    ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
    ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
    ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
    inplace=False)
    return ingredient_df

Ora puoi utilizzare questa funzione per avere un'idea dei dieci ingredienti più popolari per cucina.

Chiama create_ingredient() e traccialo chiamando barh():

thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()

Fai lo stesso per i dati giapponesi:

japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()

Ora per gli ingredienti cinesi:

chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()

Traccia gli ingredienti indiani:

indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()

Infine, traccia gli ingredienti coreani:

korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()

Ora, elimina gli ingredienti più comuni che creano confusione tra cucine distinte, chiamando drop():

Tutti amano il riso, l'aglio e lo zenzero!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```

Bilanciare il dataset

Ora che hai pulito i dati, utilizza SMOTE - "Synthetic Minority Over-sampling Technique" - per bilanciarli.

Chiama fit_resample(), questa strategia genera nuovi campioni tramite interpolazione.
```
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
Bilanciando i tuoi dati, otterrai risultati migliori durante la classificazione. Pensa a una classificazione binaria. Se la maggior parte dei tuoi dati appartiene a una classe, un modello di ML predirà quella classe più frequentemente, semplicemente perché ci sono più dati per essa. Bilanciare i dati aiuta a rimuovere questo squilibrio.

Ora puoi controllare il numero di etichette per ingrediente:

print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')

Il tuo output appare così:

new label count: korean      799
chinese     799
indian      799
japanese    799
thai        799
Name: cuisine, dtype: int64
old label count: korean      799
indian      598
chinese     442
japanese    320
thai        289
Name: cuisine, dtype: int64

I dati sono puliti, bilanciati e molto deliziosi!

L'ultimo passaggio è salvare i tuoi dati bilanciati, incluse etichette e caratteristiche, in un nuovo dataframe che può essere esportato in un file:
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
Puoi dare un'ultima occhiata ai dati utilizzando transformed_df.head() e transformed_df.info(). Salva una copia di questi dati per usarli nelle lezioni future:
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
Questo nuovo CSV si trova ora nella cartella dei dati principali.

🚀Sfida

Questo curriculum contiene diversi dataset interessanti. Esplora le cartelle data e verifica se ce ne sono alcuni adatti per una classificazione binaria o multiclass. Quali domande potresti porre a questo dataset?

Quiz post-lezione

Revisione e studio autonomo

Esplora l'API di SMOTE. Per quali casi d'uso è più adatta? Quali problemi risolve?

Compito

Esplora i metodi di classificazione

Disclaimer:
Questo documento è stato tradotto utilizzando il servizio di traduzione automatica Co-op Translator. Sebbene ci impegniamo per garantire l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua nativa dovrebbe essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale effettuata da un traduttore umano. Non siamo responsabili per eventuali incomprensioni o interpretazioni errate derivanti dall'uso di questa traduzione.

15 KiB Raw Blame History