15 KiB

Raw Permalink Blame History Unescape Escape

Pengelompokan Masakan 1

Dalam pelajaran ini, Anda akan menggunakan dataset yang telah Anda simpan dari pelajaran sebelumnya, yang berisi data seimbang dan bersih tentang berbagai jenis masakan.

Anda akan menggunakan dataset ini dengan berbagai pengelompokan untuk memprediksi jenis masakan nasional berdasarkan kelompok bahan. Sambil melakukannya, Anda akan mempelajari lebih lanjut tentang beberapa cara algoritma dapat digunakan untuk tugas klasifikasi.

Kuis sebelum pelajaran

Persiapan

Dengan asumsi Anda telah menyelesaikan Pelajaran 1, pastikan file cleaned_cuisines.csv ada di folder root /data untuk empat pelajaran ini.

Latihan - memprediksi jenis masakan nasional

Bekerja di folder notebook.ipynb pelajaran ini, impor file tersebut bersama dengan pustaka Pandas:
```
import pandas as pd
cuisines_df = pd.read_csv("../data/cleaned_cuisines.csv")
cuisines_df.head()
```
Data terlihat seperti ini:

	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

Sekarang, impor beberapa pustaka lagi:

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

Pisahkan koordinat X dan y ke dalam dua dataframe untuk pelatihan. cuisine dapat menjadi dataframe label:

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

Data akan terlihat seperti ini:

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

Hapus kolom Unnamed: 0 dan kolom cuisine dengan memanggil drop(). Simpan data lainnya sebagai fitur yang dapat dilatih:
```
cuisines_feature_df = cuisines_df.drop(['Unnamed: 0', 'cuisine'], axis=1)
cuisines_feature_df.head()
```
Fitur Anda akan terlihat seperti ini:

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

Sekarang Anda siap untuk melatih model Anda!

Memilih pengelompokan

Setelah data Anda bersih dan siap untuk pelatihan, Anda harus memutuskan algoritma mana yang akan digunakan untuk tugas ini.

Scikit-learn mengelompokkan klasifikasi di bawah Pembelajaran Terawasi, dan dalam kategori tersebut Anda akan menemukan banyak cara untuk mengelompokkan. Ragamnya cukup membingungkan pada pandangan pertama. Metode berikut semuanya mencakup teknik klasifikasi:

Model Linear
Support Vector Machines
Stochastic Gradient Descent
Nearest Neighbors
Gaussian Processes
Decision Trees
Metode Ensemble (Voting Classifier)
Algoritma Multikelas dan multioutput (klasifikasi multikelas dan multilabel, klasifikasi multikelas-multioutput)

Anda juga dapat menggunakan jaringan saraf untuk mengelompokkan data, tetapi itu di luar cakupan pelajaran ini.

Pengelompokan mana yang harus dipilih?

Jadi, pengelompokan mana yang harus Anda pilih? Sering kali, mencoba beberapa dan mencari hasil yang baik adalah cara untuk menguji. Scikit-learn menawarkan perbandingan berdampingan pada dataset yang dibuat, membandingkan KNeighbors, SVC dua cara, GaussianProcessClassifier, DecisionTreeClassifier, RandomForestClassifier, MLPClassifier, AdaBoostClassifier, GaussianNB, dan QuadraticDiscriminationAnalysis, menunjukkan hasil yang divisualisasikan:

Grafik dihasilkan dari dokumentasi Scikit-learn

AutoML menyelesaikan masalah ini dengan menjalankan perbandingan ini di cloud, memungkinkan Anda memilih algoritma terbaik untuk data Anda. Coba di sini

Pendekatan yang lebih baik

Pendekatan yang lebih baik daripada menebak secara acak adalah mengikuti ide-ide pada ML Cheat Sheet yang dapat diunduh ini. Di sini, kita menemukan bahwa, untuk masalah multikelas kita, kita memiliki beberapa pilihan:

Bagian dari Algorithm Cheat Sheet Microsoft, merinci opsi klasifikasi multikelas

✅ Unduh cheat sheet ini, cetak, dan tempel di dinding Anda!

Penalaran

Mari kita lihat apakah kita dapat menalar melalui pendekatan yang berbeda mengingat kendala yang kita miliki:

Jaringan saraf terlalu berat. Mengingat dataset kita yang bersih tetapi minimal, dan fakta bahwa kita menjalankan pelatihan secara lokal melalui notebook, jaringan saraf terlalu berat untuk tugas ini.
Tidak menggunakan pengelompokan dua kelas. Kita tidak menggunakan pengelompokan dua kelas, jadi itu mengesampingkan one-vs-all.
Decision tree atau logistic regression bisa digunakan. Decision tree mungkin cocok, atau logistic regression untuk data multikelas.
Multiclass Boosted Decision Trees menyelesaikan masalah yang berbeda. Multiclass boosted decision tree paling cocok untuk tugas nonparametrik, misalnya tugas yang dirancang untuk membangun peringkat, sehingga tidak berguna untuk kita.

Menggunakan Scikit-learn

Kita akan menggunakan Scikit-learn untuk menganalisis data kita. Namun, ada banyak cara untuk menggunakan logistic regression di Scikit-learn. Lihat parameter yang dapat diteruskan.

Pada dasarnya ada dua parameter penting - multi_class dan solver - yang perlu kita tentukan, saat kita meminta Scikit-learn untuk melakukan logistic regression. Nilai multi_class menerapkan perilaku tertentu. Nilai solver adalah algoritma yang akan digunakan. Tidak semua solver dapat dipasangkan dengan semua nilai multi_class.

Menurut dokumentasi, dalam kasus multikelas, algoritma pelatihan:

Menggunakan skema one-vs-rest (OvR), jika opsi multi_class diatur ke ovr
Menggunakan cross-entropy loss, jika opsi multi_class diatur ke multinomial. (Saat ini opsi multinomial hanya didukung oleh solver ‘lbfgs’, ‘sag’, ‘saga’, dan ‘newton-cg’.)"

🎓 'Skema' di sini bisa berupa 'ovr' (one-vs-rest) atau 'multinomial'. Karena logistic regression sebenarnya dirancang untuk mendukung klasifikasi biner, skema ini memungkinkan algoritma tersebut menangani tugas klasifikasi multikelas dengan lebih baik. sumber

🎓 'Solver' didefinisikan sebagai "algoritma yang digunakan dalam masalah optimasi". sumber.

Scikit-learn menawarkan tabel ini untuk menjelaskan bagaimana solver menangani tantangan yang berbeda yang disajikan oleh berbagai jenis struktur data:

Latihan - membagi data

Kita dapat fokus pada logistic regression untuk percobaan pelatihan pertama kita karena Anda baru saja mempelajari tentang hal ini dalam pelajaran sebelumnya. Pisahkan data Anda menjadi kelompok pelatihan dan pengujian dengan memanggil train_test_split():

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

Latihan - menerapkan logistic regression

Karena Anda menggunakan kasus multikelas, Anda perlu memilih skema yang akan digunakan dan solver yang akan diatur. Gunakan LogisticRegression dengan pengaturan multikelas dan solver liblinear untuk melatih.

Buat logistic regression dengan multi_class diatur ke ovr dan solver diatur ke 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))
```
✅ Coba solver lain seperti lbfgs, yang sering diatur sebagai default Gunakan fungsi Pandas ravel untuk meratakan data Anda jika diperlukan. Akurasi model ini cukup baik, yaitu di atas 80%!

Anda dapat melihat model ini beraksi dengan menguji satu baris data (#50):

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

Hasilnya dicetak:

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

✅ Cobalah nomor baris yang berbeda dan periksa hasilnya.

Lebih mendalam, Anda dapat memeriksa akurasi prediksi ini:
```
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()
```
Hasilnya dicetak - masakan India adalah tebakan terbaiknya, dengan probabilitas yang baik:

0

indian 0.715851

chinese 0.229475

japanese 0.029763

korean 0.017277

thai 0.007634

✅ Bisakah Anda menjelaskan mengapa model ini cukup yakin bahwa ini adalah masakan India?

	0
indian	0.715851
chinese	0.229475
japanese	0.029763
korean	0.017277
thai	0.007634

Dapatkan lebih banyak detail dengan mencetak laporan klasifikasi, seperti yang Anda lakukan dalam pelajaran regresi:

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

	precision	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
accuracy	0.80	1199
macro avg	0.80	0.80	0.80	1199
weighted avg	0.80	0.80	0.80	1199

🚀Tantangan

Dalam pelajaran ini, Anda menggunakan data yang telah dibersihkan untuk membangun model pembelajaran mesin yang dapat memprediksi jenis masakan berdasarkan serangkaian bahan. Luangkan waktu untuk membaca berbagai opsi yang disediakan Scikit-learn untuk mengklasifikasikan data. Pelajari lebih dalam konsep 'solver' untuk memahami apa yang terjadi di balik layar.

Kuis setelah pelajaran

Tinjauan & Studi Mandiri

Pelajari lebih dalam tentang matematika di balik regresi logistik dalam pelajaran ini

Tugas

Pelajari tentang solver

Penafian:
Dokumen ini telah diterjemahkan menggunakan layanan penerjemahan AI Co-op Translator. Meskipun kami berusaha untuk memberikan hasil yang akurat, harap diingat bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang otoritatif. Untuk informasi yang bersifat kritis, disarankan menggunakan jasa penerjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini.

	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

15 KiB Raw Permalink Blame History Unescape Escape