Tutorial: Melatih model di Python dengan pembelajaran mesin otomatis (tidak digunakan lagi)

Artikel
03/10/2024

Azure Machine Learning adalah lingkungan berbasis cloud yang memungkinkan Anda melatih, menyebarkan, mengotomatiskan, mengelola, dan melacak model pembelajaran mesin.

Dalam tutorial ini, Anda menggunakan pembelajaran mesin otomatis di Pembelajaran Mesin Microsoft Azure untuk membuat model regresi untuk memprediksi harga tarif taksi. Proses ini menggunakan model terbaik dengan menerima data pelatihan dan pengaturan konfigurasi, dan secara otomatis melakukan iterasi melalui kombinasi berbagai metode, model, dan pengaturan hyperparameter.

Dalam tutorial ini, Anda akan mempelajari cara:

Mengunduh data dengan menggunakan Apache Spark dan Azure Open Datasets.
Mengubah dan membersihkan data dengan menggunakan Apache Spark DataFrames.
Melatih model regresi dalam pembelajaran mesin otomatis.
Menghitung akurasi model.

Sebelum Anda mulai

Buat kumpulan Apache Spark 2.4 tanpa server dengan mengikuti mulai cepat Membuat kumpulan Apache Spark tanpa server.
Selesaikan tutorial Penyiapan ruang kerja Pembelajaran Mesin Microsoft Azure jika Anda tidak memiliki ruang kerja Pembelajaran Mesin Microsoft Azure yang sudah ada.

Peringatan

Mulai 29 September 2023, Azure Synapse akan menghentikan dukungan resmi untuk Runtime Spark 2.4. Pasca 29 September 2023, kami tidak akan membahas tiket dukungan apa pun yang terkait dengan Spark 2.4. Tidak akan ada alur rilis yang diberlakukan untuk perbaikan bug atau keamanan untuk Spark 2.4. Memanfaatkan Spark 2.4 pasca tanggal cutoff dukungan dilakukan dengan risiko seseorang sendiri. Kami sangat mencegah penggunaannya yang berkelanjutan karena potensi masalah keamanan dan fungsionalitas.
Sebagai bagian dari proses penghentian untuk Apache Spark 2.4, kami ingin memberi tahu Anda bahwa AutoML di Azure Synapse Analytics juga tidak akan digunakan lagi. Ini termasuk antarmuka kode rendah dan API yang digunakan untuk membuat uji coba AutoML melalui kode.
Harap dicatat bahwa fungsionalitas AutoML tersedia secara eksklusif melalui runtime Spark 2.4.
Untuk pelanggan yang ingin terus memanfaatkan kemampuan AutoML, sebaiknya simpan data Anda ke akun Azure Data Lake Storage Gen2 (ADLSg2) Anda. Dari sana, Anda dapat mengakses pengalaman AutoML dengan lancar melalui Azure Pembelajaran Mesin (AzureML). Informasi lebih lanjut mengenai solusi ini tersedia di sini.

Memahami model regresi

Model regresi memprediksi nilai output numerik berdasarkan pemrediksi independen. Dalam regresi, tujuannya adalah untuk membantu membangun hubungan di antara variabel pemrediksi independen dengan memerkirakan bagaimana satu variabel memengaruhi yang lain.

Contoh berdasarkan data taksi Kota New York

Dalam contoh ini, Anda menggunakan Spark untuk melakukan analisis pada data tip perjalanan taxi dari Kota New York (NYC). Data tersedia melalui Azure Open Datasets. Subset himpunan data ini berisi informasi tentang perjalanan taksi kuning, termasuk informasi tentang setiap perjalanan, waktu mulai dan akhir, serta lokasi, dan biayanya.

Penting

Mungkin ada biaya tambahan untuk menarik data ini dari lokasi penyimpanannya. Dalam langkah-langkah berikut, Anda mengembangkan model untuk memprediksi harga tarif taksi NYC.

Mengunduh dan menyiapkan data

Berikut caranya:

Buat buku catatan dengan menggunakan kernel PySpark. Untuk instruksi, lihat Membuat buku catatan.

Catatan

Karena kernel PySpark, Anda tidak perlu membuat konteks apa pun secara eksplisit. Konteks Spark secara otomatis dibuat saat Anda menjalankan sel kode pertama.

Karena data mentah dalam format Parquet, Anda dapat menggunakan konteks Spark untuk menarik file langsung ke memori sebagai DataFrame. Buat Spark DataFrame dengan mengambil data melalui API Open Datasets. Di sini, Anda menggunakan properti schema on read DataFrame Spark untuk menyimpulkan jenis data dan skema.

blob_account_name = "azureopendatastorage"
blob_container_name = "nyctlc"
blob_relative_path = "yellow"
blob_sas_token = r""

# Allow Spark to read from the blob remotely
wasbs_path = 'wasbs://%s@%s.blob.core.windows.net/%s' % (blob_container_name, blob_account_name, blob_relative_path)
spark.conf.set('fs.azure.sas.%s.%s.blob.core.windows.net' % (blob_container_name, blob_account_name),blob_sas_token)

# Spark read parquet; note that it won't load any data yet
df = spark.read.parquet(wasbs_path)

Tergantung pada ukuran kumpulan Spark Anda, data mentah mungkin terlalu besar atau memerlukan terlalu banyak waktu untuk dioperasikan. Anda dapat memfilter data ini ke sesuatu yang lebih kecil, seperti satu bulan data, dengan menggunakan start_date dan filter end_date. Setelah Anda memfilter DataFrame, Anda juga menjalankan fungsi describe() di DataFrame baru untuk melihat statistik ringkasan untuk setiap bidang.

Berdasarkan statistik ringkasan, Anda dapat melihat bahwa ada beberapa penyimpangan dalam data. Misalnya, statistik menunjukkan bahwa jarak perjalanan minimum kurang dari 0. Anda perlu memfilter titik data tidak teratur ini.
```
# Create an ingestion filter
start_date = '2015-01-01 00:00:00'
end_date = '2015-12-31 00:00:00'

filtered_df = df.filter('tpepPickupDateTime > "' + start_date + '" and tpepPickupDateTime< "' + end_date + '"')

filtered_df.describe().show()
```

Hasilkan fitur dari set data dengan memilih sekumpulan kolom dan buat berbagai fitur berbasis waktu dari bidang datetime penjemputan. Filter anomali yang diidentifikasi dari langkah sebelumnya, lalu hapus beberapa kolom terakhir karena tidak diperlukan dalam pelatihan.

from datetime import datetime
from pyspark.sql.functions import *

# To make development easier, faster, and less expensive, downsample for now
sampled_taxi_df = filtered_df.sample(True, 0.001, seed=1234)

taxi_df = sampled_taxi_df.select('vendorID', 'passengerCount', 'tripDistance',  'startLon', 'startLat', 'endLon' \
                                , 'endLat', 'paymentType', 'fareAmount', 'tipAmount'\
                                , column('puMonth').alias('month_num') \
                                , date_format('tpepPickupDateTime', 'hh').alias('hour_of_day')\
                                , date_format('tpepPickupDateTime', 'EEEE').alias('day_of_week')\
                                , dayofmonth(col('tpepPickupDateTime')).alias('day_of_month')
                                ,(unix_timestamp(col('tpepDropoffDateTime')) - unix_timestamp(col('tpepPickupDateTime'))).alias('trip_time'))\
                        .filter((sampled_taxi_df.passengerCount > 0) & (sampled_taxi_df.passengerCount < 8)\
                                & (sampled_taxi_df.tipAmount >= 0)\
                                & (sampled_taxi_df.fareAmount >= 1) & (sampled_taxi_df.fareAmount <= 250)\
                                & (sampled_taxi_df.tipAmount < sampled_taxi_df.fareAmount)\
                                & (sampled_taxi_df.tripDistance > 0) & (sampled_taxi_df.tripDistance <= 200)\
                                & (sampled_taxi_df.rateCodeId <= 5)\
                                & (sampled_taxi_df.paymentType.isin({"1", "2"})))
taxi_df.show(10)

Seperti yang Anda lihat, ini akan membuat DataFrame baru dengan kolom tambahan untuk hari dalam satu bulan, jam penjemputan, hari kerja, dan total waktu perjalanan.

Gambar DataFrame taksi.

Hasilkan himpunan data pengujian dan validasi

Setelah Anda memiliki himpunan data akhir, Anda dapat membagi data menjadi pelatihan dan kumpulan pengujian dengan menggunakan fungsi random_ split di Spark. Dengan menggunakan bobot yang disediakan, fungsi ini secara acak membagi data ke dalam kumpulan data pelatihan untuk pelatihan model dan kumpulan data validasi untuk pengujian.

# Random split dataset using Spark; convert Spark to pandas
training_data, validation_data = taxi_df.randomSplit([0.8,0.2], 223)

Langkah ini memastikan bahwa titik data untuk menguji model yang sudah jadi belum digunakan untuk melatih model.

Sambungkan ke ruang kerja Pembelajaran Mesin Microsoft Azure

Di Pembelajaran Mesin Microsoft Azure, 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. Dalam langkah ini, Anda membuat objek ruang kerja dari ruang kerja Pembelajaran Mesin Microsoft Azure yang ada.

from azureml.core import Workspace

# Enter your subscription id, resource group, and workspace name.
subscription_id = "<enter your subscription ID>" #you should be owner or contributor
resource_group = "<enter your resource group>" #you should be owner or contributor
workspace_name = "<enter your workspace name>" #your workspace name

ws = Workspace(workspace_name = workspace_name,
               subscription_id = subscription_id,
               resource_group = resource_group)

Mengonversi DataFrame menjadi kumpulan data Pembelajaran Mesin Microsoft Azure

Untuk mengirimkan eksperimen jarak jauh, konversikan himpunan data Anda menjadi instans TabularDatset Pembelajaran Mesin Microsoft Azure. TabularDataset mewakili data dalam format tabular dengan menguraikan file yang disediakan.

Kode berikut mendapatkan ruang kerja yang ada dan datastore Pembelajaran Mesin Microsoft Azure default. Kemudian melewati datastore dan lokasi file ke parameter jalur untuk membuat instans TabularDataset baru.

import pandas 
from azureml.core import Dataset

# Get the Azure Machine Learning default datastore
datastore = ws.get_default_datastore()
training_pd = training_data.toPandas().to_csv('training_pd.csv', index=False)

# Convert into an Azure Machine Learning tabular dataset
datastore.upload_files(files = ['training_pd.csv'],
                       target_path = 'train-dataset/tabular/',
                       overwrite = True,
                       show_progress = True)
dataset_training = Dataset.Tabular.from_delimited_files(path = [(datastore, 'train-dataset/tabular/training_pd.csv')])

Gambar himpunan data yang diunggah.

Mengirimkan eksperimen otomatis

Bagian berikut memandu Anda melalui proses pengajuan eksperimen pembelajaran mesin otomatis.

Menentukan pengaturan pelatihan

Untuk mengirimkan eksperimen, Anda harus menentukan parameter eksperimen dan pengaturan model untuk pelatihan. Untuk daftar lengkap pengaturan, lihat Mengonfigurasi eksperimen pembelajaran mesin otomatis di Python.

import logging

automl_settings = {
    "iteration_timeout_minutes": 10,
    "experiment_timeout_minutes": 30,
    "enable_early_stopping": True,
    "primary_metric": 'r2_score',
    "featurization": 'auto',
    "verbosity": logging.INFO,
    "n_cross_validations": 2}

Meneruskan pengaturan pelatihan yang ditentukan sebagai parameter kwargs ke objek AutoMLConfig. Karena Anda menggunakan Spark, Anda juga harus melewati konteks Spark, yang secara otomatis dapat diakses oleh variabel sc. Selain itu, Anda menentukan data pelatihan dan jenis model, yang merupakan regresi dalam kasus ini.

from azureml.train.automl import AutoMLConfig

automl_config = AutoMLConfig(task='regression',
                             debug_log='automated_ml_errors.log',
                             training_data = dataset_training,
                             spark_context = sc,
                             model_explainability = False, 
                             label_column_name ="fareAmount",**automl_settings)

Catatan

Langkah-langkah pra-pemrosesan pembelajaran mesin otomatis menjadi bagian dari model yang mendasarinya. Langkah-langkah ini termasuk normalisasi fitur, menangani data yang hilang, dan mengonversi teks menjadi numerik. Saat Anda 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

Selanjutnya, Anda membuat objek eksperimen di ruang kerja Pembelajaran Mesin Microsoft Azure Anda. Eksperimen bertindak sebagai kontainer untuk menjalankan individu Anda.

from azureml.core.experiment import Experiment

# Start an experiment in Azure Machine Learning
experiment = Experiment(ws, "aml-synapse-regression")
tags = {"Synapse": "regression"}
local_run = experiment.submit(automl_config, show_output=True, tags = tags)

# Use the get_details function to retrieve the detailed output for the run.
run_details = local_run.get_details()

Setelah percobaan selesai, output mengembalikan detail tentang iterasi yang telah selesai. Untuk setiap iterasi, Anda akan melihat jenis model, durasi proses, dan akurasi latihan. Bidang BEST melacak skor latihan terbaik berdasarkan jenis metrik Anda.

Cuplikan layar output model.

Catatan

Setelah Anda mengirimkan eksperimen pembelajaran mesin otomatis, ini akan menjalankan berbagai iterasi dan jenis model. Eksekusi ini biasanya memerlukan waktu 60 hingga 90 menit.

Mengambil model terbaik

Untuk memilih model terbaik dari iterasi Anda, gunakan fungsi get_output untuk mengembalikan model yang berjalan paling baik dan sesuai. Kode berikut mengambil model terbaik dan sesuai untuk metrik yang dicatat atau iterasi tertentu.

# Get best model
best_run, fitted_model = local_run.get_output()

Akurasi model pengujian

Untuk menguji akurasi model, gunakan model terbaik untuk menjalankan prediksi tarif taksi pada himpunan data pengujian. Fungsi predict ini menggunakan model terbaik dan memprediksi nilai y (jumlah tarif) dari himpunan data validasi.
```
# Test best model accuracy
validation_data_pd = validation_data.toPandas()
y_test = validation_data_pd.pop("fareAmount").to_frame()
y_predict = fitted_model.predict(validation_data_pd)
```
Kesalahan root-mean-square adalah ukuran yang sering digunakan dari perbedaan antara nilai sampel yang diprediksi oleh model dan nilai yang diamati. Anda menghitung kesalahan root-mean-square dari hasil dengan membandingkan DataFrame y_test dengan nilai yang diprediksi oleh model.

Fungsi mean_squared_error ini mengambil dua array dan menghitung kesalahan kuadrat rata-rata di antaranya. Anda lalu mengambil akar kuadrat dari hasilnya. 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

# Calculate root-mean-square error
y_actual = y_test.values.flatten().tolist()
rmse = sqrt(mean_squared_error(y_actual, y_predict))

print("Root Mean Square Error:")
print(rmse)
```
```
Root Mean Square Error:
2.309997102577151
```
Kesalahan root-mean-square adalah ukuran yang baik tentang seberapa akurat model memprediksi respons. Dari hasilnya, Anda melihat bahwa model ini cukup baik dalam memprediksi tarif taksi dari fitur himpunan data, biasanya dalam $ 2,00.

Jalankan kode berikut untuk menghitung kesalahan mean-absolute-percent. Metrik ini mengekspresikan akurasi sebagai persentase kesalahan. Ini dilakukan dengan menghitung perbedaan mutlak antara setiap prediksi dan nilai aktual lalu menjumlahkan semua perbedaan. Lalu mengekspresikan jumlah tersebut sebagai persentase dari total nilai aktual.

# Calculate mean-absolute-percent error and model accuracy 
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.03655071038487368

Model Accuracy:
0.9634492896151263

Dari dua metrik akurasi prediksi tersebut, Anda melihat bahwa model tersebut terbilang cukup baik dalam memprediksi tarif taksi dari fitur himpunan data.

Setelah memasang model regresi linier, Anda sekarang perlu menentukan seberapa sesuai model tersebut dengan data. Untuk melakukan ini, Anda memplot nilai tarif aktual terhadap output yang diprediksi. Selain itu, Anda menghitung pengukuran R-kuadrat untuk memahami seberapa dekat data ke garis regresi yang disesuaikan.

import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import mean_squared_error, r2_score

# Calculate the R2 score by using the predicted and actual fare prices
y_test_actual = y_test["fareAmount"]
r2 = r2_score(y_test_actual, y_predict)

# Plot the actual versus predicted fare amount values
plt.style.use('ggplot')
plt.figure(figsize=(10, 7))
plt.scatter(y_test_actual,y_predict)
plt.plot([np.min(y_test_actual), np.max(y_test_actual)], [np.min(y_test_actual), np.max(y_test_actual)], color='lightblue')
plt.xlabel("Actual Fare Amount")
plt.ylabel("Predicted Fare Amount")
plt.title("Actual vs Predicted Fare Amount R^2={}".format(r2))
plt.show()

Cuplikan layar plot regresi.

Dari hasilnya, Anda dapat melihat bahwa pengukuran R-kuadrat menyumbang 95 persen dari varians. Ini juga divalidasi oleh plot aktual versus plot yang diamati. Semakin banyak varians yang diperhitungkan oleh model regresi, semakin dekat titik data akan termasuk ke garis regresi yang disesuaikan.

Mendaftarkan model ke Pembelajaran Mesin Microsoft Azure

Setelah memvalidasi model terbaik, Anda dapat mendaftarkannya ke Pembelajaran Mesin Microsoft Azure. Lalu, Anda dapat mengunduh atau menyebarkan model terdaftar, dan menerima semua file yang Anda daftarkan.

description = 'My automated ML model'
model_path='outputs/model.pkl'
model = best_run.register_model(model_name = 'NYCYellowTaxiModel', model_path = model_path, description = description)
print(model.name, model.version)

NYCYellowTaxiModel 1

Menampilkan hasil di Pembelajaran Mesin Microsoft Azure

Anda juga dapat mengakses hasil iterasi dengan membuka eksperimen di ruang kerja Pembelajaran Mesin Microsoft Azure Anda. Di sini, Anda bisa mendapatkan detail tambahan tentang status eksekusi, model yang dicoba, dan metrik model lainnya.

Cuplikan layar ruang kerja Pembelajaran Mesin Microsoft Azure.

Bagikan melalui