History

leestott 98900475bd 🌐 Update translations via Co-op Translator		3 weeks ago
..
solution	🌐 Update translations via Co-op Translator	3 weeks ago
README.md	🌐 Update translations via Co-op Translator	3 weeks ago
assignment.md	🌐 Update translations via Co-op Translator	3 weeks ago
notebook.ipynb	🌐 Update translations via Co-op Translator	3 weeks ago

README.md

Introduksjon til klassifisering

I disse fire leksjonene skal du utforske et grunnleggende fokusområde innen klassisk maskinlæring - klassifisering. Vi skal gå gjennom bruken av ulike klassifiseringsalgoritmer med et datasett om alle de fantastiske kjøkkenene i Asia og India. Håper du er sulten!

Feir pan-asiatiske kjøkken i disse leksjonene! Bilde av Jen Looper

Klassifisering er en form for supervised learning som har mye til felles med regresjonsteknikker. Hvis maskinlæring handler om å forutsi verdier eller navn på ting ved hjelp av datasett, faller klassifisering generelt inn i to grupper: binær klassifisering og multiklasse klassifisering.

🎥 Klikk på bildet over for en video: MITs John Guttag introduserer klassifisering

Husk:

Lineær regresjon hjalp deg med å forutsi forholdet mellom variabler og lage nøyaktige spådommer om hvor et nytt datapunkt ville falle i forhold til den linjen. For eksempel kunne du forutsi hva prisen på et gresskar ville være i september vs. desember.
Logistisk regresjon hjalp deg med å oppdage "binære kategorier": ved dette prisnivået, er dette gresskaret oransje eller ikke-oransje?

Klassifisering bruker ulike algoritmer for å bestemme andre måter å avgjøre en datapunktopps etikett eller klasse. La oss jobbe med dette matlagingsdatasettet for å se om vi, ved å observere en gruppe ingredienser, kan avgjøre hvilket kjøkken de tilhører.

Quiz før leksjonen

Denne leksjonen er tilgjengelig i R!

Introduksjon

Klassifisering er en av de grunnleggende aktivitetene for maskinlæringsforskere og dataforskere. Fra enkel klassifisering av en binær verdi ("er denne e-posten spam eller ikke?"), til kompleks bildeklassifisering og segmentering ved hjelp av datamaskinsyn, er det alltid nyttig å kunne sortere data i klasser og stille spørsmål om det.

For å formulere prosessen på en mer vitenskapelig måte, skaper klassifiseringsmetoden din en prediktiv modell som gjør det mulig å kartlegge forholdet mellom inputvariabler og outputvariabler.

Binære vs. multiklasse problemer for klassifiseringsalgoritmer å håndtere. Infografikk av Jen Looper

Før vi starter prosessen med å rense dataene våre, visualisere dem og forberede dem for våre ML-oppgaver, la oss lære litt om de ulike måtene maskinlæring kan brukes til å klassifisere data.

Avledet fra statistikk, bruker klassifisering med klassisk maskinlæring funksjoner som smoker, weight og age for å avgjøre sannsynligheten for å utvikle X sykdom. Som en supervised learning-teknikk, lik de regresjonsøvelsene du utførte tidligere, er dataene dine merket, og ML-algoritmene bruker disse merkene til å klassifisere og forutsi klasser (eller 'funksjoner') i et datasett og tilordne dem til en gruppe eller et utfall.

✅ Ta et øyeblikk til å forestille deg et datasett om matretter. Hva ville en multiklassemodell kunne svare på? Hva ville en binær modell kunne svare på? Hva om du ville avgjøre om en gitt matrett sannsynligvis bruker bukkehornkløver? Hva om du ville se om du, gitt en pose med stjerneanis, artisjokker, blomkål og pepperrot, kunne lage en typisk indisk rett?

🎥 Klikk på bildet over for en video. Hele premisset for showet 'Chopped' er 'mystery basket', der kokker må lage en rett ut av et tilfeldig utvalg ingredienser. Sikkert en ML-modell ville ha hjulpet!

Hei 'klassifiserer'

Spørsmålet vi ønsker å stille til dette matlagingsdatasettet er faktisk et multiklasse-spørsmål, siden vi har flere potensielle nasjonale kjøkken å jobbe med. Gitt en gruppe ingredienser, hvilken av disse mange klassene passer dataene inn i?

Scikit-learn tilbyr flere forskjellige algoritmer for å klassifisere data, avhengig av hvilken type problem du vil løse. I de neste to leksjonene skal du lære om flere av disse algoritmene.

Øvelse - rens og balanser dataene dine

Den første oppgaven, før du starter dette prosjektet, er å rense og balansere dataene dine for å få bedre resultater. Start med den tomme notebook.ipynb-filen i roten av denne mappen.

Det første du må installere er imblearn. Dette er en Scikit-learn-pakke som lar deg bedre balansere dataene (du vil lære mer om denne oppgaven om et øyeblikk).

For å installere imblearn, kjør pip install, slik:
```
pip install imblearn
```
Importer pakkene du trenger for å importere dataene dine og visualisere dem, og importer også SMOTE fra imblearn.
```
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE
```
Nå er du klar til å lese og importere dataene.
Den neste oppgaven vil være å importere dataene:
```
df  = pd.read_csv('../data/cuisines.csv')
```
Ved å bruke read_csv() vil innholdet i csv-filen cusines.csv bli lest og plassert i variabelen df.

Sjekk formen på dataene:

df.head()

De første fem radene ser slik ut:

|     | 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å informasjon om disse dataene ved å kalle info():

df.info()

Utdataene dine ligner:

<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

Øvelse - lære om matretter

Nå begynner arbeidet å bli mer interessant. La oss oppdage fordelingen av data per kjøkken.

Plott dataene som stolper ved å kalle barh():
```
df.cuisine.value_counts().plot.barh()
```
Det er et begrenset antall kjøkken, men fordelingen av data er ujevn. Du kan fikse det! Før du gjør det, utforsk litt mer.

Finn ut hvor mye data som er tilgjengelig per kjøkken og skriv det ut:

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

Utdataene ser slik ut:

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

Oppdage ingredienser

Nå kan du grave dypere i dataene og lære hva som er de typiske ingrediensene per kjøkken. Du bør rense ut gjentakende data som skaper forvirring mellom kjøkken, så la oss lære om dette problemet.

Lag en funksjon create_ingredient() i Python for å lage en ingrediens-datasett. Denne funksjonen vil starte med å fjerne en unyttig kolonne og sortere ingredienser etter antall:

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

Nå kan du bruke den funksjonen til å få en idé om de ti mest populære ingrediensene per kjøkken.

Kall create_ingredient() og plott det ved å kalle barh():

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

Gjør det samme for de japanske dataene:

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

Nå for de kinesiske ingrediensene:

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

Plott de indiske ingrediensene:

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

Til slutt, plott de koreanske ingrediensene:

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

Nå, fjern de vanligste ingrediensene som skaper forvirring mellom ulike kjøkken, ved å kalle drop():

Alle elsker ris, hvitløk og ingefær!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```

Balanser datasettet

Nå som du har renset dataene, bruk SMOTE - "Synthetic Minority Over-sampling Technique" - for å balansere det.

Kall fit_resample(), denne strategien genererer nye prøver ved interpolasjon.
```
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
Ved å balansere dataene dine, vil du få bedre resultater når du klassifiserer dem. Tenk på en binær klassifisering. Hvis mesteparten av dataene dine er én klasse, vil en ML-modell forutsi den klassen oftere, bare fordi det er mer data for den. Å balansere dataene tar skjeve data og hjelper med å fjerne denne ubalansen.

Nå kan du sjekke antall etiketter per ingrediens:

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

Utdataene dine ser slik ut:

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

Dataene er fine og rene, balanserte og veldig delikate!

Det siste trinnet er å lagre de balanserte dataene, inkludert etiketter og funksjoner, i et nytt datasett som kan eksporteres til en fil:
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
Du kan ta en siste titt på dataene ved å bruke transformed_df.head() og transformed_df.info(). Lagre en kopi av disse dataene for bruk i fremtidige leksjoner:
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
Denne ferske CSV-filen kan nå finnes i rotdata-mappen.

🚀Utfordring

Dette pensumet inneholder flere interessante datasett. Grav gjennom data-mappene og se om noen inneholder datasett som ville være passende for binær eller multiklasse klassifisering? Hvilke spørsmål ville du stille til dette datasettet?

Quiz etter leksjonen

Gjennomgang og selvstudium

Utforsk SMOTEs API. Hvilke bruksområder er det best egnet for? Hvilke problemer løser det?

Oppgave

Utforsk klassifiseringsmetoder

Ansvarsfraskrivelse:
Dette dokumentet er oversatt ved hjelp av AI-oversettelsestjenesten Co-op Translator. Selv om vi streber etter nøyaktighet, vær oppmerksom på at automatiserte oversettelser kan inneholde feil eller unøyaktigheter. Det originale dokumentet på sitt opprinnelige språk bør anses som den autoritative kilden. For kritisk informasjon anbefales profesjonell menneskelig oversettelse. Vi er ikke ansvarlige for eventuelle misforståelser eller feiltolkninger som oppstår ved bruk av denne oversettelsen.