Melatih model regresi dengan AutoML dan Python (SDK v1)
BERLAKU UNTUK:SDK Python azureml v1
Dalam artikel ini, Anda mempelajari cara melatih model regresi dengan SDK Python Azure Machine Learning menggunakan ML otomatis Azure Machine Learning. Model regresi ini memprediksi tarif taksi NYC.
Proses ini menerima pengaturan data dan konfigurasi pelatihan, dan secara otomatis melakukan iterasi melalui kombinasi metode normalisasi/standardisasi fitur, model, dan pengaturan hyperparameter yang berbeda untuk sampai pada model terbaik.
Anda menulis kode menggunakan Python SDK dalam artikel ini. Anda mempelajari tugas-tugas berikut:
- Mengunduh, mengubah, dan membersihkan data menggunakan Azure Open Datasets
- Melatih model regresi pembelajaran mesin otomatis
- Menghitung akurasi model
Untuk AutoML tanpa kode, cobalah tutorial berikut:
Prasyarat
Jika Anda tidak memiliki langganan Azure, buat akun gratis sebelum Anda memulai. Coba versi gratis atau berbayar Azure Machine Learning sekarang.
- Selesaikan Mulai cepat: Mulai menggunakan Azure Machine Learning jika Anda belum memiliki ruang kerja Azure Machine Learning atau instans komputasi.
- Setelah Anda menyelesaikan mulai cepat:
- Pilih Notebooks di studio.
- Pilih tab Sampel.
- Buka notebook SDK v1/tutorials/regression-automl-nyc-taxi-data/regression-automated-ml.ipynb.
- Untuk menjalankan setiap sel dalam tutorial, pilih Kloning buku catatan ini
Artikel ini juga tersedia di GitHub jika ingin menggunakannya di lingkungan lokal Anda sendiri. Untuk mendapatkan paket yang diperlukan,
- Instal klien
automl
lengkap. - Jalankan
pip install azureml-opendatasets azureml-widgets
untuk mendapatkan paket yang diperlukan.
Mengunduh dan menyiapkan data
Impor paket yang diperlukan. Paket Open Datasets berisi kelas yang mewakili setiap sumber data (misalnya NycTlcGreen
) untuk memfilter parameter tanggal dengan mudah sebelum mengunduh.
from azureml.opendatasets import NycTlcGreen
import pandas as pd
from datetime import datetime
from dateutil.relativedelta import relativedelta
Mulailah dengan membuat dataframe untuk menyimpan data taksi. Saat Anda bekerja di lingkungan non-Spark, Open Datasets hanya memungkinkan pengunduhan satu bulan data pada satu waktu dengan kelas tertentu untuk menghindari MemoryError
dengan himpunan data besar.
Untuk mengunduh data taksi, secara berulang-ulang mengambil satu bulan sekaligus, dan sebelum menambahkannya untuk green_taxi_df
secara acak membuat sampel 2.000 rekaman dari setiap bulan untuk menghindari penuhnya dataframe. Kemudian, lihat pratinjau data.
green_taxi_df = pd.DataFrame([])
start = datetime.strptime("1/1/2015","%m/%d/%Y")
end = datetime.strptime("1/31/2015","%m/%d/%Y")
for sample_month in range(12):
temp_df_green = NycTlcGreen(start + relativedelta(months=sample_month), end + relativedelta(months=sample_month)) \
.to_pandas_dataframe()
green_taxi_df = green_taxi_df.append(temp_df_green.sample(2000))
green_taxi_df.head(10)
vendorID | lpepPickupDatetime | lpepDropoffDatetime | passengerCount | tripDistance | puLocationId | doLocationId | pickupLongitude | pickupLatitude | dropoffLongitude | ... | paymentType | fareAmount | extra | mtaTax | improvementSurcharge | tipAmount | tollsAmount | ehailFee | totalAmount | tripType |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
131969 | 2 | 2015-01-11 05:34:44 | 2015-01-11 05:45:03 | 3 | 4.84 | Tidak | Tidak | -73.88 | 40.84 | -73.94 | ... | 2 | 15.00 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 16.30 |
1129817 | 2 | 2015-01-20 16:26:29 | 2015-01-20 16:30:26 | 1 | 0.69 | Tidak | Tidak | -73.96 | 40.81 | -73.96 | ... | 2 | 4.50 | 1 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 6.30 |
1278620 | 2 | 2015-01-01 05:58:10 | 2015-01-01 06:00:55 | 1 | 0,45 | Tidak | Tidak | -73.92 | 40.76 | -73.91 | ... | 2 | 4.00 | 0.00 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 4,80 |
348430 | 2 | 2015-01-17 02:20:50 | 2015-01-17 02:41:38 | 1 | 0.00 | Tidak | Tidak | -73.81 | 40.70 | -73.82 | ... | 2 | 12.50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 13.80 |
1269627 | 1 | 2015-01-01 05:04:10 | 2015-01-01 05:06:23 | 1 | 0.50 | Tidak | Tidak | -73.92 | 40.76 | -73.92 | ... | 2 | 4.00 | 0.50 | 0.50 | 0 | 0.00 | 0.00 | nan | 5.00 |
811755 | 1 | 2015-01-04 19:57:51 | 2015-01-04 20:05:45 | 2 | 1.10 | Tidak | Tidak | -73.96 | 40.72 | -73.95 | ... | 2 | 6.50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 7.80 |
737281 | 1 | 2015-01-03 12:27:31 | 2015-01-03 12:33:52 | 1 | 0.90 | Tidak | Tidak | -73.88 | 40.76 | -73.87 | ... | 2 | 6.00 | 0.00 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 6.80 |
113951 | 1 | 2015-01-09 23:25:51 | 2015-01-09 23:39:52 | 1 | 3.30 | Tidak | Tidak | -73.96 | 40.72 | -73.91 | ... | 2 | 12.50 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 13.80 |
150436 | 2 | 2015-01-11 17:15:14 | 2015-01-11 17:22:57 | 1 | 1.19 | Tidak | Tidak | -73.94 | 40.71 | -73.95 | ... | 1 | 7.00 | 0.00 | 0.50 | 0,3 | 1,75 | 0.00 | nan | 9.55 |
432136 | 2 | 2015-01-22 23:16:33 2015-01-22 23:20:13 1 0.65 | Tidak | Tidak | -73.94 | 40.71 | -73.94 | ... | 2 | 5.00 | 0.50 | 0.50 | 0,3 | 0.00 | 0.00 | nan | 6.30 |
Hapus beberapa kolom yang tidak diperlukan untuk pelatihan atau pembuatan fitur lainnya. Pembelajaran mesin otomatis akan secara otomatis menangani fitur berbasis waktu seperti lpepPickupDatetime.
columns_to_remove = ["lpepDropoffDatetime", "puLocationId", "doLocationId", "extra", "mtaTax",
"improvementSurcharge", "tollsAmount", "ehailFee", "tripType", "rateCodeID",
"storeAndFwdFlag", "paymentType", "fareAmount", "tipAmount"
]
for col in columns_to_remove:
green_taxi_df.pop(col)
green_taxi_df.head(5)
Membersihkan data
Jalankan fungsi describe()
pada dataframe baru untuk melihat statistik ringkasan setiap bidang.
green_taxi_df.describe()
vendorID | passengerCount | tripDistance | pickupLongitude | pickupLatitude | dropoffLongitude | dropoffLatitude | totalAmount | month_num day_of_month | day_of_week | hour_of_day |
---|---|---|---|---|---|---|---|---|---|---|
jumlah | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 | 48000.00 |
mean | 1.78 | 1.37 | 2.87 | -73.83 | 40.69 | -73.84 | 40.70 | 14.75 | 6.50 | 15.13 |
std | 0.41 | 1.04 | 2.93 | 2.76 | 1.52 | 2.61 | 1.44 | 12.08 | 3.45 | 8.45 |
min | 1 | 0.00 | 0.00 | -74.66 | 0.00 | -74.66 | 0.00 | -300.00 | 1 | 1 |
25% | 2.00 | 1 | 1.06 | -73.96 | 40.70 | -73.97 | 40.70 | 7.80 | 3.75 | 8.00 |
50% | 2.00 | 1 | 1.90 | -73.94 | 40.75 | -73.94 | 40.75 | 11.30 | 6.50 | 15.00 |
75% | 2.00 | 1 | 3.60 | -73.92 | 40.80 | -73.91 | 40.79 | 17.80 | 9.25 | 22.00 |
maks | 2.00 | 9.00 | 97.57 | 0.00 | 41.93 | 0.00 | 41.94 | 450.00 | 12.00 | 30.00 |
Dari statistik ringkasan, Anda melihat bahwa ada beberapa bidang yang memiliki outlier atau nilai yang mengurangi akurasi model. Pertama, filter bidang lat/long agar berada dalam batas-batas daerah Manhattan. Ini memfilter perjalanan taksi atau perjalanan yang lebih lama yang merupakan outlier sehubungan dengan hubungan mereka dengan fitur lain.
Selain itu, filter bidang tripDistance
menjadi lebih besar dari nol, tetapi kurang dari 31 mil (jarak haversine antara dua pasangan lat/long). Tindakan ini menghilangkan perjalanan outlier panjang yang memiliki biaya perjalanan yang tidak konsisten.
Terakhir, bidang totalAmount
memiliki nilai negatif untuk tarif taksi, yang tidak masuk akal dalam konteks model kami, dan bidang passengerCount
memiliki data yang buruk dengan nilai minimum adalah nol.
Filter anomali ini menggunakan fungsi kueri, lalu hapus beberapa kolom terakhir yang tidak diperlukan untuk pelatihan.
final_df = green_taxi_df.query("pickupLatitude>=40.53 and pickupLatitude<=40.88")
final_df = final_df.query("pickupLongitude>=-74.09 and pickupLongitude<=-73.72")
final_df = final_df.query("tripDistance>=0.25 and tripDistance<31")
final_df = final_df.query("passengerCount>0 and totalAmount>0")
columns_to_remove_for_training = ["pickupLongitude", "pickupLatitude", "dropoffLongitude", "dropoffLatitude"]
for col in columns_to_remove_for_training:
final_df.pop(col)
Panggil describe()
lagi pada data untuk memastikan pembersihan berjalan seperti yang diharapkan. Anda sekarang memiliki sekumpulan data taksi, liburan, dan cuaca yang telah disiapkan dan dibersihkan untuk digunakan pada pelatihan model pembelajaran mesin.
final_df.describe()
Konfigurasi ruang kerja
Buat objek ruang kerja dari ruang kerja yang sudah ada. Ruang kerja adalah kelas yang menerima informasi langganan dan sumber daya Azure Anda. Ruang kerja juga membuat sumber daya cloud untuk memantau dan melacak eksekusi model Anda. Workspace.from_config()
membaca file config.json dan memuat detail autentikasi ke dalam objek bernama ws
: ws
digunakan di seluruh kode lainnya dalam artikel ini.
from azureml.core.workspace import Workspace
ws = Workspace.from_config()
Membagi data menjadi kumpulan pelatihan dan pengujian
Bagi data menjadi kumpulan pelatihan dan pengujian dengan menggunakan fungsi train_test_split
di pustaka scikit-learn
. Fungsi ini memisahkan data ke dalam kumpulan data x (fitur) untuk pelatihan model dan kumpulan data y (nilai yang akan diprediksi) untuk pengujian.
Parameter test_size
menentukan persentase data yang akan dialokasikan ke pengujian. Parameter random_state
menetapkan seed ke generator acak sehingga pemisahan pengujian dan pelatihan Anda bersifat deterministik.
from sklearn.model_selection import train_test_split
x_train, x_test = train_test_split(final_df, test_size=0.2, random_state=223)
Tujuan dari langkah ini adalah mengatur titik data untuk menguji model jadi yang belum digunakan untuk melatih model, guna mengukur akurasi sesungguhnya.
Dengan kata lain, model yang terlatih harus dapat secara akurat membuat prediksi dari data yang belum dilihatnya. Anda sekarang memiliki data yang disiapkan untuk melatih model pembelajaran mesin secara otomatis.
Melatih model secara otomatis
Untuk melatih model secara otomatis, ikuti langkah-langkah berikut:
- Tentukan pengaturan untuk eksperimen yang dijalankan. Lampirkan data pelatihan Anda ke konfigurasi, dan ubah pengaturan yang mengontrol proses pelatihan.
- Kirim eksperimen untuk penyetelan model. Setelah mengirimkan eksperimen, proses ini berulang-ulang melalui berbagai algoritme pembelajaran mesin dan pengaturan hyperparameter, mematuhi batasan yang ditentukan. Proses ini memilih model yang paling cocok dengan mengoptimalkan metrik akurasi.
Menentukan pengaturan pelatihan
Tentukan parameter eksperimen dan pengaturan model untuk pelatihan. Lihat daftar lengkap pengaturan. Mengirimkan eksperimen dengan pengaturan default ini membutuhkan waktu sekitar 5-20 menit, tetapi jika Anda menginginkan waktu proses yang lebih singkat, kurangi experiment_timeout_hours
parameter .
Properti | Nilai dalam artikel ini | Deskripsi |
---|---|---|
iteration_timeout_minutes | 10 | Batas waktu dalam menit untuk setiap iterasi. Tingkatkan nilai ini untuk set data yang lebih besar yang membutuhkan lebih banyak waktu untuk setiap iterasi. |
experiment_timeout_hours | 0,3 | Jumlah waktu maksimum dalam jam yang diperlukan semua iterasi sebelum eksperimen diakhiri. |
enable_early_stopping | Benar | Bendera untuk mengaktifkan penghentian dini jika skor tidak membaik dalam jangka pendek. |
primary_metric | spearman_correlation | Metrik yang ingin Anda optimalkan. Model yang paling sesuai dipilih berdasarkan metrik ini. |
featurization | auto | Dengan menggunakan auto, eksperimen dapat melakukan praproses data input (menangani data yang hilang, mengonversi teks menjadi numerik, dll.) |
verbosity | logging.INFO | Mengontrol tingkat pencatatan. |
n_cross_validations | 5 | Jumlah pemisahan validasi silang yang akan dilakukan saat data validasi tidak ditentukan. |
import logging
automl_settings = {
"iteration_timeout_minutes": 10,
"experiment_timeout_hours": 0.3,
"enable_early_stopping": True,
"primary_metric": 'spearman_correlation',
"featurization": 'auto',
"verbosity": logging.INFO,
"n_cross_validations": 5
}
Gunakan pengaturan pelatihan yang ditentukan sebagai parameter **kwargs
ke objek AutoMLConfig
. Selain itu, tentukan data pelatihan Anda dan jenis model, yang berupa regression
dalam kasus ini.
from azureml.train.automl import AutoMLConfig
automl_config = AutoMLConfig(task='regression',
debug_log='automated_ml_errors.log',
training_data=x_train,
label_column_name="totalAmount",
**automl_settings)
Catatan
Langkah-langkah pra-pemrosesan pembelajaran mesin otomatis (normalisasi fitur, penanganan data yang hilang, konversi teks menjadi numerik, dll.) menjadi bagian dari model yang mendasarinya. Saat menggunakan model untuk prediksi, langkah-langkah pra-pemrosesan yang sama diterapkan selama pelatihan juga diterapkan ke data input Anda secara otomatis.
Melatih model regresi otomatis
Buat objek eksperimen di ruang kerja Anda. Eksperimen berfungsi sebagai kontainer untuk pekerjaan individu Anda. Teruskan objek automl_config
yang ditentukan ke eksperimen, dan atur output ke True
untuk melihat kemajuan selama pekerjaan.
Setelah memulai eksperimen, output ditampilkan pembaruan langsung saat eksperimen berjalan. Untuk setiap iterasi, Anda akan melihat jenis model, durasi proses, dan akurasi latihan. Bidang BEST
melacak skor latihan terbaik berdasarkan jenis metrik Anda.
from azureml.core.experiment import Experiment
experiment = Experiment(ws, "Tutorial-NYCTaxi")
local_run = experiment.submit(automl_config, show_output=True)
Running on local machine
Parent Run ID: AutoML_1766cdf7-56cf-4b28-a340-c4aeee15b12b
Current status: DatasetFeaturization. Beginning to featurize the dataset.
Current status: DatasetEvaluation. Gathering dataset statistics.
Current status: FeaturesGeneration. Generating features for the dataset.
Current status: DatasetFeaturizationCompleted. Completed featurizing the dataset.
Current status: DatasetCrossValidationSplit. Generating individually featurized CV splits.
Current status: ModelSelection. Beginning model selection.
****************************************************************************************************
ITERATION: The iteration being evaluated.
PIPELINE: A summary description of the pipeline being evaluated.
DURATION: Time taken for the current iteration.
METRIC: The result of computing score on the fitted pipeline.
BEST: The best observed score thus far.
****************************************************************************************************
ITERATION PIPELINE DURATION METRIC BEST
0 StandardScalerWrapper RandomForest 0:00:16 0.8746 0.8746
1 MinMaxScaler RandomForest 0:00:15 0.9468 0.9468
2 StandardScalerWrapper ExtremeRandomTrees 0:00:09 0.9303 0.9468
3 StandardScalerWrapper LightGBM 0:00:10 0.9424 0.9468
4 RobustScaler DecisionTree 0:00:09 0.9449 0.9468
5 StandardScalerWrapper LassoLars 0:00:09 0.9440 0.9468
6 StandardScalerWrapper LightGBM 0:00:10 0.9282 0.9468
7 StandardScalerWrapper RandomForest 0:00:12 0.8946 0.9468
8 StandardScalerWrapper LassoLars 0:00:16 0.9439 0.9468
9 MinMaxScaler ExtremeRandomTrees 0:00:35 0.9199 0.9468
10 RobustScaler ExtremeRandomTrees 0:00:19 0.9411 0.9468
11 StandardScalerWrapper ExtremeRandomTrees 0:00:13 0.9077 0.9468
12 StandardScalerWrapper LassoLars 0:00:15 0.9433 0.9468
13 MinMaxScaler ExtremeRandomTrees 0:00:14 0.9186 0.9468
14 RobustScaler RandomForest 0:00:10 0.8810 0.9468
15 StandardScalerWrapper LassoLars 0:00:55 0.9433 0.9468
16 StandardScalerWrapper ExtremeRandomTrees 0:00:13 0.9026 0.9468
17 StandardScalerWrapper RandomForest 0:00:13 0.9140 0.9468
18 VotingEnsemble 0:00:23 0.9471 0.9471
19 StackEnsemble 0:00:27 0.9463 0.9471
Jelajahi hasilnya
Jelajahi hasil pelatihan otomatis dengan widget Jupyter. Widget memungkinkan Anda untuk melihat grafik dan tabel dari semua perulangan pekerjaan individual, bersama dengan metrik akurasi pelatihan dan metadata. Selain itu, Anda dapat memfilter metrik akurasi yang berbeda dari metrik utama dengan pemilih dropdown.
from azureml.widgets import RunDetails
RunDetails(local_run).show()
Mengambil model terbaik
Pilih model terbaik dari iterasi Anda. Fungsi get_output
mengembalikan proses terbaik dan model yang tepat untuk pemanggilan terbaik terakhir. Dengan menggunakan overload pada get_output
, Anda dapat mengambil model yang dijalankan terbaik dan sesuai untuk metrik yang dicatat atau untuk iterasi tertentu.
best_run, fitted_model = local_run.get_output()
print(best_run)
print(fitted_model)
Menguji akurasi model terbaik
Gunakan model terbaik untuk menjalankan prediksi pada kumpulan data pengujian guna memprediksi tarif taksi. Fungsi predict
menggunakan model terbaik dan memprediksi nilai y, biaya perjalanan, dari kumpulan data x_test
. Cetak 10 nilai biaya yang diprediksi pertama dari y_predict
.
y_test = x_test.pop("totalAmount")
y_predict = fitted_model.predict(x_test)
print(y_predict[:10])
Hitung root mean squared error
hasilnya. Konversikan dataframe y_test
menjadi daftar untuk dibandingkan dengan nilai yang diprediksi. Fungsi mean_squared_error
mengambil dua array nilai dan menghitung kesalahan kuadrat rata-rata di antaranya. Mengambil akar kuadrat dari hasil memberikan kesalahan dalam unit yang sama dengan variabel y, biaya. Metrik ini menunjukkan kira-kira seberapa jauh prediksi tarif taksi dari nilai tarif aktual.
from sklearn.metrics import mean_squared_error
from math import sqrt
y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))
rmse
Jalankan kode berikut untuk menghitung kesalahan persentase absolut rata-rata (MAPE) dengan menggunakan kumpulan data y_actual
dan y_predict
penuh. Metrik ini menghitung perbedaan absolut antara setiap nilai yang diprediksi dan nilai sesungguhnya, serta menjumlahkan semua perbedaan. Lalu mengekspresikan jumlah tersebut sebagai persentase dari total nilai sesungguhnya.
sum_actuals = sum_errors = 0
for actual_val, predict_val in zip(y_actual, y_predict):
abs_error = actual_val - predict_val
if abs_error < 0:
abs_error = abs_error * -1
sum_errors = sum_errors + abs_error
sum_actuals = sum_actuals + actual_val
mean_abs_percent_error = sum_errors / sum_actuals
print("Model MAPE:")
print(mean_abs_percent_error)
print()
print("Model Accuracy:")
print(1 - mean_abs_percent_error)
Model MAPE:
0.14353867606052823
Model Accuracy:
0.8564613239394718
Dari dua metrik akurasi prediksi, Anda melihat bahwa model ini cukup baik dalam memprediksi tarif taksi dari fitur kumpulan data, biasanya dalam +- $4.00, dan sekitar 15% kesalahan.
Proses pengembangan model pembelajaran mesin tradisional menggunakan banyak sumber daya, dan membutuhkan pengetahuan domain yang signifikan dan investasi waktu untuk menjalankan dan membandingkan hasil dari puluhan model. Menggunakan pembelajaran mesin otomatis adalah cara yang bagus untuk menguji dengan cepat banyak model berbeda untuk skenario Anda.
Membersihkan sumber daya
Jangan selesaikan bagian ini jika Anda berencana menjalankan tutorial Azure Pembelajaran Mesin lainnya.
Menghentikan instans komputasi
Jika Anda menggunakan instans komputasi, hentikan VM saat Anda tidak menggunakannya untuk mengurangi biaya.
Di ruang kerja Anda, pilih Komputasi.
Dari daftar, pilih nama instans komputasi.
Pilih Hentikan.
Ketika Anda siap untuk menggunakan server lagi, pilih Mulai.
Menghapus semuanya
Jika Anda tidak berencana menggunakan sumber daya yang Anda buat, hapus sehingga Anda tidak dikenakan biaya apa pun.
- Dari portal Microsoft Azure, pilih Grup sumber daya dari sisi sebelah kiri.
- Dari daftar, pilih grup sumber daya yang Anda buat.
- Pilih Hapus grup sumber daya.
- Masukkan nama grup sumber daya. Kemudian pilih Hapus.
Anda juga dapat menyimpan grup sumber daya tetapi menghapus satu ruang kerja. Tampilkan properti ruang kerja dan pilih Hapus.
Langkah berikutnya
Dalam artikel pembelajaran mesin otomatis ini, Anda telah melakukan tugas berikut:
- Mengonfigurasi ruang kerja dan menyiapkan data untuk eksperimen.
- Berlatih menggunakan model regresi otomatis secara lokal dengan parameter kustom.
- Mempelajari dan meninjau hasil pelatihan.
Menyiapkan AutoML untuk melatih model visi komputer dengan Python (v1)