16 KiB

Raw Permalink Blame History Unescape Escape

Categorieën van keukens 1

In deze les gebruik je de dataset die je in de vorige les hebt opgeslagen, vol met gebalanceerde, schone gegevens over keukens.

Je zult deze dataset gebruiken met verschillende classificatiemethoden om een nationale keuken te voorspellen op basis van een groep ingrediënten. Terwijl je dit doet, leer je meer over enkele manieren waarop algoritmen kunnen worden ingezet voor classificatietaken.

Quiz voorafgaand aan de les

Voorbereiding

Als je Les 1 hebt voltooid, zorg er dan voor dat een bestand genaamd cleaned_cuisines.csv zich bevindt in de root /data map voor deze vier lessen.

Oefening - voorspel een nationale keuken

Werk in de map notebook.ipynb van deze les en importeer dat bestand samen met de Pandas-bibliotheek:
```
import pandas as pd
cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
cuisines_df.head()
```
De gegevens zien er als volgt uit:

	Unnamed: 0	cuisine	almond	...	yogurt
0	0	indian	0	...	0
1	1	indian	1	...	0
2	2	indian	0	...	0
3	3	indian	0	...	0
4	4	indian	0	...	1

Importeer nu nog enkele andere bibliotheken:

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report, precision_recall_curve
from sklearn.svm import SVC
import numpy as np

Verdeel de X- en y-coördinaten in twee dataframes voor training. cuisine kan de labels-dataset zijn:

cuisines_label_df = cuisines_df['cuisine']
cuisines_label_df.head()

Het ziet er als volgt uit:

0    indian
1    indian
2    indian
3    indian
4    indian
Name: cuisine, dtype: object

Laat die Unnamed: 0-kolom en de cuisine-kolom vallen door drop() aan te roepen. Sla de rest van de gegevens op als trainbare kenmerken:
```
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
cuisines_feature_df.head()
```
Je kenmerken zien er als volgt uit:

	almond	...	yogurt
0	0	...	0
1	1	...	0
2	0	...	0
3	0	...	0
4	0	...	1

Nu ben je klaar om je model te trainen!

Het kiezen van je classifier

Nu je gegevens schoon en klaar zijn voor training, moet je beslissen welk algoritme je voor de taak wilt gebruiken.

Scikit-learn groepeert classificatie onder Gecontroleerd Leren, en in die categorie vind je veel manieren om te classificeren. De variëteit kan in eerste instantie overweldigend lijken. De volgende methoden bevatten allemaal technieken voor classificatie:

Lineaire modellen
Support Vector Machines
Stochastic Gradient Descent
Nabijheid van buren
Gaussiaanse processen
Beslissingsbomen
Ensemble-methoden (stemmen Classifier)
Multiclass- en multioutput-algoritmen (multiclass- en multilabel-classificatie, multiclass-multioutput-classificatie)

Je kunt ook neurale netwerken gebruiken om gegevens te classificeren, maar dat valt buiten de scope van deze les.

Welke classifier moet je kiezen?

Dus, welke classifier moet je kiezen? Vaak is het testen van verschillende classifiers en kijken naar een goed resultaat een manier om te testen. Scikit-learn biedt een vergelijking naast elkaar op een gecreëerde dataset, waarbij KNeighbors, SVC op twee manieren, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB en QuadraticDiscriminationAnalysis worden vergeleken, en de resultaten worden gevisualiseerd:

Plots gegenereerd in de documentatie van Scikit-learn

AutoML lost dit probleem handig op door deze vergelijkingen in de cloud uit te voeren, zodat je het beste algoritme voor je gegevens kunt kiezen. Probeer het hier

Een betere aanpak

Een betere manier dan willekeurig gokken is echter om de ideeën te volgen op dit downloadbare ML Cheat sheet. Hier ontdekken we dat we voor ons multiclass-probleem enkele keuzes hebben:

Een sectie van Microsoft's Algorithm Cheat Sheet, met opties voor multiclass-classificatie

✅ Download dit cheat sheet, print het uit en hang het aan je muur!

Redenering

Laten we kijken of we verschillende benaderingen kunnen beredeneren, gegeven de beperkingen die we hebben:

Neurale netwerken zijn te zwaar. Gezien onze schone, maar minimale dataset, en het feit dat we lokaal trainen via notebooks, zijn neurale netwerken te zwaar voor deze taak.
Geen tweeklassen-classifier. We gebruiken geen tweeklassen-classifier, dus dat sluit one-vs-all uit.
Beslissingsboom of logistische regressie zou kunnen werken. Een beslissingsboom zou kunnen werken, of logistische regressie voor multiclass-gegevens.
Multiclass Boosted Decision Trees lossen een ander probleem op. De multiclass boosted decision tree is het meest geschikt voor niet-parametrische taken, bijvoorbeeld taken die zijn ontworpen om ranglijsten te maken, dus het is niet nuttig voor ons.

Gebruik van Scikit-learn

We zullen Scikit-learn gebruiken om onze gegevens te analyseren. Er zijn echter veel manieren om logistische regressie te gebruiken in Scikit-learn. Bekijk de parameters om door te geven.

In wezen zijn er twee belangrijke parameters - multi_class en solver - die we moeten specificeren wanneer we Scikit-learn vragen om een logistische regressie uit te voeren. De waarde van multi_class past een bepaald gedrag toe. De waarde van de solver bepaalt welk algoritme wordt gebruikt. Niet alle solvers kunnen worden gecombineerd met alle multi_class-waarden.

Volgens de documentatie, in het multiclass-geval, gebruikt het trainingsalgoritme:

Het one-vs-rest (OvR) schema, als de multi_class optie is ingesteld op ovr
De cross-entropy loss, als de multi_class optie is ingesteld op multinomial. (Momenteel wordt de multinomial optie alleen ondersteund door de ‘lbfgs’, ‘sag’, ‘saga’ en ‘newton-cg’ solvers.)"

🎓 Het 'schema' hier kan 'ovr' (one-vs-rest) of 'multinomial' zijn. Aangezien logistische regressie eigenlijk is ontworpen om binaire classificatie te ondersteunen, stellen deze schema's het in staat om beter om te gaan met multiclass-classificatietaken. bron

🎓 De 'solver' wordt gedefinieerd als "het algoritme dat wordt gebruikt in het optimalisatieprobleem". bron.

Scikit-learn biedt deze tabel om uit te leggen hoe solvers omgaan met verschillende uitdagingen die worden gepresenteerd door verschillende soorten datastructuren:

Oefening - splits de gegevens

We kunnen ons richten op logistische regressie voor onze eerste trainingspoging, aangezien je onlangs over de laatste hebt geleerd in een vorige les. Splits je gegevens in trainings- en testgroepen door train_test_split() aan te roepen:

X_train, X_test, y_train, y_test = train_test_split(cuisines_feature_df, cuisines_label_df, test_size=0.3)

Oefening - pas logistische regressie toe

Aangezien je het multiclass-geval gebruikt, moet je kiezen welk schema je wilt gebruiken en welke solver je wilt instellen. Gebruik LogisticRegression met een multiclass-instelling en de liblinear solver om te trainen.

Maak een logistische regressie met multi_class ingesteld op ovr en de solver ingesteld op liblinear:

lr = LogisticRegression(multi_class='ovr',solver='liblinear')
model = lr.fit(X_train, np.ravel(y_train))

accuracy = model.score(X_test, y_test)
print ("Accuracy is {}".format(accuracy))

✅ Probeer een andere solver zoals lbfgs, die vaak als standaard wordt ingesteld

Let op, gebruik de Pandas ravel functie om je data te flatten wanneer nodig. De nauwkeurigheid is goed bij meer dan 80%!

Je kunt dit model in actie zien door één rij gegevens te testen (#50):

print(f'ingredients: {X_test.iloc[50][X_test.iloc[50]!=0].keys()}')
print(f'cuisine: {y_test.iloc[50]}')

Het resultaat wordt afgedrukt:

ingredients: Index(['cilantro', 'onion', 'pea', 'potato', 'tomato', 'vegetable_oil'], dtype='object')
cuisine: indian

✅ Probeer een ander rijnummer en controleer de resultaten.

Door dieper te graven, kun je de nauwkeurigheid van deze voorspelling controleren:
```
test= X_test.iloc[50].values.reshape(-1, 1).T
proba = model.predict_proba(test)
classes = model.classes_
resultdf = pd.DataFrame(data=proba, columns=classes)

topPrediction = resultdf.T.sort_values(by=[0], ascending = [False])
topPrediction.head()
```
Het resultaat wordt afgedrukt - Indiase keuken is de beste gok, met een goede waarschijnlijkheid:

0

indian 0.715851

chinese 0.229475

japanese 0.029763

korean 0.017277

thai 0.007634

✅ Kun je uitleggen waarom het model er vrij zeker van is dat dit een Indiase keuken is?

	0
indian	0.715851
chinese	0.229475
japanese	0.029763
korean	0.017277
thai	0.007634

Krijg meer details door een classificatierapport af te drukken, zoals je deed in de lessen over regressie:

y_pred = model.predict(X_test)
print(classification_report(y_test,y_pred))

	precisie	recall	f1-score	support
chinese	0.73	0.71	0.72	229
indian	0.91	0.93	0.92	254
japanese	0.70	0.75	0.72	220
korean	0.86	0.76	0.81	242
thai	0.79	0.85	0.82	254
nauwkeurigheid	0.80	1199
macro gem.	0.80	0.80	0.80	1199
gewogen gem.	0.80	0.80	0.80	1199

🚀Uitdaging

In deze les heb je je schoongemaakte gegevens gebruikt om een machine learning-model te bouwen dat een nationale keuken kan voorspellen op basis van een reeks ingrediënten. Neem de tijd om de vele opties te bekijken die Scikit-learn biedt om gegevens te classificeren. Verdiep je in het concept van 'solver' om te begrijpen wat er achter de schermen gebeurt.

Quiz na de les

Review & Zelfstudie

Verdiep je wat meer in de wiskunde achter logistische regressie in deze les

Opdracht

Bestudeer de solvers

Disclaimer:
Dit document is vertaald met behulp van de AI-vertalingsservice Co-op Translator. Hoewel we streven naar nauwkeurigheid, dient u zich ervan bewust te zijn dat geautomatiseerde vertalingen fouten of onnauwkeurigheden kunnen bevatten. Het originele document in de oorspronkelijke taal moet worden beschouwd als de gezaghebbende bron. Voor cruciale informatie wordt professionele menselijke vertaling aanbevolen. Wij zijn niet aansprakelijk voor eventuele misverstanden of verkeerde interpretaties die voortvloeien uit het gebruik van deze vertaling.

	almond	...	yogurt
0	0	...	0
1	1	...	0
2	0	...	0
3	0	...	0
4	0	...	1

	almond	...	yogurt
0	0	...	0
1	1	...	0
2	0	...	0
3	0	...	0
4	0	...	1

16 KiB Raw Permalink Blame History Unescape Escape