Tutorial: Melatih model di Azure Pembelajaran Mesin

BERLAKU UNTUK: Python SDK azure-ai-ml v2 (saat ini)

Pelajari cara ilmuwan data menggunakan Azure Pembelajaran Mesin untuk melatih model. Dalam contoh ini, Anda menggunakan himpunan data kartu kredit untuk memahami cara menggunakan Azure Pembelajaran Mesin untuk masalah klasifikasi. Tujuannya adalah untuk memprediksi apakah pelanggan memiliki kemungkinan besar default pada pembayaran kartu kredit. Skrip pelatihan menangani persiapan data. Skrip kemudian melatih dan mendaftarkan model.

Tutorial ini membawa Anda melalui langkah-langkah untuk mengirimkan pekerjaan pelatihan berbasis cloud (pekerjaan perintah).

Jika Anda ingin mempelajari selengkapnya tentang cara memuat data Anda ke Azure, lihat Tutorial: Mengunggah, mengakses, dan menjelajahi data Anda di Azure Pembelajaran Mesin.

Video ini menunjukkan cara memulai di studio Azure Pembelajaran Mesin sehingga Anda dapat mengikuti langkah-langkah dalam tutorial. Video memperlihatkan cara membuat buku catatan, membuat instans komputasi, dan mengkloning buku catatan. Langkah-langkahnya juga dijelaskan di bagian berikut.

Prasyarat

• Untuk menggunakan Azure Pembelajaran Mesin, Anda memerlukan ruang kerja. Jika Anda tidak memilikinya, selesaikan Buat sumber daya yang Anda perlukan untuk mulai membuat ruang kerja dan pelajari selengkapnya tentang menggunakannya.

  Penting

  Jika ruang kerja Azure Pembelajaran Mesin Anda dikonfigurasi dengan jaringan virtual terkelola, Anda mungkin perlu menambahkan aturan keluar untuk mengizinkan akses ke repositori paket Python publik. Untuk informasi selengkapnya, lihat Skenario: Mengakses paket pembelajaran mesin publik.

• Masuk ke studio dan pilih ruang kerja Anda jika belum dibuka.

• Buka atau buat buku catatan di ruang kerja Anda:

  • Jika Anda ingin menyalin dan menempelkan kode ke dalam sel, buat buku catatan baru.
  • Atau, buka tutorial/get-started-notebooks/train-model.ipynb dari bagian Sampel studio. Lalu pilih Kloning untuk menambahkan buku catatan ke File Anda. Untuk menemukan contoh buku catatan, lihat Pelajari dari contoh buku catatan.

Atur kernel Anda dan buka di Visual Studio Code (Visual Studio Code)

1. Di bilah atas di atas notebook yang Anda buka, buat instans komputasi jika Anda belum memilikinya.

   

2. Jika instans komputasi dihentikan, pilih Mulai komputasi dan tunggu hingga instans berjalan.

   

3. Tunggu hingga instans komputasi berjalan. Kemudian pastikan bahwa kernel, yang ditemukan di kanan atas, adalah Python 3.10 - SDK v2. Jika tidak, gunakan daftar dropdown untuk memilih kernel ini.

   

   Jika Anda tidak melihat kernel ini, verifikasi bahwa instans komputasi Anda sedang berjalan. Jika ya, pilih tombol Refresh di kanan atas buku catatan.

4. Jika Anda melihat banner yang mengatakan Bahwa Anda perlu diautentikasi, pilih Autentikasi.

5. Anda dapat menjalankan buku catatan di sini, atau membukanya di VISUAL Code untuk lingkungan pengembangan terintegrasi penuh (IDE) dengan kekuatan sumber daya Azure Pembelajaran Mesin. Pilih Buka di Visual Studio Code, lalu pilih opsi web atau desktop. Saat diluncurkan dengan cara ini, VISUAL Code dilampirkan ke instans komputasi Anda, kernel, dan sistem file ruang kerja.

   

Menggunakan pekerjaan perintah untuk melatih model di Azure Pembelajaran Mesin

Untuk melatih model, Anda perlu mengirimkan pekerjaan. Azure Pembelajaran Mesin menawarkan beberapa jenis pekerjaan yang berbeda untuk melatih model. Pengguna dapat memilih metode pelatihan mereka berdasarkan kompleksitas model, ukuran data, dan persyaratan kecepatan pelatihan. Dalam tutorial ini, Anda mempelajari cara mengirimkan pekerjaan perintah untuk menjalankan skrip pelatihan.

Pekerjaan perintah adalah fungsi yang memungkinkan Anda mengirimkan skrip pelatihan kustom untuk melatih model Anda. Pekerjaan ini juga dapat didefinisikan sebagai pekerjaan pelatihan kustom. Pekerjaan perintah di Azure Pembelajaran Mesin adalah jenis pekerjaan yang menjalankan skrip atau perintah di lingkungan tertentu. Anda dapat menggunakan pekerjaan perintah untuk melatih model, memproses data, atau kode kustom lainnya yang ingin Anda jalankan di cloud.

Tutorial ini berfokus pada penggunaan pekerjaan perintah untuk membuat pekerjaan pelatihan kustom yang Anda gunakan untuk melatih model. Setiap pekerjaan pelatihan kustom memerlukan item berikut:

• lingkungan
• data
• pekerjaan perintah
• skrip pelatihan

Tutorial ini menyediakan item-item ini untuk contoh: membuat pengklasifikasi untuk memprediksi pelanggan yang memiliki kemungkinan default yang tinggi pada pembayaran kartu kredit.

Membuat handel ke ruang kerja

Sebelum Anda menyelami kode, Anda memerlukan cara untuk mereferensikan ruang kerja Anda. Buat ml_client untuk handel ke ruang kerja. Kemudian gunakan ml_client untuk mengelola sumber daya dan pekerjaan.

Di sel berikutnya, masukkan ID langganan, nama grup sumber daya, dan nama ruang kerja Anda. Untuk menemukan nilai-nilai ini:

1. Di toolbar studio Azure Machine Learning, di kanan atas, pilih nama ruang kerja Anda.
2. Salin nilai untuk ruang kerja, grup sumber daya, dan ID langganan ke dalam kode. Anda perlu menyalin satu nilai, menutup area dan menempelkan, lalu kembali untuk nilai berikutnya.

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

SUBSCRIPTION="<SUBSCRIPTION_ID>"
RESOURCE_GROUP="<RESOURCE_GROUP>"
WS_NAME="<AML_WORKSPACE_NAME>"
# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id=SUBSCRIPTION,
    resource_group_name=RESOURCE_GROUP,
    workspace_name=WS_NAME,
)

# Verify that the handle works correctly.
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

Membuat lingkungan pekerjaan

Untuk menjalankan pekerjaan Azure Pembelajaran Mesin di sumber daya komputasi, Anda memerlukan lingkungan. Lingkungan mencantumkan runtime dan pustaka perangkat lunak yang ingin Anda instal pada komputasi tempat melakukan pelatihan. Ini mirip dengan lingkungan python di komputer lokal Anda. Untuk informasi selengkapnya, lihat Apa itu lingkungan Azure Pembelajaran Mesin?

Azure Pembelajaran Mesin menyediakan banyak lingkungan yang dikumpulkan atau siap pakai yang berguna untuk skenario pelatihan dan inferensi umum.

Dalam contoh ini, Anda membuat lingkungan conda kustom untuk pekerjaan Anda, menggunakan file yaml conda.

Pertama, buat direktori untuk menyimpan file.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Sel berikutnya menggunakan sihir IPython untuk menulis file conda ke direktori yang Anda buat.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

Spesifikasi berisi beberapa paket biasa yang Anda gunakan dalam pekerjaan Anda, seperti numpy dan pip.

Referensikan file yaml ini untuk membuat dan mendaftarkan lingkungan kustom ini di ruang kerja Anda:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

print(
    f"Environment with name {custom_job_env.name} is registered to workspace, the environment version is {custom_job_env.version}"
)

Mengonfigurasi pekerjaan pelatihan menggunakan fungsi perintah

Anda membuat pekerjaan perintah Azure Pembelajaran Mesin untuk melatih model untuk prediksi default kredit. Pekerjaan perintah menjalankan skrip pelatihan di lingkungan tertentu pada sumber daya komputasi tertentu. Anda sudah membuat lingkungan dan kluster komputasi. Selanjutnya, buat skrip pelatihan. Dalam hal ini, Anda melatih himpunan data untuk menghasilkan pengklasifikasi GradientBoostingClassifier menggunakan model.

Skrip pelatihan menangani persiapan data, pelatihan, dan pendaftaran model terlatih. Metode train_test_split ini membagi himpunan data menjadi data pengujian dan pelatihan. Dalam tutorial ini, Anda membuat skrip pelatihan Python.

Pekerjaan perintah dapat dijalankan dari antarmuka CLI, Python SDK, atau studio. Dalam tutorial ini, gunakan Azure Pembelajaran Mesin Python SDK v2 untuk membuat dan menjalankan pekerjaan perintah.

Membuat skrip pelatihan

Mulailah dengan membuat skrip pelatihan: file python main.py . Pertama-tama buat folder sumber untuk skrip:

import os

train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)

Skrip ini melakukan praproses data, membaginya menjadi data pengujian dan pelatihan. Kemudian menggunakan data untuk melatih model berbasis pohon dan mengembalikan model output.

MLFlow digunakan untuk mencatat parameter dan metrik selama pekerjaan ini. Paket MLFlow memungkinkan Anda melacak metrik dan hasil untuk setiap model yang dilatih Azure. Gunakan MLFlow untuk mendapatkan model terbaik untuk data Anda. Kemudian lihat metrik model di studio Azure. Untuk informasi selengkapnya, lihat MLflow dan Azure Pembelajaran Mesin.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_csv(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    #Split train and test datasets
    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Dalam skrip ini, setelah model dilatih, file model disimpan dan didaftarkan ke ruang kerja. Mendaftarkan model memungkinkan Anda menyimpan dan membuat versi model Anda di cloud Azure, di ruang kerja Anda. Setelah mendaftarkan model, Anda dapat menemukan semua model terdaftar lainnya di satu tempat di Azure Studio yang disebut registri model. Registri model membantu Anda mengatur dan melacak model terlatih Anda.

Mengonfigurasi perintah

Sekarang setelah Anda memiliki skrip yang dapat melakukan tugas klasifikasi, gunakan perintah tujuan umum yang dapat menjalankan tindakan baris perintah. Tindakan baris perintah ini dapat langsung memanggil perintah sistem atau dengan menjalankan skrip.

Buat variabel input untuk menentukan data input, rasio pemisahan, tingkat pembelajaran, dan nama model terdaftar. Skrip perintah:

• Menggunakan lingkungan yang dibuat sebelumnya. @latest Gunakan notasi untuk menunjukkan versi terbaru lingkungan saat perintah dijalankan.
• Mengonfigurasi tindakan baris perintah itu sendiri, python main.py dalam hal ini. Anda dapat mengakses input dan output dalam perintah dengan menggunakan ${{ ... }} notasi.
• Karena sumber daya komputasi tidak ditentukan, skrip berjalan pada kluster komputasi tanpa server yang dibuat secara otomatis.

from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="aml-scikit-learn@latest",
    display_name="credit_default_prediction",
)

Mengirimkan pekerjaan

Kirim pekerjaan untuk dijalankan di studio Azure Pembelajaran Mesin. Kali ini, gunakan create_or_update pada ml_client. ml_clientadalah kelas klien yang memungkinkan Anda menyambungkan ke langganan Azure menggunakan Python dan berinteraksi dengan layanan Azure Pembelajaran Mesin. ml_client memungkinkan Anda untuk mengirimkan pekerjaan Anda menggunakan Python.

ml_client.create_or_update(job)

Lihat output pekerjaan dan tunggu penyelesaian pekerjaan

Untuk melihat pekerjaan di studio Azure Pembelajaran Mesin, pilih tautan dalam output sel sebelumnya. Output pekerjaan ini terlihat seperti ini di studio Azure Pembelajaran Mesin. Jelajahi tab untuk berbagai detail seperti metrik, output, dll. Setelah pekerjaan selesai, ia mendaftarkan model di ruang kerja Anda sebagai hasil dari pelatihan.

Saat Anda menjalankan sel, output buku catatan memperlihatkan tautan ke halaman detail pekerjaan di studio Pembelajaran Mesin. Atau, Anda juga dapat memilih Pekerjaan di menu navigasi kiri.

Pekerjaan adalah pengelompokan eksekusi dari skrip atau sepotong kode tertentu yang banyak. Informasi untuk eksekusi disimpan pada pekerjaan. Halaman detail memberikan gambaran umum tentang pekerjaan, waktu yang diperlukan untuk dijalankan, kapan dibuat, dan informasi lainnya. Halaman ini juga memiliki tab ke informasi lain tentang pekerjaan seperti metrik, Output + log, dan kode. Berikut adalah tab yang tersedia di halaman detail pekerjaan:

• Gambaran umum: Informasi dasar tentang pekerjaan, termasuk statusnya, waktu mulai dan berakhir, dan jenis pekerjaan yang dijalankan
• Input: Data dan kode yang digunakan sebagai input untuk pekerjaan. Bagian ini dapat mencakup himpunan data, skrip, konfigurasi lingkungan, dan sumber daya lain yang digunakan selama pelatihan.
• Output + log: Log yang dihasilkan saat pekerjaan sedang berjalan. Tab ini membantu pemecahan masalah jika ada yang salah dengan skrip pelatihan atau pembuatan model Anda.
• Metrik: Metrik performa utama dari model Anda seperti skor pelatihan, skor f1, dan skor presisi.

Membersihkan sumber daya

Jika Anda berencana untuk melanjutkan sekarang ke tutorial lain, lewati ke Konten terkait.

Menghentikan instans komputasi

Jika Anda tidak akan menggunakannya sekarang, hentikan instans komputasi:

1. Di studio, di area navigasi kiri, pilih Komputasi.
2. Di tab atas, pilih Instans komputasi.
3. Pilih instans komputasi dalam daftar.
4. Di toolbar atas, pilih Hentikan.

Menghapus semua sumber daya

Jika Anda tidak berencana menggunakan sumber daya yang sudah Anda buat, hapus sehingga Anda tidak dikenakan biaya apa pun:

1. Di portal Azure, di kotak pencarian, masukkan Grup sumber daya dan pilih dari hasil.

2. Dari daftar, pilih grup sumber daya yang Anda buat.

3. Di halaman Gambaran Umum , pilih Hapus grup sumber daya.

   

4. Masukkan nama grup sumber daya. Kemudian pilih Hapus.

Konten terkait

Pelajari tentang menyebarkan model:

Tutorial ini menggunakan file data online. Untuk mempelajari selengkapnya tentang cara lain untuk mengakses data, lihat Tutorial: Mengunggah, mengakses, dan menjelajahi data Anda di Azure Pembelajaran Mesin.

ML otomatis adalah alat tambahan untuk mengurangi jumlah waktu yang dihabiskan ilmuwan data untuk menemukan model yang paling sesuai dengan data mereka. Untuk informasi selengkapnya, lihat Apa itu pembelajaran mesin otomatis.

Jika Anda ingin contoh lainnya yang mirip dengan tutorial ini, lihat Pelajari dari contoh buku catatan. Sampel ini tersedia di halaman contoh GitHub. Contohnya termasuk Buku Catatan Python lengkap yang bisa Anda jalankan kodenya dan pelajari cara melatih model. Anda dapat memodifikasi dan menjalankan skrip yang ada dari sampel, yang berisi skenario termasuk klasifikasi, pemrosesan bahasa alami, dan deteksi anomali.