Tutorial: Membuat alur pembelajaran mesin produksi

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

Catatan

Untuk tutorial yang menggunakan SDK v1 untuk membangun saluran, lihat Tutorial: Membuat alur Azure Machine Learning untuk klasifikasi gambar

Inti dari alur pembelajaran mesin adalah untuk membagi tugas pembelajaran mesin lengkap menjadi alur kerja dengan beberapa langkah. Setiap langkah adalah komponen yang dapat dikelola yang dapat dikembangkan, dioptimalkan, dikonfigurasi, dan diotomatisasi satu per satu. Langkah-langkah terhubung melalui antarmuka yang terdefinisi dengan baik. Layanan alur Azure Machine Learning secara otomatis mengatur semua dependensi antar langkah alur. Manfaat menggunakan alur adalah standar praktik MLOps, kolaborasi tim yang dapat diskalakan, efisiensi pelatihan, dan pengurangan biaya. Untuk mempelajari selengkapnya tentang manfaat alur, lihat Apa itu alur Azure Pembelajaran Mesin.

Dalam tutorial ini, Anda menggunakan Azure Pembelajaran Mesin untuk membuat proyek pembelajaran mesin siap produksi, menggunakan Azure Pembelajaran Mesin Python SDK v2.

Ini berarti Anda akan dapat memanfaatkan Azure Pembelajaran Mesin Python SDK untuk:

• Mendapatkan handel ke ruang kerja Azure Pembelajaran Mesin Anda
• Membuat aset data Azure Machine Learning
• Membuat komponen Azure Pembelajaran Mesin yang dapat digunakan kembali
• Membuat, memvalidasi, dan menjalankan alur Azure Pembelajaran Mesin

Selama tutorial ini, Anda membuat alur Azure Pembelajaran Mesin untuk melatih model untuk prediksi default kredit. Alur menangani dua langkah:

1. Penyiapan data
2. Melatih dan mendaftarkan model terlatih

Gambar berikutnya memperlihatkan alur sederhana karena Anda akan melihatnya di studio Azure setelah dikirimkan.

Kedua langkah tersebut adalah pertama, penyiapan data dan kedua, pelatihan.

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

1. 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.

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

3. Selesaikan tutorial Mengunggah, mengakses, dan menjelajahi data Anda untuk membuat aset data yang Anda butuhkan dalam tutorial ini. Pastikan Anda menjalankan semua kode untuk membuat aset data awal. Jelajahi data dan revisi jika mau, tetapi Anda hanya memerlukan data awal dalam tutorial ini.

4. 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/pipeline.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.

   

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.

Menyiapkan sumber daya alur

Kerangka kerja Azure Pembelajaran Mesin dapat digunakan dari antarmuka CLI, Python SDK, atau studio. Dalam contoh ini, Anda menggunakan Azure Pembelajaran Mesin Python SDK v2 untuk membuat alur.

Sebelum membuat alur, Anda memerlukan sumber daya berikut:

• Aset data untuk pelatihan
• Lingkungan perangkat lunak untuk menjalankan alur
• Sumber daya komputasi ke tempat pekerjaan berjalan

Membuat handel ke ruang kerja

Sebelum kami menyelami kode, Anda memerlukan cara untuk mereferensikan ruang kerja Anda. Anda akan membuat ml_client handel ke ruang kerja. Anda kemudian akan menggunakan 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.
3. Anda harus 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,
)

Catatan

Membuat MLClient tidak akan menghubungkan ke ruang kerja. Inisialisasi klien malas, ia akan menunggu untuk pertama kalinya perlu melakukan panggilan (ini akan terjadi di sel kode berikutnya).

Verifikasi koneksi dengan melakukan panggilan ke ml_client. Karena ini adalah pertama kalinya Anda melakukan panggilan ke ruang kerja, Anda mungkin akan diminta untuk mengautentikasi.

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

Mengakses aset data terdaftar

Mulailah dengan mendapatkan data yang sebelumnya Anda daftarkan di Tutorial: Mengunggah, mengakses, dan menjelajahi data Anda di Azure Pembelajaran Mesin.

• Azure Pembelajaran Mesin menggunakan Data objek untuk mendaftarkan definisi data yang dapat digunakan kembali, dan menggunakan data dalam alur.

# get a handle of the data asset and print the URI
credit_data = ml_client.data.get(name="credit-card", version="initial")
print(f"Data asset URI: {credit_data.path}")

Membuat lingkungan kerja untuk langkah-langkah alur

Sejauh ini, Anda telah membuat lingkungan pengembangan pada instans komputasi, mesin pengembangan Anda. Anda juga memerlukan lingkungan untuk digunakan untuk setiap langkah alur. Setiap langkah dapat memiliki lingkungannya sendiri, atau Anda dapat menggunakan beberapa lingkungan umum untuk beberapa langkah.

Dalam contoh ini, Anda membuat lingkungan conda 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)

Sekarang, buat file di direktori dependensi.

%%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=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 2.4.1
    - azureml-mlflow==1.51.0

Spesifikasi berisi beberapa paket biasa, yang Anda gunakan dalam alur Anda (numpy, pip), bersama dengan beberapa paket spesifik Azure Pembelajaran Mesin (azureml-mlflow).

Paket Azure Pembelajaran Mesin tidak wajib untuk menjalankan pekerjaan Azure Pembelajaran Mesin. Namun, menambahkan paket ini memungkinkan Anda berinteraksi dengan Azure Pembelajaran Mesin untuk mencatat metrik dan mendaftarkan model, semuanya di dalam pekerjaan Azure Pembelajaran Mesin. Anda menggunakannya dalam skrip pelatihan nanti dalam tutorial ini.

Gunakan file yaml untuk membuat dan mendaftarkan lingkungan khusus ini di ruang kerja Anda:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

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

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

Membuat alur pelatihan

Sekarang setelah Anda memiliki semua aset yang diperlukan untuk menjalankan alur Anda, saatnya untuk membangun alur itu sendiri.

Alur Azure Pembelajaran Mesin adalah alur kerja ML yang dapat digunakan kembali yang biasanya terdiri dari beberapa komponen. Berikut siklus khas suatu komponen:

• Tulis spesifikasi yaml komponen, atau buat secara terprogram menggunakan ComponentMethod.
• Secara opsional, daftarkan komponen dengan nama dan versi di ruang kerja Anda, agar dapat digunakan kembali dan dibagikan.
• Muat komponen tersebut dari kode alur.
• Terapkan alur menggunakan input, output, dan parameter komponen.
• Kirim alur.

Ada dua cara untuk membuat definisi komponen, terprogram dan yaml. Dua bagian berikutnya memandikan Anda membuat komponen dua arah. Anda dapat membuat dua komponen yang mencoba kedua opsi atau memilih metode pilihan Anda.

Catatan

Dalam tutorial ini untuk kesederhanaan, kita menggunakan komputasi yang sama untuk semua komponen. Namun, Anda dapat mengatur komputasi yang berbeda untuk setiap komponen, misalnya dengan menambahkan baris seperti train_step.compute = "cpu-cluster". Untuk melihat contoh membangun alur dengan komputasi yang berbeda untuk setiap komponen, lihat bagian Pekerjaan alur dasar di tutorial alur cifar-10.

Buat komponen 1: penyiapan data (menggunakan definisi terprogram)

Mari kita mulai dengan membuat komponen pertama. Komponen ini menangani pra-pemrosesan data. Tugas pra-pemrosesan dilakukan dalam file Python data_prep.py .

Pertama, buat folder sumber untuk komponen data_prep:

import os

data_prep_src_dir = "./components/data_prep"
os.makedirs(data_prep_src_dir, exist_ok=True)

Skrip ini melakukan tugas sederhana untuk membagi data menjadi himpunan data latih dan uji. Azure Pembelajaran Mesin memasang himpunan data sebagai folder ke komputasi, oleh karena itu, kami membuat select_first_file fungsi tambahan untuk mengakses file data di dalam folder input yang dipasang.

MLFlow digunakan untuk mencatat parameter dan metrik selama eksekusi alur kami.

%%writefile {data_prep_src_dir}/data_prep.py
import os
import argparse
import pandas as pd
from sklearn.model_selection import train_test_split
import logging
import mlflow


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("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    args = parser.parse_args()

    # Start Logging
    mlflow.start_run()

    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)

    credit_train_df, credit_test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )

    # output paths are mounted as folder, therefore, we are adding a filename to the path
    credit_train_df.to_csv(os.path.join(args.train_data, "data.csv"), index=False)

    credit_test_df.to_csv(os.path.join(args.test_data, "data.csv"), index=False)

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Sekarang setelah Anda memiliki skrip yang dapat melakukan tugas yang diinginkan, buat Azure Pembelajaran Mesin Component darinya.

Gunakan tujuan CommandComponent umum yang dapat menjalankan tindakan baris perintah. Tindakan baris perintah ini dapat langsung memanggil perintah sistem atau menjalankan skrip. Input/output ditentukan pada baris perintah melalui notasi ${{ ... }}.

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

data_prep_component = command(
    name="data_prep_credit_defaults",
    display_name="Data preparation for training",
    description="reads a .xl input, split the input to train and test",
    inputs={
        "data": Input(type="uri_folder"),
        "test_train_ratio": Input(type="number"),
    },
    outputs=dict(
        train_data=Output(type="uri_folder", mode="rw_mount"),
        test_data=Output(type="uri_folder", mode="rw_mount"),
    ),
    # The source folder of the component
    code=data_prep_src_dir,
    command="""python data_prep.py \
            --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} \
            --train_data ${{outputs.train_data}} --test_data ${{outputs.test_data}} \
            """,
    environment=f"{pipeline_job_env.name}:{pipeline_job_env.version}",
)

Secara opsional, daftarkan komponen di ruang kerja untuk digunakan kembali di masa mendatang.

# Now we register the component to the workspace
data_prep_component = ml_client.create_or_update(data_prep_component.component)

# Create (register) the component in your workspace
print(
    f"Component {data_prep_component.name} with Version {data_prep_component.version} is registered"
)

Buat komponen 2: pelatihan (menggunakan definisi yaml)

Komponen kedua yang Anda buat menggunakan data pelatihan dan pengujian, melatih model berbasis pohon dan mengembalikan model output. Gunakan kemampuan pengelogan Azure Pembelajaran Mesin untuk merekam dan memvisualisasikan kemajuan pembelajaran.

Anda menggunakan kelas CommandComponent untuk membuat komponen pertama Anda. Kali ini Anda menggunakan definisi yaml untuk menentukan komponen kedua. Setiap metode memiliki kelebihannya masing-masing. Definisi yaml sebenarnya dapat diperiksa di sepanjang kode, dan akan memberikan pelacakan riwayat yang dapat dibaca. Metode terprogram menggunakan CommandComponent bisa menjadi lebih mudah dengan dokumentasi kelas bawaan dan penyelesaian kode.

Buat direktori untuk komponen ini:

import os

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

Buat skrip pelatihan di direktori:

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


def select_first_file(path):
    """Selects first file in folder, use under assumption there is only one file in folder
    Args:
        path (str): path to directory or file to choose
    Returns:
        str: full path of selected file
    """
    files = os.listdir(path)
    return os.path.join(path, files[0])


# Start Logging
mlflow.start_run()

# enable autologging
mlflow.sklearn.autolog()

os.makedirs("./outputs", exist_ok=True)


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

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--train_data", type=str, help="path to train data")
    parser.add_argument("--test_data", type=str, help="path to test data")
    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")
    parser.add_argument("--model", type=str, help="path to model file")
    args = parser.parse_args()

    # paths are mounted as folder, therefore, we are selecting the file from folder
    train_df = pd.read_csv(select_first_file(args.train_data))

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

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

    # paths are mounted as folder, therefore, we are selecting the file from folder
    test_df = pd.read_csv(select_first_file(args.test_data))

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

    # 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.model, "trained_model"),
    )

    # Stop Logging
    mlflow.end_run()


if __name__ == "__main__":
    main()

Seperti yang Anda lihat dalam skrip pelatihan ini, setelah model dilatih, file model disimpan dan didaftarkan ke ruang kerja. Sekarang Anda dapat menggunakan model terdaftar dalam menyimpulkan titik akhir.

Untuk lingkungan langkah ini, Anda menggunakan salah satu lingkungan Azure Pembelajaran Mesin bawaan (yang dikumpulkan). Tag azureml, memberi tahu sistem untuk menggunakan pencarian nama di lingkungan yang dikurasi. Pertama, buat file yaml yang menjelaskan komponen:

%%writefile {train_src_dir}/train.yml
# <component>
name: train_credit_defaults_model
display_name: Train Credit Defaults Model
# version: 1 # Not specifying a version will automatically update the version
type: command
inputs:
  train_data: 
    type: uri_folder
  test_data: 
    type: uri_folder
  learning_rate:
    type: number     
  registered_model_name:
    type: string
outputs:
  model:
    type: uri_folder
code: .
environment:
  # for this step, we'll use an AzureML curate environment
  azureml://registries/azureml/environments/sklearn-1.0/labels/latest
command: >-
  python train.py 
  --train_data ${{inputs.train_data}} 
  --test_data ${{inputs.test_data}} 
  --learning_rate ${{inputs.learning_rate}}
  --registered_model_name ${{inputs.registered_model_name}} 
  --model ${{outputs.model}}
# </component>

Sekarang buat dan daftarkan komponen. Mendaftarkannya memungkinkan Anda untuk menggunakannya kembali di alur lain. Selain itu, siapa pun yang memiliki akses ke ruang kerja Anda dapat menggunakan komponen terdaftar.

# importing the Component Package
from azure.ai.ml import load_component

# Loading the component from the yml file
train_component = load_component(source=os.path.join(train_src_dir, "train.yml"))

# Now we register the component to the workspace
train_component = ml_client.create_or_update(train_component)

# Create (register) the component in your workspace
print(
    f"Component {train_component.name} with Version {train_component.version} is registered"
)

Membuat alur dari komponen

Sekarang setelah kedua komponen Anda ditentukan dan didaftarkan, Anda dapat mulai menerapkan alur.

Di sini, Anda menggunakan data input, rasio pemisahan, dan nama model terdaftar sebagai variabel input. Kemudian panggil komponen dan hubungkan melalui pengidentifikasi input/outputnya. Output dari setiap langkah dapat diakses melalui properti .outputs.

Fungsi Python yang dikembalikan oleh load_component() bekerja sebagai fungsi Python reguler yang kami gunakan dalam alur untuk memanggil setiap langkah.

Untuk membuat kode alur, Anda menggunakan dekorator tertentu @dsl.pipeline yang mengidentifikasi alur Azure Pembelajaran Mesin. Di dekorator, kita dapat menentukan deskripsi alur dan sumber daya default seperti komputasi dan penyimpanan. Seperti fungsi Python, alur dapat memiliki input. Anda kemudian dapat membuat beberapa instans dari satu alur dengan input yang berbeda.

Di sini, kami menggunakan data input, rasio terpisah dan nama model terdaftar sebagai variabel input. Kami kemudian memanggil komponen dan menghubungkannya melalui pengidentifikasi input/output mereka. Output dari setiap langkah dapat diakses melalui properti .outputs.

# the dsl decorator tells the sdk that we are defining an Azure Machine Learning pipeline
from azure.ai.ml import dsl, Input, Output


@dsl.pipeline(
    compute="serverless",  # "serverless" value runs pipeline on serverless compute
    description="E2E data_perp-train pipeline",
)
def credit_defaults_pipeline(
    pipeline_job_data_input,
    pipeline_job_test_train_ratio,
    pipeline_job_learning_rate,
    pipeline_job_registered_model_name,
):
    # using data_prep_function like a python call with its own inputs
    data_prep_job = data_prep_component(
        data=pipeline_job_data_input,
        test_train_ratio=pipeline_job_test_train_ratio,
    )

    # using train_func like a python call with its own inputs
    train_job = train_component(
        train_data=data_prep_job.outputs.train_data,  # note: using outputs from previous step
        test_data=data_prep_job.outputs.test_data,  # note: using outputs from previous step
        learning_rate=pipeline_job_learning_rate,  # note: using a pipeline input as parameter
        registered_model_name=pipeline_job_registered_model_name,
    )

    # a pipeline returns a dictionary of outputs
    # keys will code for the pipeline output identifier
    return {
        "pipeline_job_train_data": data_prep_job.outputs.train_data,
        "pipeline_job_test_data": data_prep_job.outputs.test_data,
    }

Sekarang gunakan definisi alur Anda untuk membuat instans alur dengan himpunan data Anda, tingkat pembagian pilihan dan nama yang Anda pilih untuk model Anda.

registered_model_name = "credit_defaults_model"

# Let's instantiate the pipeline with the parameters of our choice
pipeline = credit_defaults_pipeline(
    pipeline_job_data_input=Input(type="uri_file", path=credit_data.path),
    pipeline_job_test_train_ratio=0.25,
    pipeline_job_learning_rate=0.05,
    pipeline_job_registered_model_name=registered_model_name,
)

Mengirimkan pekerjaan

Sekarang saatnya untuk mengirimkan pekerjaan untuk dijalankan di Azure Pembelajaran Mesin. Kali ini Anda menggunakan create_or_update pada ml_client.jobs.

Di sini Anda juga meneruskan nama eksperimen. Eksperimen adalah kontainer untuk semua perulangan yang dilakukan seseorang pada proyek tertentu. Semua pekerjaan yang dikirimkan dengan nama eksperimen yang sama akan dicantumkan di samping satu sama lain di studio Azure Pembelajaran Mesin.

Setelah selesai, alur mendaftarkan model di ruang kerja Anda sebagai hasil dari pelatihan.

# submit the pipeline job
pipeline_job = ml_client.jobs.create_or_update(
    pipeline,
    # Project's name
    experiment_name="e2e_registered_components",
)
ml_client.jobs.stream(pipeline_job.name)

Anda dapat melacak kemajuan alur Anda, dengan menggunakan tautan yang dihasilkan di sel sebelumnya. Saat pertama kali memilih tautan ini, Anda mungkin melihat bahwa alur masih berjalan. Setelah selesai, Anda dapat memeriksa hasil setiap komponen.

Klik dua kali komponen Latih Model Default Kredit.

Ada dua hasil penting yang ingin Anda lihat tentang pelatihan:

• Lihat log Anda:

  1. Pilih tab Output+log .
  2. Buka folder ke user_logs>std_log.txt Bagian ini memperlihatkan skrip menjalankan stdout.

• Menampilkan metrik Anda: Pilih tab Metrik . Bagian ini memperlihatkan metrik yang dicatat berbeda. Dalam contoh ini. mlflow autologging, secara otomatis mencatat metrik pelatihan.

  

Menyebarkan model sebagai titik akhir online

Untuk mempelajari cara menyebarkan model Anda ke titik akhir online, lihat Menyebarkan model sebagai tutorial titik akhir online.

Membersihkan sumber daya

Jika Anda berencana untuk melanjutkan sekarang ke tutorial lain, lewati ke Langkah berikutnya.

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

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:

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.

Langkah berikutnya

Pelajari cara Menjadwalkan pekerjaan alur pembelajaran mesin