Mulai Cepat: Memulai Azure Machine Learning

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

Tutorial ini memperkenalkan beberapa fitur yang paling banyak digunakan dari layanan Azure Machine Learning. Anda membuat, mendaftarkan, dan menyebarkan model. Tutorial ini membantu Anda terbiasa dengan konsep inti Azure Pembelajaran Mesin dan penggunaannya yang paling umum.

Dalam panduan memulai cepat ini, Anda melatih, mendaftarkan, dan menyebarkan model pembelajaran mesin menggunakan Azure Machine Learning—semuanya dari notebook Python. Pada akhirnya, Anda akan memiliki titik akhir yang berfungsi yang dapat Anda panggil untuk prediksi.

Anda akan mempelajari cara untuk:

Menjalankan pekerjaan pelatihan pada komputasi cloud yang dapat diskalakan
Mendaftarkan model terlatih Anda
Menyebarkan model sebagai titik akhir online
Menguji titik akhir dengan data sampel

Anda membuat skrip pelatihan untuk menangani persiapan data, melatih, dan mendaftarkan model. Setelah melatih model, Anda menerapkannya sebagai titik akhir, lalu mengakses titik akhir tersebut untuk melakukan inference.

Langkah-langkah yang Anda ambil adalah:

Menyiapkan handel ke ruang kerja Azure Pembelajaran Mesin Anda
Membuat skrip pelatihan Anda
Membuat sumber daya komputasi yang dapat diskalakan, kluster komputasi
Buat dan jalankan tugas perintah yang mengeksekusi skrip pelatihan pada kluster komputasi, yang dikonfigurasi dengan lingkungan tugas yang sesuai.
Melihat output skrip pelatihan Anda
Menyebarkan model yang baru dilatih sebagai titik akhir
Memanggil titik akhir Azure Pembelajaran Mesin untuk inferensi

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/quickstart.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)

Di bilah atas di atas notebook yang Anda buka, buat instans komputasi jika Anda belum memilikinya.
Jika instans komputasi dihentikan, pilih Mulai komputasi dan tunggu hingga instans berjalan.
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.
Jika Anda melihat banner yang mengatakan Bahwa Anda perlu diautentikasi, pilih Autentikasi.
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.

Penting

Sisa tutorial ini berisi sel-sel buku catatan tutorial. Salin dan tempelkan ke buku catatan baru Anda, atau beralihlah ke buku catatan sekarang jika Anda mengkloningnya.

Membuat handel ke ruang kerja

Sebelum menyelami kode, Anda memerlukan cara untuk mereferensikan ruang kerja Anda. Ruang kerja adalah sumber daya tingkat teratas untuk Azure Machine Learning, menyediakan tempat terpusat untuk bekerja dengan semua artefak yang Anda buat saat Anda menggunakan Azure Machine Learning.

Buat ml_client sebagai pegangan ke ruang kerja Anda—klien ini akan mengelola semua sumber daya dan pekerjaan Anda.

Di sel berikutnya, masukkan ID Langganan, nama Grup Sumber Daya, dan Nama ruang kerja Anda. Untuk menemukan nilai-nilai ini:

Di toolbar studio Azure Machine Learning, di kanan atas, pilih nama ruang kerja Anda.
Salin nilai untuk ruang kerja, grup sumber daya, dan ID langganan ke dalam kode.
Salin satu nilai, tutup area, dan tempelkan. Kemudian kembali untuk mengambil nilai berikutnya.

Cuplikan layar: temukan kredensial untuk kode Anda di kanan atas toolbar.

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,
)

Catatan

Membuat MLClient tidak tersambung ke ruang kerja. Inisialisasi klien malas. Ini menunggu sampai perlu melakukan panggilan untuk pertama kalinya. Tindakan ini terjadi di sel kode berikutnya.

# 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 skrip pelatihan

Buat skrip pelatihan, yang merupakan file Python main.py .

Pertama, buat folder sumber untuk skrip:

import os

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

Skrip ini telah memproses data dan membaginya menjadi himpunan data pengujian dan pelatihan. Ini melatih model berbasis pohon dengan menggunakan data ini dan mengembalikan model output.

Selama eksekusi alur, gunakan MLFlow untuk mencatat parameter dan metrik.

Sel berikut menggunakan sihir IPython untuk menulis skrip pelatihan ke direktori yang baru saja Anda buat.

%%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)

    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")

    # pin numpy
    conda_env = {
        'name': 'mlflow-env',
        'channels': ['conda-forge'],
        'dependencies': [
            'python=3.10.15',
            'pip<=21.3.1',
            {
                'pip': [
                    'mlflow==2.17.0',
                    'cloudpickle==2.2.1',
                    'pandas==1.5.3',
                    'psutil==5.8.0',
                    'scikit-learn==1.5.2',
                    'numpy==1.26.4',
                ]
            }
        ],
    }

    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
        conda_env=conda_env,
    )

    # 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()

Saat model dilatih, skrip menyimpan dan mendaftarkan file model ke ruang kerja. Anda dapat menggunakan model yang terdaftar pada titik akhir inferensi.

Anda mungkin perlu memilih Refresh untuk melihat folder dan skrip baru di File Anda.

Cuplikan layar memperlihatkan ikon refresh.

Mengonfigurasi perintah

Anda sekarang memiliki skrip yang dapat melakukan tugas yang diinginkan, dan kluster komputasi untuk menjalankan skrip. Gunakan perintah tujuan umum yang dapat menjalankan tindakan baris perintah. Tindakan baris perintah ini dapat langsung memanggil perintah sistem atau menjalankan skrip.

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

Menggunakan lingkungan yang menentukan pustaka perangkat lunak dan runtime yang diperlukan untuk skrip pelatihan. Azure Pembelajaran Mesin menyediakan banyak lingkungan yang dikumpulkan atau siap pakai, yang berguna untuk skenario pelatihan dan inferensi umum. Anda menggunakan salah satu lingkungan tersebut di sini. Dalam Tutorial: Melatih model di Azure Pembelajaran Mesin, Anda mempelajari cara membuat lingkungan kustom.
Mengonfigurasi tindakan baris perintah itu sendiri - python main.py dalam hal ini. Input dan output dapat diakses dalam perintah melalui ${{ ... }} notasi.
Mengakses data dari file di internet.
Karena Anda tidak menentukan sumber daya komputasi, 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="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    display_name="credit_default_prediction",
)

Mengirimkan pekerjaan

Kirim pekerjaan untuk dijalankan di Azure Machine Learning. Kali ini, gunakan create_or_update pada ml_client.

ml_client.create_or_update(job)

Lihat output pekerjaan dan tunggu penyelesaian pekerjaan

Lihat pekerjaan di studio Azure Pembelajaran Mesin dengan memilih tautan dalam output sel sebelumnya.

Output pekerjaan ini terlihat seperti ini di studio Azure Pembelajaran Mesin. Jelajahi tab untuk berbagai detail seperti metrik, output, dan lainnya. Setelah selesai, tugas mendaftarkan model di ruang kerja Anda sebagai hasil pelatihan.

Cuplikan layar memperlihatkan halaman gambaran umum untuk pekerjaan tersebut.

Penting

Tunggu hingga status pekerjaan menunjukkan Selesai sebelum melanjutkan—biasanya 2-3 menit. Jika kluster komputasi diskalakan ke nol, mungkin memerlukan waktu hingga 10 menit untuk penyediaan.

Saat Anda menunggu, jelajahi detail pekerjaan di studio:

Tab Metrik : Menampilkan metrik pelatihan yang dicatat oleh MLflow
Tab Output + log : Periksa log pelatihan
Tab Model : Lihat model terdaftar (setelah selesai)

Menyebarkan model sebagai titik akhir online

Sebarkan model pembelajaran mesin Anda sebagai layanan web di cloud Azure dengan menggunakan online endpoint.

Untuk menyebarkan layanan pembelajaran mesin, gunakan model yang Anda daftarkan.

Membuat titik akhir online baru

Sekarang setelah Anda mendaftarkan model, buat endpoint online Anda. Nama titik akhir harus unik di seluruh wilayah Azure. Untuk tutorial ini, buat nama unik dengan menggunakan UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Buat titik akhir.

# Expect the endpoint creation to take a few minutes
from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Catatan

Harapkan pembuatan titik akhir memakan waktu beberapa menit.

Setelah membuat titik akhir, ambil titik akhir tersebut seperti yang ditunjukkan dalam kode berikut:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Menyebarkan model ke titik akhir

Setelah Anda membuat titik akhir, sebarkan model dengan menggunakan skrip entri. Setiap titik akhir dapat memiliki beberapa penyebaran. Anda dapat menentukan aturan untuk mengarahkan lalu lintas ke implementasi ini. Dalam contoh ini, Anda membuat penyebaran tunggal yang menangani 100% lalu lintas masuk. Pilih nama warna untuk penyebaran, seperti biru, hijau, atau merah. Pilihannya sembarangan.

Untuk menemukan versi terbaru model terdaftar Anda, periksa halaman Model di studio Azure Machine Learning. Atau, gunakan kode berikut untuk mengambil nomor versi terbaru.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)
print(f'Latest model is version "{latest_model_version}" ')

Sebarkan versi model terbaru.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)

# Expect this deployment to take approximately 6 to 8 minutes.
# create an online deployment.
# if you run into an out of quota error, change the instance_type to a comparable VM that is available.
# Learn more on https://azure.microsoft.com/pricing/details/machine-learning/.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Catatan

Penyebaran ini diperkirakan akan memakan waktu sekitar 6 hingga 8 menit.

Setelah penyebaran selesai, Anda siap untuk mengujinya.

Menguji dengan sampel kueri

Setelah Anda menyebarkan model ke titik akhir, jalankan inferensi dengan menggunakan model.

Buat file permintaan sampel yang mengikuti desain yang diharapkan dalam metode run dalam skrip penilaian.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)

%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}

# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Membersihkan sumber daya

Jika Anda tidak memerlukan titik akhir, hapus untuk berhenti menggunakan sumber daya. Pastikan tidak ada penerapan lain yang menggunakan endpoint sebelum Anda menghapusnya.

Catatan

Harapkan penghapusan lengkap memakan waktu sekitar 20 menit.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Menghentikan instans komputasi

Jika Anda tidak membutuhkannya sekarang, hentikan instans komputasi:

Di studio, di panel kiri, pilih Komputasi.
Di tab atas, pilih Instans komputasi.
Pilih instans komputasi dalam daftar.
Di toolbar atas, pilih Hentikan.

Menghapus semua sumber daya

Penting

Sumber daya yang Anda buat sebagai prasyarat untuk tutorial dan artikel cara penggunaan Azure Machine Learning lainnya.

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

Di portal Azure, di kotak pencarian, masukkan Grup sumber daya dan pilih dari hasil.
Dari daftar, pilih grup sumber daya yang Anda buat.
Di halaman Gambaran Umum , pilih Hapus grup sumber daya.
Masukkan nama grup sumber daya. Kemudian pilih Hapus.

Langkah berikutnya

Melatih model di Azure Pembelajaran Mesin

Jelajahi lebih banyak cara untuk membangun dengan Azure Machine Learning:

Panduan	Deskripsi
Mengunggah, mengakses, dan menjelajahi data Anda	Menyimpan data besar di cloud dan mengaksesnya dari notebook
Pengembangan model di stasiun kerja cloud	Prototipe dan mengembangkan model secara interaktif
Menyebarkan model sebagai titik akhir online	Pelajari konfigurasi penyebaran tingkat lanjut
Membuat alur produksi	Membangun alur kerja ML otomatis yang dapat digunakan kembali

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-01-24

Bagikan melalui

Mulai Cepat: Memulai Azure Machine Learning

Prasyarat

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

Membuat handel ke ruang kerja

Membuat skrip pelatihan

Mengonfigurasi perintah

Mengirimkan pekerjaan

Lihat output pekerjaan dan tunggu penyelesaian pekerjaan

Menyebarkan model sebagai titik akhir online

Membuat titik akhir online baru

Menyebarkan model ke titik akhir

Menguji dengan sampel kueri

Membersihkan sumber daya

Menghentikan instans komputasi

Menghapus semua sumber daya

Langkah berikutnya

Saran dan Komentar

Sumber Daya Tambahan: