10 Pembelajaran Mesin Otomatis untuk Pembelajaran Terawasi (Bagian 2)

Artikel ini diterbitkan sebagai bagian dari Blogathon Ilmu Data

Pengantar

Postingan kali ini akan membahas 10 paket Automated Machine Learning (autoML) yang bisa kita jalankan dengan Python. Jika Anda lelah menjalankan banyak algoritme Pembelajaran Mesin hanya untuk menemukan yang terbaik, pos ini mungkin yang Anda cari. Posting ini adalah bagian kedua dari ini Pos pertama. Bagian pertama menjelaskan konsep umum Machine Learning mulai dari mendefinisikan tujuan, pra-pemrosesan, pembuatan dan pemilihan model, penyetelan hyperparameter, dan evaluasi model. Di akhir postingan tersebut, Auto-Sklearn diperkenalkan sebagai autoML. Jika Anda sudah terbiasa dengan Machine Learning, Anda dapat melewati bagian 1 itu.

Poin utama dari bagian pertama adalah kita membutuhkan waktu yang relatif lama dan banyak baris kode untuk menjalankan semua algoritma klasifikasi atau regresi sebelum akhirnya memilih atau menyusun model terbaik. Sebaliknya, kita dapat menjalankan AutoML untuk secara otomatis mencari model terbaik dengan waktu yang jauh lebih singkat dan, tentu saja, lebih sedikit kode. Temukan buku catatan saya untuk algoritme Pembelajaran Mesin konvensional untuk tugas regresi (memprediksi harga rumah) dan klasifikasi (memprediksi kelas tingkat kemiskinan) pada tabel di bawah. Buku catatan AutoML saya juga ada dalam tabel di bawah ini. Perhatikan bahwa posting ini hanya akan fokus pada regresi dan klasifikasi AutoML sementara AutoML juga dapat diterapkan untuk peramalan gambar, NLP atau teks, dan deret waktu.

Sekarang kita akan mulai membahas 10 paket AutoML yang bisa menggantikan notebook lama tersebut.

 Skler Otomatis

AutoML ini seperti yang sudah disebutkan di atas sudah pernah dibahas sebelumnya. Mari kita lakukan rekap cepat. Di bawah ini adalah kode untuk mencari model terbaik dalam 3 menit. Lebih jelasnya dijelaskan pada bagian pertama.

Regresi

!apt install -y build-essential swig curl !curl https://raw.githubusercontent.com/automl/auto-sklearn/master/requirements.txt | xargs -n 1 -L 1 pip instal !pip instal auto-sklearn !pip instal scipy==1.7.0 !pip instal -U scikit-belajar dari autosklearn.regression impor AutoSklearnRegressor dari sklearn.metrics impor mean_squared_error, mean_absolute_error

Menjalankan AutoSklearn

# Buat model sklearn = AutoSklearnRegressor(time_left_for_this_task=3*60, per_run_time_limit=30, n_jobs=-1) # Sesuaikan data pelatihan sklearn.fit(X_train, y_train) # Cetak Statistik Sprint(sklearn.sprint_statistics()) # Prediksikan data validasi pred_sklearn = sklearn.predict(X_val) # Hitung RMSE rmse_sklearn=MSE(y_val, pred_sklearn)**0.5 print('RMSE: ' + str(rmse_sklearn))

Keluaran:

hasil auto-sklearn: Nama dataset: c40b5794-fa4a-11eb-8116-0242ac130202 Metrik: r2 Skor validasi terbaik: 0.888788 Jumlah algoritme target yang dijalankan: 37 Jumlah algoritme target yang berhasil dijalankan: 23 Jumlah algoritme target yang di-crash yang dijalankan: 0 Jumlah algoritme target yang berhasil dijalankan: 8 algoritma target yang melebihi batas waktu: 6 Jumlah algoritma target yang melebihi batas memori: 27437.715258009852 RMSE: XNUMX

Hasil:

# Sebar plot nilai benar dan prediksi plt.scatter(pred_sklearn, y_val, alpha=0.2) plt.xlabel('predicted') plt.ylabel('true value') plt.text(100000, 400000, 'RMSE: ' + str (bulat(rmse_sklearn))) plt.text(100000, 350000, 'MAE: ' + str(bulat(mean_absolute_error(y_val, pred_sklearn)))) plt.text(100000, 300000, 'R: ' + str(bulat( np.corrcoef(y_val, pred_sklearn)[0,1],4))) plt.show()

Klasifikasi

Menerapkan AutoML

!apt install -y build-essential swig curl !curl https://raw.githubusercontent.com/automl/auto-sklearn/master/requirements.txt | xargs -n 1 -L 1 pip install from autosklearn.classification import AutoSklearnClassifier # Buat model sklearn = AutoSklearnClassifier(time_left_for_this_task=3*60, per_run_time_limit=15, n_jobs=-1) # Sesuaikan data pelatihan sklearn.fit(X_train, y_train ) # Sprint Statistics print(sklearn.sprint_statistics()) # Memprediksi data validasi pred_sklearn = sklearn.predict(X_val) # Hitung akurasi print('Accuracy: ' + str(accuracy_score(y_val, pred_sklearn)))

Keluaran:

hasil auto-sklearn: Nama dataset: 576d4f50-c85b-11eb-802c-0242ac130202 Metrik: akurasi Skor validasi terbaik: 0.917922 Jumlah algoritme target berjalan: 40 Jumlah algoritme target yang berhasil dijalankan: 8 Jumlah algoritme target crash yang dijalankan: 0 Jumlah algoritme target yang berhasil dijalankan: 28 algoritma target yang melebihi batas waktu: 4 Jumlah algoritma target yang melebihi batas memori: 0.923600209314495 Akurasi: XNUMX

Hasil:

# Hasil prediksi print('Confusion Matrix') print(pd.DataFrame(confusion_matrix(y_val, pred_sklearn), index=[1,2,3,4], column=[1,2,3,4])) print( '') print('Laporan Klasifikasi') print(laporan_klasifikasi(y_val, pred_sklearn))

Keluaran:

Matriks Kebingungan 1 2 3 4 1 123 14 3 11 2 17 273 11 18 3 3 17 195 27 4 5 15 5 1174 Klasifikasi Pemanggilan presisi laporan dukungan skor-f 1 1 0.83 0.81 0.82 151 2 0.86 0.86 0.86 319 3 0.91 0.81 0.86 242 4 akurasi 0.95 0.98 rata-rata makro 0.97 1199 0.92 1911 rata-rata tertimbang 0.89 0.86 0.88 1911

Alat Pengoptimalan Jalur Pipa Berbasis Pohon (TPOT)

TPOT dibangun di atas scikit-learn. TPOT menggunakan algoritma genetika untuk mencari model terbaik menurut “generasi” dan “ukuran populasi”. Semakin tinggi dua parameter yang ditetapkan, semakin lama waktu yang dibutuhkan. Tidak seperti AutoSklearn, kami tidak menetapkan waktu berjalan khusus untuk TPOT. Seperti namanya, setelah TPOT dijalankan, ia mengekspor baris kode yang berisi pipa dari mengimpor paket, memisahkan kumpulan data, membuat model yang disetel, menyesuaikan model, dan akhirnya memprediksi kumpulan data validasi. Pipa diekspor dalam format .py.

Pada kode di bawah ini, saya mengatur generasi dan population_size menjadi 5. Outputnya memberikan 5 generasi dengan "skor" yang meningkat. Saya menetapkan skor menjadi "neg_mean_absolute_error" dan "akurasi" masing-masing untuk tugas regresi dan klasifikasi. Neg_mean_absolute_error berarti Mean Absolute Error (MAE) dalam bentuk negatif. Algoritma memilih nilai skor tertinggi. Membuat MAE negatif akan membuat algoritma memilih MAE yang paling dekat dengan nol.

Regresi

dari tpot import TPOTRegressor # Buat model cv = RepeatedStratifiedKFold(n_splits=3, n_repeats=3, random_state=123) tpot = TPOTRegressor(generations=5, population_size=5, cv=cv, scoring='neg_mean_absolute_error', verbosity=2, random_state =123, n_jobs=-1) # Sesuaikan data pelatihan tpot.fit(X_train, y_train) # Ekspor hasilnya tpot.export('tpot_model.py')

Keluaran:

Generasi 1 - Skor CV internal terbaik saat ini: -20390.588131563232 Generasi 2 - Skor CV internal terbaik saat ini: -19654.82630417806 Generasi 3 - Skor CV internal terbaik saat ini: -19312.09139004322 Generasi 4 - Skor CV internal terbaik saat ini: -19312.09139004322 Generasi 5 - Internal terbaik saat ini Skor CV: -18752.921100941825 Pipa terbaik: RandomForestRegressor(input_matrix, bootstrap=True, max_features=0.25, min_samples_leaf=3, min_samples_split=2, n_estimators=100)

Klasifikasi

from tpot import TPOTClassifier # TPOT yang dihentikan tadi. Itu masih memberikan saluran pipa terbaik sementara.
# Buat modelnya
cv = RepeatedStratifiedKFold(n_splits=3, n_repeats=3, random_state=123) tpot = TPOTClassifier(generations=5, population_size=5, cv=cv, scoring='accuracy', verbosity=2, random_state=123, n_jobs=-1 )
# Sesuaikan data pelatihan
tpot.fit(X_train, y_train)
# Ekspor hasilnya
tpot.export('tpot_model.py')

Keluaran:

Generasi 1 - Skor CV internal terbaik saat ini: 0.7432273262661955 Generasi 2 - Skor CV internal terbaik saat ini: 0.843824979278454 Generasi 3 - Skor CV internal terbaik saat ini: 0.8545565589146273 Generasi 4 - Skor CV internal terbaik saat ini: 0.8545565589146273 Generasi 5 - Skor CV internal terbaik saat ini: 0.859616978580465 Generasi 0.001 - Skor CV internal terbaik saat ini: 2 Pipa Terbaik: RandomForestClassifier (gradientBoostingClassifier (input_matrix, learning_rate = 0.7000000000000001, max_depth = 1, max_features = 19, MIN_SAMPLES_LEAF = 100, Min_0.15000000000000002 min_samples_leaf=0.8500000000000001, min_samples_split=4, n_estimator=12)

AutoSklearn memberikan hasil RandomForestRegressor untuk tugas regresi. Adapun klasifikasinya, memberikan susunan GradientBoostingClassifier dan RandomForestClassifier. Semua algoritme sudah menyetel hyperparameternya.

Berikut ini untuk melihat metrik penilaian data validasi.

Regresi

pred_tpot = hasil # Sebarkan plot nilai benar dan prediksi plt.scatter(pred_tpot, y_val, alpha=0.2) plt.xlabel('predicted') plt.ylabel('true value') plt.text(100000, 400000, 'RMSE: ' + str(round(MSE(y_val, pred_tpot)**0.5))) plt.text(100000, 350000, 'MAE: ' + str(round(mean_absolute_error(y_val, pred_tpot)))) plt.text(100000, 300000, 'R: ' + str(round(np.corrcoef(y_val, pred_tpot)[0,1],4))) plt.show()

Keluaran:

Gambar 2 hasil regresi TPOT.

Klasifikasi

pred_tpot = hasil # Hitung akurasi print('Akurasi: ' + str(skor_akurasi(y_val, pred_tpot))) print('') # Hasil prediksi print('Confusion Matrix') print(pd.DataFrame(confusion_matrix(y_val, pred_tpot ), indeks=[1,2,3,4], kolom=[1,2,3,4])) print('') print('Laporan Klasifikasi') print(laporan_klasifikasi(y_val, pred_tpot))

Keluaran:

Akurasi: 0.9246467817896389 Matriks Kebingungan 1 2 3 4 1 117 11 7 16 2 6 288 10 15 3 2 18 186 36 4 5 12 6 Laporan Klasifikasi Penarikan Presisi F1176 Dukungan 1 1 0.90 0.77 0.83 151 2 0.88 0.90 0.89 319 3 0.89 0.77 0.82 242 4 0.95 0.98 0.96 1199 0.92. 1911 0.90 0.86 0.88 1911 0.92 0.92 akurasi 0.92 1911 rata-rata makro XNUMX XNUMX XNUMX XNUMX rata-rata tertimbang XNUMX XNUMX XNUMX XNUMX

Optimasi Hyper-parameter Asinkron Terdistribusi (Hyperopt)

Hyperopt juga biasanya digunakan untuk mengoptimalkan hyperparameter dari salah satu model yang telah ditentukan. Misalnya, kami memutuskan untuk menerapkan Hutan Acak dan kemudian menjalankan hyperopt untuk menemukan hyperparameter optimal untuk Hutan Acak. saya sebelumnya pos membahasnya. Namun, postingan ini berbeda karena menggunakan hyperopt untuk mencari model Machine Learning terbaik secara otomatis, bukan hanya menyetel hyperparameter. Kodenya mirip tapi beda.

Kode di bawah ini menunjukkan cara menggunakan hyperopt untuk menjalankan AutoML. Evaluasi maksimum 50 dan batas waktu uji coba 20 detik ditetapkan. Ini akan menentukan berapa lama AutoML akan bekerja. Seperti di TPOT, kami tidak menetapkan batas waktu di hyperopt.

Regresi

!pip instal git+https://github.com/hyperopt/hyperopt-sklearn.git dari hpsklearn impor HyperoptEstimator dari hpsklearn impor any_regressor dari hpsklearn impor any_preprocessing dari hyperopt impor tpe dari sklearn.metrics impor mean_squared_error # Buat modelnya hyperopt = HyperoptEstimator( regressor=any_regressor('reg'), preprocessing=any_preprocessing('pre'), loss_fn=mean_squared_error, algo=tpe.suggest, max_evals=50, trial_timeout=20) # Pas dengan data hyperopt.fit(X_train, y_train)

Klasifikasi

!pip instal git+https://github.com/hyperopt/hyperopt-sklearn.git dari hpsklearn impor HyperoptEstimator dari hpsklearn impor any_classifier dari hpsklearn impor any_preprocessing dari hyperopt impor tpe # Buat model hyperopt = HyperoptEstimator(classifier=any_classifier('cla '), preprocessing=any_preprocessing('pre'), algo=tpe.suggest, max_evals=50, trial_timeout=30) # Pas dengan data pelatihan hyperopt.fit(X_train_ar, y_train_ar)

Di notebook Kaggle (pada tabel di atas), setiap kali saya selesai melakukan fitting dan prediksi, saya akan menunjukkan prediksi hasil validasi data dalam scatter plot, Confusion Matrix, dan laporan klasifikasi. Kodenya selalu hampir sama dengan sedikit penyesuaian. Jadi, mulai saat ini dan seterusnya, saya tidak akan memasukkannya ke dalam postingan ini. Tapi, notebook Kaggle menyediakannya.

Untuk melihat algoritma dari hasil pencarian AutoML. Gunakan kode di bawah ini. Hasilnya adalah ExtraTreeClassfier dan XGBRegressor. Perhatikan bahwa itu juga mencari teknik preprocessing, seperti standard scaler dan normalizer.

# Tampilkan model cetak(hyperopt.best_model())

Regresi

{'pelajar': XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=0.6209369845565308, colsample_bynode=1, colsample_bytree=0.6350745975782562, gamma=0.07330922089021298, gpu_id='gaintrate=', tingkat_kepentingan, interaksi,' =1, max_delta_step=0.0040826994703554555, max_depth=0, min_child_weight=10, hilang=nan, monotone_constraints='()', n_estimators=1, n_jobs=2600, num_parallel_tree=1, objektif='reg:linear', status_acak=1, reg_alpha=3, reg_lambda=0.4669165283261672, scale_pos_weight=2.2280355282357056, seed=1, subsample=3, tree_method='exact', validasi_parameters=0.7295609371405459, verbositas=Tidak ada), 'preprocs': (Normalizer()(norm='l1'),) , 'ex_preprocs': ()}

Klasifikasi

{'pelajar': ExtraTreesClassifier(bootstrap=True, max_features='sqrt', n_estimators=308, n_jobs=1, random_state=1, verbose=False), 'preprocs': (StandardScaler(with_std=False),), 'ex_preprocs ': ()}

AutoKeras

AutoKeras, seperti yang Anda duga, adalah autoML yang berspesialisasi dalam Deep Learning atau jaringan Neural. "Keras" pada namanya memberi petunjuk. AutoKeras membantu dalam menemukan arsitektur dan hyperparameter jaringan saraf terbaik untuk model prediksi. Berbeda dengan AutoML lainnya, AutoKeras tidak mempertimbangkan algoritma berbasis pohon, berbasis jarak, atau lainnya.

Deep Learning menantang tidak hanya untuk penyetelan hyperparameter tetapi juga untuk pengaturan arsitektur. Banyak yang bertanya tentang berapa banyak neuron atau lapisan yang terbaik untuk digunakan. Tidak ada jawaban yang jelas untuk itu. Secara konvensional, pengguna harus mencoba menjalankan dan mengevaluasi arsitektur Deep Learning mereka satu per satu sebelum akhirnya memutuskan mana yang terbaik. Butuh waktu lama dan sumber daya untuk menyelesaikannya. Saya menulis posting yang menjelaskan hal ini di sini. Namun, AutoKeras dapat mengatasi masalah ini.

Untuk menerapkan AutoKeras, saya menetapkan max_trials menjadi 8 dan akan mencoba menemukan arsitektur pembelajaran mendalam terbaik untuk maksimal 8 percobaan. Tetapkan epoch saat menyesuaikan dataset pelatihan dan ini akan menentukan keakuratan model.

Regresi

!pip install autokeras import autokeras # Buat model keras = autokeras.StructuredDataRegressor(max_trials=8) # Sesuaikan dataset pelatihan dengan keras.fit(X_train, y_train, epochs=100) # Prediksi data validasi pred_keras = keras.predict(X_val)

Klasifikasi

!pip install autokeras import autokeras # Buat model keras = autokeras.StructuredDataClassifier(max_trials=8) # Sesuaikan dataset training keras.fit(X_train, y_train, epochs=100) # Prediksi data validasi pred_keras = keras.predict(X_val) # Hitung akurasi print('Accuracy: ' + str(accuracy_score(y_val, pred_keras)))

Untuk mengetahui arsitektur pencarian AutoKeras, gunakan kode berikut.

# Tampilkan model yang dibangun keras_export = keras.export_model() keras_export.summary()

Regresi

Model: "model" _________________________________________________________________ Lapisan (jenis) Param Bentuk Keluaran # ==================================== ============================= input_1 (InputLayer) [(Tidak ada, 20)] 0 _________________________________________________________________ multi_category_encoding (Mul (Tidak ada, 20) 0 _________________________________________________________________ padat (Padat) (Tidak ada, 512) 10752 _________________________________________________________________ re_lu (ReLU) (Tidak ada, 512) 0 _________________________________________________________________ padat_1 (Padat) (Tidak ada, 32) 16416 _________________________________________________________________ re_lu_1 (ReLU) (Tidak ada, 32) 0 _________________________________________________________________ kepala_regresi_1 (Padat) (Tidak ada, 1) 33 ============================================ ===================== Total parameter: 27,201 Parameter yang dapat dilatih: 27,201 Parameter yang tidak dapat dilatih: 0 ________________________________________________________________ _______________

Klasifikasi

Model: "model" _________________________________________________________________ Layer (type) Output Shape Param # ==================================== ============================= input_1 (InputLayer) [(Tidak ada, 71)] 0 _________________________________________________________________ multi_category_encoding (Mul (Tidak ada, 71) 0 _________________________________________________________________ normalisasi (Normalisasi (Tidak ada, 71) 143 _________________________________________________________________ padat (Padat) (Tidak ada, 512) 36864 _________________________________________________________________ re_lu (ReLU) (Tidak ada, 512) 0 _________________________________________________________________ padat_1 (Padat) (Tidak ada, 32) 16416 _________________________________________________________________ re_lu_1 (ReLU) ( Tidak ada, 32) 0 _________________________________________________________________ putus sekolah (Putus sekolah) (Tidak ada, 32) 0 _________________________________________________________________ padat_2 (Padat) (N satu, 4) 132 _________________________________________________________________ klasifikasi_head_1 (Softm (Tidak ada, 4) 0 =================================== ============================== Total parameter: 53,555 Parameter yang dapat dilatih: 53,412 Parameter yang tidak dapat dilatih: 143 _________________________________________________________________

 MLJAR

MLJAR adalah AutoML hebat lainnya. Dan, Anda akan menemukan alasannya segera. Untuk menjalankan MLJAR, saya menetapkan argumen mode, eval_metric, total_time_limit, dan feature_selection. AutoML ini akan memahami apakah ini tugas regresi atau klasifikasi dari eval_metric. Total_time_limit adalah durasi berapa lama kami mengizinkan MLJAR berjalan dalam hitungan detik. Dalam hal ini, dibutuhkan 300 detik atau 5 menit untuk menemukan model terbaik yang mungkin. Kami juga dapat menentukan apakah akan mengizinkan pemilihan fitur. Output kemudian akan melaporkan algoritma yang digunakan dan berapa lama waktu yang dibutuhkan untuk menyelesaikannya.

Regresi

!pip instal -q -U git+https://github.com/mljar/[email dilindungi]
from supervised.automl import AutoML # Buat model mljar = AutoML(mode="Compete", eval_metric="rmse", total_time_limit=300, features_selection=True) # Sesuaikan data pelatihan mljar.fit(X_train, y_train) # Prediksikan data pelatihan mljar_pred = mljar.predict(X_val)

Klasifikasi

!pip instal -q -U git+https://github.com/mljar/[email dilindungi] from supervised.automl import AutoML # Buat model mljar = AutoML(mode="Compete", eval_metric="accuracy", total_time_limit=300, features_selection=True) # Sesuaikan data pelatihan mljar.fit(X_train, y_train) # Prediksikan data pelatihan mljar_pred = mljar.predict(X_val)

Argumen "mode" memungkinkan kita memutuskan untuk apa MLJAR diharapkan. Ada 4 jenis mode untuk menentukan tujuan menjalankan MLJAR. Pada contoh kode di atas, mode “compete” digunakan untuk memenangkan sebuah kompetisi dengan mencari model terbaik dengan metode tuning dan ensembling. Mode “optuna” digunakan untuk menemukan model yang paling sesuai dengan waktu komputasi yang tidak terbatas. Mode "performa" membangun pipeline Machine Learning untuk produksi. Mode “jelaskan” digunakan untuk penjelasan data.

Hasil MLJAR dilaporkan dan divisualisasikan secara otomatis. Sayangnya, Kaggle tidak menampilkan hasil laporan setelah disimpan. Jadi, di bawah ini adalah tampilannya. Laporan tersebut membandingkan hasil MLJAR untuk setiap algoritme. Kita dapat melihat metode ansambel memiliki MSE terendah untuk tugas regresi dan akurasi tertinggi untuk tugas klasifikasi. Peningkatan jumlah iterasi menurunkan MSE untuk tugas regresi dan meningkatkan akurasi tugas klasifikasi. (Tabel papan peringkat di bawah sebenarnya memiliki lebih banyak baris, tetapi telah dipotong.)

Regresi

Gambar 3 Laporan MLJAR untuk regresi

Gambar 4 MLJAR untuk regresi

 Perekat Otomatis

AutoGluon mengharuskan pengguna untuk memformat dataset pelatihan menggunakan TabularDataset untuk mengenalinya. Pengguna kemudian dapat menentukan alokasi time_limit agar AutoGluon berfungsi. Pada contoh kode di bawah ini, saya menyetelnya menjadi 120 detik atau 2 menit.

Regresi

!pip install -U pip !pip install -U setuptools wheel !pip install -U "mxnet<2.0.0" !pip install autogluon dari autogluon.tabular import TabularDataset, TabularPredictor # Siapkan data Xy_train = X_train.reset_index(drop=True ) Xy_train['Target'] = y_train Xy_val = X_val.reset_index(drop=True) Xy_val['Target'] = y_val X_train_gluon = TabularDataset(Xy_train) X_val_gluon = TabularDataset(Xy_val) # Sesuaikan data pelatihan gluon = TabularPredictor(label= 'Target').fit(X_train_gluon, time_limit=120) # Memprediksi data pelatihan gluon_pred = gluon.predict(X_val)

Klasifikasi

!pip install -U pip !pip install -U setuptools wheel !pip install -U "mxnet<2.0.0" !pip install autogluon dari autogluon.tabular import TabularDataset, TabularPredictor # Siapkan data Xy_train = X_train.reset_index(drop=True ) Xy_train['Target'] = y_train Xy_val = X_val.reset_index(drop=True) Xy_val['Target'] = y_val X_train_gluon = TabularDataset(Xy_train) X_val_gluon = TabularDataset(Xy_val) # Sesuaikan data pelatihan gluon = TabularPredictor(label= 'Target').fit(X_train_gluon, time_limit=120) # Memprediksi data pelatihan gluon_pred = gluon.predict(X_val)

Setelah menyelesaikan tugasnya, AutoGluon dapat melaporkan keakuratan setiap algoritma Machine Learning yang dicobanya. Laporan itu disebut papan peringkat. Kolom di bawah sebenarnya lebih panjang, tapi saya potong untuk postingan ini.

# Tampilkan papan peringkat model = gluon.papan peringkat(X_train_gluon) papan peringkat

Regresi

	model	skor_tes	skor_val	pred_time_test	. . .
0	MSE Hutan Acak	-15385.131260	-23892.159881	0.133275	. . .
1	ExtraTreesMSE	-15537.139720	-24981.601931	0.137063	. . .
2	RinganGBMLarge	-17049.125557	-26269.841824	0.026560	. . .
3	XGBoost	-18142.996982	-23573.451829	0.054067	. . .
4	KTetanggaDist	-18418.785860	-41132.826848	0.135036	. . .
5	KucingMeningkatkan	-19585.309377	-23910.403833	0.004854	. . .
6	Ensemble Tertimbang_L2	-20846.144676	-22060.013365	1.169406	. . .
7	CahayaGBM	-23615.121228	-23205.065207	0.024396	. . .
8	GBMXT ringan	-25261.893395	-24608.580984	0.015091	. . .
9	NeuralNetMXNet	-28904.712029	-24104.217749	0.819149	. . .
10	KNeighboursUnif	-39243.784302	-39545.869493	0.132839	. . .
11	NeuralNetFastAI	-197411.475391	-191261.448480	0.070965	. . .

Klasifikasi

	model	skor_tes	skor_val	pred_time_test	. . .
0	Ensemble Tertimbang_L2	0.986651	0.963399	3.470253	. . .
1	CahayaGBM	0.985997	0.958170	0.600316	. . .
2	XGBoost	0.985997	0.956863	0.920570	. . .
3	Entri Hutan Acak	0.985866	0.954248	0.366476	. . .
4	RandomForestGini	0.985735	0.952941	0.397669	. . .
5	ExtraTreesEntr	0.985735	0.952941	0.398659	. . .
6	ExtraTreesGini	0.985735	0.952941	0.408386	. . .
7	KTetanggaDist	0.985473	0.950327	2.013774	. . .
8	GBMXT ringan	0.984034	0.951634	0.683871	. . .
9	NeuralNetFastAI	0.983379	0.947712	0.340936	. . .
10	NeuralNetMXNet	0.982332	0.956863	2.459954	. . .
11	KucingMeningkatkan	0.976574	0.934641	0.044412	. . .
12	KNeighboursUnif	0.881560	0.769935	1.970972	. . .
13	RinganGBMLarge	0.627143	0.627451	0.014708	. . .

H2O

Mirip dengan AutoGluon, H2O membutuhkan dataset pelatihan dalam format tertentu, yang disebut H2OFrame. Untuk memutuskan berapa lama H2O akan bekerja, max_runtime_secs atau max_models harus ditentukan. Nama-nama menjelaskan apa artinya.

Regresi

import h2o from h2o.automl import H2OAutoML h2o.init() # Siapkan data Xy_train = X_train.reset_index(drop=True) Xy_train['SalePrice'] = y_train.reset_index(drop=True) Xy_val = X_val.reset_index(drop= Benar) Xy_val['SalePrice'] = y_val.reset_index(drop=True) # Konversi H2O Frame Xy_train_h2o = h2o.H2OFrame(Xy_train) X_val_h2o = h2o.H2OFrame(X_val) # Buat model h2o_model = H2OAutoML(max_runtime_secs=120, seed =123) # Cocok dengan model h2o_model.train(x=Xy_train_h2o.columns, y='SalePrice', training_frame=Xy_train_h2o) # Memprediksi data pelatihan h2o_pred = h2o_model.predict(X_val_h2o)

Klasifikasi

impor h2o dari h2o.automl impor H2OAutoML h2o.init() # Konversi Bingkai H2O Xy_train_h2o = h2o.H2OFrame(Xy_train) X_val_h2o = h2o.H2OFrame(X_val) Xy_train_h2o['Target'] = Xy_train_h2o['Target'].asfactor() # Membuat model h2o_model = H2OAutoML(max_runtime_secs=120, seed=123) # Sesuaikan model h2o_model.train(x=Xy_train_h2o.columns, y='Target', training_frame=Xy_train_h2o) # Memprediksi data pelatihan h2o_pred = h2o_model.predict (X_val_h2o) h2o_pred

Untuk tugas klasifikasi, hasil prediksi adalah hasil klasifikasi multilabel. Ini memberikan nilai probabilitas untuk setiap kelas. Di bawah ini adalah contoh klasifikasinya.

meramalkan	p1	p2	p3	p4
4	0.0078267	0.0217498	0.0175197	0.952904
4	0.00190617	0.00130162	0.00116375	0.995628
4	0.00548938	0.0156449	0.00867845	0.970187
3	0.00484961	0.0161661	0.970052	0.00893224
2	0.0283297	0.837641	0.0575789	0.0764503
3	0.00141621	0.0022694	0.992301	0.00401299
4	0.00805432	0.0300103	0.0551097	0.906826

H2O melaporkan hasilnya dengan tabel sederhana yang menunjukkan berbagai metrik penilaian dari setiap algoritme Pembelajaran Mesin.

# Tampilkan hasil model leaderboard_h2o = h2o.automl.get_leaderboard(h2o_model, extra_columns = 'ALL') leaderboard_h2o

Keluaran regresi:

model_id	mean_residual_deviance	rmse	mse	mae	rmsle	...
GBM_grid__1_AutoML_20210811_022746_model_17	8.34855e + 08	28893.9	8.34855e + 08	18395.4	0.154829	...
GBM_1_AutoML_20210811_022746	8.44991e + 08	29068.7	8.44991e + 08	17954.1	0.149824	...
StackedEnsemble_BestOfFamily_AutoML_20210811_022746	8.53226e + 08	29210	8.53226e + 08	18046.8	0.149974	...
GBM_grid__1_AutoML_20210811_022746_model_1	8.58066e + 08	29292.8	8.58066e + 08	17961.7	0.153238	...
GBM_grid__1_AutoML_20210811_022746_model_2	8.91964e + 08	29865.8	8.91964e + 08	17871.9	0.1504	...
GBM_grid__1_AutoML_20210811_022746_model_10	9.11731e + 08	30194.9	9.11731e + 08	18342.2	0.153421	...
GBM_grid__1_AutoML_20210811_022746_model_21	9.21185e + 08	30351	9.21185e + 08	18493.5	0.15413	...
GBM_grid__1_AutoML_20210811_022746_model_8	9.22497e + 08	30372.6	9.22497e + 08	19124	0.159135	...
GBM_grid__1_AutoML_20210811_022746_model_23	9.22655e + 08	30375.2	9.22655e + 08	17876.6	0.150722	...
XGBoost_3_AutoML_20210811_022746	9.31315e + 08	30517.5	9.31315e + 08	19171.1	0.157819	...

Klasifikasi

model_id	mean_per_class_error	logloss	rmse	mse	...
StackedEnsemble_BestOfFamily_AutoML_20210608_143533	0.187252	0.330471	0.309248	0.0956343	...
StackedEnsemble_AllModels_AutoML_20210608_143533	0.187268	0.331742	0.309836	0.0959986	...
DRF_1_AutoML_20210608_143533	0.214386	4.05288	0.376788	0.141969	...
GBM_grid__1_AutoML_20210608_143533_model_1	0.266931	0.528616	0.415268	0.172447	...
XGBoost_grid__1_AutoML_20210608_143533_model_1	0.323726	0.511452	0.409528	0.167713	...
GBM_4_AutoML_20210608_143533	0.368778	1.05257	0.645823	0.417088	...
GBM_grid__1_AutoML_20210608_143533_model_2	0.434227	1.10232	0.663382	0.440075	...
GBM_3_AutoML_20210608_143533	0.461059	1.08184	0.655701	0.429944	...
GBM_2_AutoML_20210608_143533	0.481588	1.08175	0.654895	0.428887	...
XGBoost_1_AutoML_20210608_143533	0.487381	1.05534	0.645005	0.416031	...

PyCaret

Ini adalah kode AutoML terpanjang yang dijelajahi oleh pos ini. PyCaret tidak perlu memisahkan fitur (X_train) dan label (y_train). Jadi, kode di bawah ini hanya akan membagi dataset pelatihan secara acak menjadi dataset pelatihan lain dan dataset validasi. Preprocessing, seperti mengisi data yang hilang atau pemilihan fitur, juga tidak diperlukan. Kemudian, kami menyiapkan PyCaret dengan menetapkan data, variabel atau label target, metode imputasi numerik, metode imputasi kategorikal, apakah akan menggunakan normalisasi, apakah akan menghapus multikolinearitas, dan sebagainya

Regresi

!pip install pycaret from pycaret.regression import * # Hasilkan angka acak val_index = np.random.choice(range(trainSet.shape[0]), round(trainSet.shape[0]*0.2), replace=False) # Split trainSet trainSet1 = trainSet.drop(val_index) trainSet2 = trainSet.iloc[val_index,:] # Buat model caret = setup(data = trainSet1, target='SalePrice', session_id=111, numeric_imputasi='mean', categorical_imputasi=' konstan', normalisasi = True, combine_rare_levels = True, rare_level_threshold = 0.05, remove_multicollinearity = True, multicollinearity_threshold = 0.95)

Klasifikasi

!pip install pycaret from pycaret.classification import * # Hasilkan angka acak val_index = np.random.choice(range(trainSet.shape[0]), round(trainSet.shape[0]*0.2), replace=False) # Split trainSet trainSet1 = trainSet.drop(val_index) trainSet2 = trainSet.iloc[val_index,:] # Buat model caret = setup(data = trainSet1, target='Target', session_id=123, numeric_imputasi='mean', categorical_imputasi=' konstan', normalisasi = True, combine_rare_levels = True, rare_level_threshold = 0.05, remove_multicollinearity = True, multicollinearity_threshold = 0.95)

Setelah itu, kita dapat menjalankan PyCaret dengan menentukan berapa banyak lipatan validasi silang yang kita inginkan. PyCaret untuk regresi memberikan beberapa model yang diurutkan dari metrik penilaian terbaik. Model teratas adalah Bayesian Ridge, Huber Regressor, Orthogonal Matching Pursuit, Ridge Regression, dan Passive-Aggressive Regressor. Metrik penilaian adalah MAE, MSE, RMSE, R2, RMSLE, dan MAPE. PyCaret untuk klasifikasi juga memberikan beberapa model. Model teratas adalah Extra Trees Classifier, Random Forest Classifier, Decision Tree Classifier, Extreme Gradient Boosting, dan Light Gradient Boosting Machine. Tabel di bawah ini dibatasi untuk baris dan kolomnya. Temukan tabel lengkapnya di buku catatan Kaggle.

# Tampilkan model caret_models = bandingkan_models(fold=5)

Regresi

	Model	MFA	MSE	RMSE	R2	...
br	Punggung Bukit Bayesian	15940.2956	566705805.8954	23655.0027	0.9059	...
Huber	Regresor Huber	15204.0960	588342119.6640	23988.3772	0.9033	...
ya Tuhan	Pengejaran Pencocokan Ortogonal	16603.0485	599383228.9339	24383.2437	0.9001	...
bubungan	Regresi Punggung	16743.4660	605693331.2000	24543.6840	0.8984	...
bahkan	Regresi Agresif Pasif	15629.1539	630122079.3113	24684.8617	0.8972	...
...	...	...	...	...	...	...

Klasifikasi

	Model	Ketepatan	AUC	Mengingat kembali	Sebelum	...
et	Pengklasifikasi Pohon Ekstra	0.8944	0.9708	0.7912	0.8972	...
rf	Pengklasifikasi Hutan Acak	0.8634	0.9599	0.7271	0.8709	...
dt	Pengklasifikasi Pohon Keputusan	0.8436	0.8689	0.7724	0.8448	...
xgboost	Peningkatan Gradien Ekstrim	0.8417	0.9455	0.7098	0.8368	...
lightgbm	Mesin Peningkat Gradien Ringan	0.8337	0.9433	0.6929	0.8294	...
...	...	...	...	...	...	...

Untuk membuat 5 model teratas, jalankan kode berikut.

Regresi

# Buat 5 model teratas br = create_model('br', fold=5) huber = create_model('huber', fold=5) omp = create_model('omp', fold=5) ridge = create_model('ridge', lipat=5) par = buat_model('par', lipat=5)

Klasifikasi

# Buat 5 model teratas et = create_model('et', fold=5) rf = create_model('rf', fold=5) dt = create_model('dt', fold=5) xgboost = create_model('xgboost', fold=5) lightgbm = create_model('lightgbm', fold=5)

Untuk menyetel model yang dipilih, jalankan kode berikut.

Regresi

# Sesuaikan model, BR: Regresi br_tune = tune_model(br, fold=5) # Tampilkan hyperparameter yang disetel, misalnya untuk BR: Regresi plot_model(br_tune, plot='parameter')

Klasifikasi

# Sesuaikan model, LightGBM: Klasifikasi lightgbm_tune = tune_model(lightgbm, fold=5) # Tampilkan hyperparameter yang disetel, misalnya untuk LightGBM: Klasifikasi plot_model(lightgbm_tune, plot='parameter')

PyCaret memungkinkan pengguna secara manual melakukan metode ensemble, seperti Bagging, Boosting, Stacking, atau Blending. Kode di bawah ini melakukan setiap metode ansambel.

Regresi

# Bagging BR br_bagging = ensemble_model(br_tune, fold=5) # Boosting BR br_boost = ensemble_model(br_tune, method='Boosting', fold=5) # Stacking dengan Huber sebagai meta-model stack = stack_models(caret_models_5, meta_model=huber , fold=5) # Memadukan model top caret_blend = blend_models(estimator_list=[br_tune,huber_tune,omp_tune,ridge_tune,par_tune])

Klasifikasi

# Mengantongi LightGBM lightgbm_bagging = ensemble_model(lightgbm_tune, fold=5) # Meningkatkan LightGBM lightgbm_boost = ensemble_model(lightgbm_tune, method='Boosting', fold=5) # Stacking dengan ET sebagai meta-model stack = stack_models(caret_models_5, meta_model=et , fold=5) # Memadukan model top caret_blend = blend_models(estimator_list=[lightgbm_tune,rf,dt])

Sekarang, mari kita pilih model campuran sebagai model prediktif. Kode berikut menggunakan model pencampuran untuk memprediksi dataset validasi.

Regresi

# Memprediksi data validasi caret_pred = predict_model(caret_blend, data = trainSet2.drop(columns=['SalePrice']))

Klasifikasi

# Memprediksi data validasi pred_caret = predict_model(caret_blend, data = trainSet2.drop(columns=['Target']))

AutoViML

Saya menjalankan AutoViML di notebook dengan menetapkan banyak argumen. Sama seperti PyCaret, AutoViML tidak perlu memisahkan fitur (X_train) dan label (y_train). Pengguna hanya perlu memisahkan dataset pelatihan (sebagai trainSet1) dan dataset validasi (sebagai trainSet2). Pengguna dapat menentukan parameter lain, seperti parameter scoring, hyperparameter, pengurangan fitur, boosting, binning, dan sebagainya.

Regresi

!pip install autoviml !pip install shap from autoviml.Auto_ViML import Auto_ViML # Buat model viml, fitur, train_v, test_v = Auto_ViML(trainSet1, 'SalePrice', trainSet2.drop(columns=['SalePrice']), scoring_parameter=' ', hyper_param='RS', feature_reduction=Benar, Boosting_Flag=Benar, Binning_Flag=Salah,Add_Poly=0, Stacking_Flag=Salah, Imbalanced_Flag=Benar, verbose=1)

Klasifikasi

!pip install autoviml !pip install shap from autoviml.Auto_ViML import Auto_ViML # Buat model viml, fitur, train_v, test_v = Auto_ViML(trainSet1, 'Target', trainSet2.drop(columns=['Target']), scoring_parameter=' balanced_accuracy', hyper_param='RS', feature_reduction=Benar, Boosting_Flag=Benar, Binning_Flag=Salah,Add_Poly=0, Stacking_Flag=Salah, Imbalanced_Flag=Benar, verbose=1)

Setelah menyesuaikan data pelatihan, kita dapat memeriksa apa yang telah dilakukan dari keluaran. Sebagai contoh, kita dapat melihat bahwa AutoViML sedang melakukan preprocessing dengan mengisi data yang hilang. Mirip dengan MLJAR, AutoViML juga memberikan laporan yang divisualisasikan. Untuk tugas regresi, ini memvisualisasikan sebar plot dari nilai yang benar dan yang diprediksi menggunakan model XGBoost. Itu juga memplot kesalahan sisa prediksi dalam histogram. Dari kedua plot tersebut terlihat bahwa model memiliki akurasi yang relatif baik dan residual error berdistribusi normal.

Laporan selanjutnya adalah uji coba metode ensemble. Kami dapat menemukan laporan ini untuk tugas regresi dan klasifikasi. Grafik terakhir menampilkan kepentingan fitur. Kita dapat melihat bahwa fitur terpenting untuk memprediksi harga rumah adalah kualitas material eksterior, diikuti dengan kualitas material dan finishing secara keseluruhan, dan ukuran garasi masing-masing.

Adapun tugas klasifikasi tidak memvisualisasikan scatter plot, tetapi kurva ROC untuk masing-masing dari empat kelas prediksi, rata-rata mikro, dan rata-rata makro serta nilai AUC. Terlihat bahwa semua kelas memiliki nilai AUC di atas 0.98. Bagan berikutnya melaporkan kurva iso-f1 sebagai metrik akurasi. Ini juga kemudian memberikan laporan klasifikasi.

Skor presisi rata-rata, rata-rata mikro untuk semua kelas: 0.97 Skor Makro F1, rata-rata untuk semua kelas: 0.83

################################################## ### precision recall f1-score support 0 0.84 0.97 0.90 963 1 0.51 0.59 0.54 258 2 0.18 0.11 0.14 191 3 0.00 0.00 0.00 118 accuracy 0.73 1530 macro avg 0.38 0.42 0.40 1530 weighted avg 0.64 0.73 0.68 1530 [[938 19 6 0 ] [106 151 1 0] [ 53 117 21 0] [ 16 12 90 0]]

Kode berikut mencetak hasil pencarian AutoViML. Kita dapat melihat bahwa model terbaik adalah XGBRegressor dan XGBClassifier untuk setiap tugas.

viml

Regresi

XGBRegressor(base_score=0.5, booster='gbtree', colsample_bylevel=1, colsample_bynode=1, colsample_bytree=0.7, gamma=1, gpu_id=0, grow_policy='depthwise', important_type='gain', interaction_constraints='', learning_rate =0.1, max_delta_step=0, max_depth=8, max_leaves=0, min_child_weight=1, hilang=nan, monotone_constraints='()', n_estimators=100, n_jobs=-1, nthread=-1, num_parallel_tree=1, objektif= 'reg: squarederror', predictor='cpu_predictor', random_state=1, reg_alpha=0.5, reg_lambda=0.5, scale_pos_weight=1, seed=1, subsample=0.7, tree_method='hist', ...)

Klasifikasi

CalibratedClassifierCV(base_estimator=OneVsRestClassifier(estimator=XGBClassifier(base_score=Tidak ada, booster='gbtree', colsample_bylevel=Tidak ada, colsample_bynode=Tidak ada, colsample_bytree=Tidak ada, gamma=Tidak ada, gpu_id=Tidak ada, important_type='gain', interaction_constraints=Tidak ada, learning_rate=Tidak ada, max_delta_step=Tidak ada, max_depth=Tidak ada, min_child_weight=Tidak ada, hilang=nan, monotone_constraints=Tidak ada, n_estimators=200, n_jobs=-1, nthread=-1, num_parallel_tree=Tidak ada, objektif='binary:logistic', random_state=99, reg_alpha=Tidak ada, reg_lambda=Tidak ada, scale_pos_weight=Tidak ada, subsample=Tidak ada, tree_method=Tidak ada, use_label_encoder=Benar, validasi_parameters=Tidak ada, verbositas=Tidak ada), n_jobs=Tidak ada), cv=5, method='isotonik ')

LightAutoML

Sekarang, kami telah mencapai AutoML ke-10. LightAutoML diharapkan ringan seperti namanya. Di sini, kita menetapkan tugas menjadi 'reg' untuk regresi, 'multiclass' untuk klasifikasi multiclass, atau 'binary' untuk klasifikasi biner. Kami juga dapat mengatur metrik dan kerugian dalam tugas tersebut. Saya menyetel batas waktu menjadi 3 menit untuk membiarkannya menemukan model terbaik. Setelah .fit dan .predict sederhana, kita sudah bisa mendapatkan hasilnya.

Regresi

!pip instal -U https://github.com/sberbank-ai-lab/LightAutoML/raw/fix/logging/LightAutoML-0.2.16.2-py3-none-any.whl !pip instal openpyxl dari lightautoml.automl.presets .tabular_presets impor TabularAutoML dari lightautoml.tasks impor Tugas # Buat model light = TabularAutoML(tugas=Tugas('reg',), batas waktu=60*3, cpu_limit=4) train_data = pd.concat([X_train, y_train], axis=1) # Paskan data pelatihan train_light = light.fit_predict(train_data, role = {'target': 'SalePrice', 'drop':[]}) # Prediksikan data validasi pred_light = light.predict(X_val)

Klasifikasi

!pip instal -U https://github.com/sberbank-ai-lab/LightAutoML/raw/fix/logging/LightAutoML-0.2.16.2-py3-none-any.whl !pip instal openpyxl dari lightautoml.automl.presets .tabular_presets impor TabularAutoML dari lightautoml.tasks impor Tugas train_data = pd.concat([X_train, y_train], axis=1) # Buat model light = TabularAutoML(tugas=Tugas('multikelas',), batas waktu=60*3, cpu_limit=4) # Paskan data pelatihan train_light = light.fit_predict(train_data, role = {'target': 'Target'}) # Prediksikan data validasi pred_light = light.predict(X_val)

Hasil dari tugas klasifikasi adalah prediksi kelas dan probabilitas masing-masing kelas. Dengan kata lain, hasilnya memenuhi ekspektasi klasifikasi multikelas dan multilabel.

# Ubah hasil prediksi menjadi dataframe pred_light2 = pred_light.data pred_light2 = pd.DataFrame(pred_light2, column=['4','2','3','1']) pred_light2 = pred_light2[['1',' 2','3','4']] pred_light2['Pred'] = pred_light2.idxmax(axis=1) pred_light2['Pred'] = pred_light2['Pred'].astype(int) pred_light2.head()

	1	2	3	4	Pred
0	0.00	0.01	0.00	0.99	4
1	0.00	0.00	0.00	1.00	4
2	0.00	0.04	0.00	0.96	4
3	0.00	0.01	0.98	0.01	3
4	0.02	0.38	0.34	0.27	2

Kesimpulan

Kami telah membahas 10 paket AutoML sekarang. Harap perhatikan bahwa masih ada AutoML lainnya yang belum dibahas dalam postingan ini. Tidak hanya di notebook Python, AutoML juga dapat ditemukan di komputasi awan atau perangkat lunak. AutoML mana yang menjadi favorit Anda? Atau, apakah Anda sedang memikirkan AutoML lain?

 

Tentang Penulis

Referensi

1. Gambar 1 – https://www.kaggle.com/rendyk/automl-regression-part1
2. Gambar2- https://www.kaggle.com/rendyk/automl-regression-part1
3. Fig3- Gambar oleh Penulis
4. Fig4-Gambar oleh Penulis
5. Fig5-Gambar oleh Penulis
6. Fig6-Gambar oleh Penulis
7. Gambar7- https://www.kaggle.com/rendyk/automl-regression-part2
8. Gambar8- https://www.kaggle.com/rendyk/automl-regression-part2
9. Gambar9- https://www.kaggle.com/rendyk/automl-regression-part2
10. Gambar 10- sklearn, topot, hyperopt, autokeras, mljar, autogluon, h2o, pycaret, autoviml

Terhubung dengan saya di sini.

Media yang ditampilkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas kebijaksanaan Penulis.

terkait

Sumber: https://www.analyticsvidhya.com/blog/2021/09/10-automated-machine-learning-for-supervised-learning-part-2/