15 KiB

Raw Permalink Blame History

Introduktion till klassificering

I dessa fyra lektioner kommer du att utforska ett grundläggande fokus inom klassisk maskininlärning - klassificering. Vi kommer att gå igenom användningen av olika klassificeringsalgoritmer med en dataset om alla fantastiska kök från Asien och Indien. Hoppas du är hungrig!

Fira pan-asiatiska kök i dessa lektioner! Bild av Jen Looper

Klassificering är en form av övervakad inlärning som har mycket gemensamt med regressionstekniker. Om maskininlärning handlar om att förutsäga värden eller namn på saker med hjälp av dataset, så faller klassificering generellt sett in i två grupper: binär klassificering och multiklassklassificering.

🎥 Klicka på bilden ovan för en video: MIT:s John Guttag introducerar klassificering

Kom ihåg:

Linjär regression hjälpte dig att förutsäga relationer mellan variabler och göra exakta förutsägelser om var en ny datapunkt skulle hamna i förhållande till den linjen. Så, du kunde förutsäga vad priset på en pumpa skulle vara i september jämfört med december, till exempel.
Logistisk regression hjälpte dig att upptäcka "binära kategorier": vid denna prisnivå, är denna pumpa orange eller inte-orange?

Klassificering använder olika algoritmer för att bestämma andra sätt att avgöra en datapunkts etikett eller klass. Låt oss arbeta med denna dataset om kök för att se om vi, genom att observera en grupp ingredienser, kan avgöra dess ursprungskök.

Quiz före lektionen

Denna lektion finns tillgänglig i R!

Introduktion

Klassificering är en av de grundläggande aktiviteterna för forskare inom maskininlärning och dataanalytiker. Från grundläggande klassificering av ett binärt värde ("är detta e-postmeddelande skräppost eller inte?") till komplex bildklassificering och segmentering med hjälp av datorseende, är det alltid användbart att kunna sortera data i klasser och ställa frågor om den.

För att uttrycka processen på ett mer vetenskapligt sätt skapar din klassificeringsmetod en prediktiv modell som gör det möjligt att kartlägga relationen mellan indata och utdata.

Binära vs. multiklassproblem för klassificeringsalgoritmer att hantera. Infografik av Jen Looper

Innan vi börjar processen med att rensa vår data, visualisera den och förbereda den för våra ML-uppgifter, låt oss lära oss lite om de olika sätten maskininlärning kan användas för att klassificera data.

Härledd från statistik, klassificering med klassisk maskininlärning använder egenskaper, såsom smoker, weight och age för att avgöra sannolikheten att utveckla X sjukdom. Som en övervakad inlärningsteknik liknande de regressionövningar du utförde tidigare, är din data märkt och ML-algoritmerna använder dessa etiketter för att klassificera och förutsäga klasser (eller 'egenskaper') i en dataset och tilldela dem till en grupp eller ett resultat.

✅ Ta en stund och föreställ dig en dataset om kök. Vad skulle en multiklassmodell kunna svara på? Vad skulle en binär modell kunna svara på? Vad händer om du ville avgöra om ett visst kök sannolikt använder bockhornsklöver? Vad händer om du ville se om du, med en present av en matkasse full av stjärnanis, kronärtskockor, blomkål och pepparrot, kunde skapa en typisk indisk rätt?

🎥 Klicka på bilden ovan för en video. Hela premissen för programmet 'Chopped' är 'mysteriekorgen' där kockar måste göra en rätt av ett slumpmässigt val av ingredienser. Visst skulle en ML-modell ha hjälpt!

Hej 'klassificerare'

Frågan vi vill ställa om denna dataset om kök är faktiskt en multiklassfråga, eftersom vi har flera potentiella nationella kök att arbeta med. Givet en mängd ingredienser, vilken av dessa många klasser passar datan in i?

Scikit-learn erbjuder flera olika algoritmer att använda för att klassificera data, beroende på vilken typ av problem du vill lösa. I de kommande två lektionerna kommer du att lära dig om flera av dessa algoritmer.

Övning - rensa och balansera din data

Den första uppgiften, innan vi börjar detta projekt, är att rensa och balansera din data för att få bättre resultat. Börja med den tomma filen notebook.ipynb i roten av denna mapp.

Det första du behöver installera är imblearn. Detta är ett Scikit-learn-paket som gör det möjligt att bättre balansera datan (du kommer att lära dig mer om denna uppgift om en stund).

För att installera imblearn, kör pip install, så här:
```
pip install imblearn
```
Importera de paket du behöver för att importera din data och visualisera den, importera också SMOTE från imblearn.
```
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE
```
Nu är du redo att importera datan nästa gång.
Nästa uppgift är att importera datan:
```
df  = pd.read_csv('../data/cuisines.csv')
```
Genom att använda read_csv() kommer innehållet i csv-filen cusines.csv att läsas och placeras i variabeln df.

Kontrollera datans form:

df.head()

De första fem raderna ser ut så här:

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

Få information om denna data genom att kalla på info():

df.info()

Din utdata liknar:

<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

Övning - lära sig om kök

Nu börjar arbetet bli mer intressant. Låt oss upptäcka fördelningen av data, per kök.

Plotta datan som staplar genom att kalla på barh():
```
df.cuisine.value_counts().plot.barh()
```
Det finns ett begränsat antal kök, men fördelningen av data är ojämn. Du kan fixa det! Innan du gör det, utforska lite mer.

Ta reda på hur mycket data som finns tillgängligt per kök och skriv ut det:

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}')

Utdata ser ut så här:

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

Upptäcka ingredienser

Nu kan du gräva djupare i datan och lära dig vilka som är de typiska ingredienserna per kök. Du bör rensa bort återkommande data som skapar förvirring mellan kök, så låt oss lära oss om detta problem.

Skapa en funktion create_ingredient() i Python för att skapa en ingrediens-dataset. Denna funktion börjar med att ta bort en oanvändbar kolumn och sortera ingredienser efter deras antal:

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

Nu kan du använda den funktionen för att få en idé om de tio mest populära ingredienserna per kök.

Kalla på create_ingredient() och plotta det genom att kalla på barh():

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

Gör samma sak för den japanska datan:

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

Nu för de kinesiska ingredienserna:

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

Plotta de indiska ingredienserna:

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

Slutligen, plotta de koreanska ingredienserna:

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

Nu, ta bort de vanligaste ingredienserna som skapar förvirring mellan olika kök, genom att kalla på drop():

Alla älskar ris, vitlök och ingefära!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```

Balansera datasetet

Nu när du har rensat datan, använd SMOTE - "Synthetic Minority Over-sampling Technique" - för att balansera den.

Kalla på fit_resample(), denna strategi genererar nya prover genom interpolation.
```
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
Genom att balansera din data får du bättre resultat när du klassificerar den. Tänk på en binär klassificering. Om det mesta av din data är en klass, kommer en ML-modell att förutsäga den klassen oftare, bara för att det finns mer data för den. Att balansera datan tar bort eventuella snedvridningar och hjälper till att eliminera denna obalans.

Nu kan du kontrollera antalet etiketter per ingrediens:

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

Din utdata ser ut så här:

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

Datan är fin och ren, balanserad och mycket läcker!

Det sista steget är att spara din balanserade data, inklusive etiketter och egenskaper, i en ny dataset som kan exporteras till en fil:
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
Du kan ta en sista titt på datan med transformed_df.head() och transformed_df.info(). Spara en kopia av denna data för användning i framtida lektioner:
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
Denna nya CSV-fil kan nu hittas i rotens datamapp.

🚀Utmaning

Detta läroplan innehåller flera intressanta dataset. Gräv igenom data-mapparna och se om någon innehåller dataset som skulle vara lämpliga för binär eller multiklassklassificering? Vilka frågor skulle du ställa till denna dataset?

Quiz efter lektionen

Granskning & Självstudier

Utforska SMOTEs API. Vilka användningsområden är det bäst lämpat för? Vilka problem löser det?

Uppgift

Utforska klassificeringsmetoder

Ansvarsfriskrivning:
Detta dokument har översatts med hjälp av AI-översättningstjänsten Co-op Translator. Även om vi strävar efter noggrannhet, bör du vara medveten om att automatiserade översättningar kan innehålla fel eller felaktigheter. Det ursprungliga dokumentet på dess originalspråk bör betraktas som den auktoritativa källan. För kritisk information rekommenderas professionell mänsklig översättning. Vi ansvarar inte för eventuella missförstånd eller feltolkningar som uppstår vid användning av denna översättning.

15 KiB Raw Permalink Blame History