Membuat dan menjalankan alur pembelajaran mesin dengan menggunakan komponen dengan Azure Machine Learning SDK v2

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

Dalam artikel ini, Anda mempelajari cara membuat alur Azure Machine Learning menggunakan Azure Machine Learning Python SDK v2 untuk menyelesaikan tugas klasifikasi gambar. Alur ini berisi tiga langkah: menyiapkan data, melatih model klasifikasi gambar, dan menilai model. Alur Pembelajaran Mesin mengoptimalkan alur kerja Anda dengan kecepatan, portabilitas, dan penggunaan kembali, sehingga Anda dapat fokus pada pembelajaran mesin alih-alih infrastruktur dan otomatisasi.

Contoh alur kerja melatih jaringan neural konvolusional Keras kecil untuk mengklasifikasikan gambar dalam dataset Fashion MNIST. Alur terlihat seperti ini:

Di artikel ini, Anda menyelesaikan tugas-tugas berikut:

• Menyiapkan data input untuk pekerjaan pipeline
• Membuat tiga komponen untuk menyiapkan data, melatih model, dan menilai model
• Membangun alur dari komponen
• Mendapatkan akses ke ruang kerja yang memiliki komputasi
• Mengirimkan pekerjaan alur
• Tinjau keluaran komponen dan jaringan saraf terlatih
• (Opsional) Daftarkan komponen untuk penggunaan kembali dan berbagi lebih lanjut dalam ruang kerja

Jika Anda tidak memiliki langganan Azure, buat akun gratis sebelum Anda memulai. Coba versi gratis atau berbayar Azure Machine Learning hari ini.

Prasyarat

• Ruang kerja Azure Machine Learning. Jika Anda tidak memilikinya, selesaikan tutorial Buat sumber daya.
• Lingkungan Python dengan Azure Machine Learning Python SDK v2 terinstal. Untuk petunjuk penginstalan, lihat Memulai. Lingkungan ini ditujukan untuk menentukan dan mengontrol sumber daya Azure Machine Learning Anda dan terpisah dari lingkungan yang digunakan saat runtime bahasa umum untuk pelatihan.
• Klon dari repositori contoh.

Untuk menjalankan contoh pelatihan, pertama-tama klon repositori contoh dan navigasikan ke sdk direktori:

git clone --depth 1 https://github.com/Azure/azureml-examples
cd azureml-examples/sdk

Memulai sesi Python interaktif

Artikel ini menggunakan Azure Machine Learning Python SDK untuk membuat dan mengontrol alur Azure Machine Learning. Artikel ini mengasumsikan Anda menjalankan cuplikan kode secara interaktif di lingkungan Python REPL atau notebook Jupyter.

Artikel ini didasarkan pada buku catatan image_classification_keras_minist_convnet.ipynb di direktori sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet di repositori contoh Azure Machine Learning.

Mengimpor pustaka yang diperlukan

Impor semua pustaka Azure Machine Learning yang Anda butuhkan untuk artikel ini:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Siapkan data input untuk pekerjaan alur Anda

Anda perlu menyiapkan data input untuk alur klasifikasi gambar.

Fashion MNIST adalah himpunan data gambar mode yang dibagi menjadi 10 kelas. Setiap gambar merupakan gambar 28 x 28 dalam skala abu-abu. Ada 60.000 gambar pelatihan dan 10.000 gambar pengujian.

import urllib3
import shutil
import gzip
import os
from pathlib import Path
from azure.ai.ml import Input

base_url = "https://azureopendatastorage.blob.core.windows.net/mnist/"
base_dir = Path("mnist")
if not base_dir.exists():
    base_dir.mkdir(parents=True)

c = urllib3.PoolManager()
for target_file in [
    "train-images-idx3-ubyte.gz",
    "train-labels-idx1-ubyte.gz",
    "t10k-images-idx3-ubyte.gz",
    "t10k-labels-idx1-ubyte.gz",
]:
    if (base_dir / target_file[:-3]).exists():
        continue
    with c.request("GET", base_url + target_file, preload_content=False) as resp, open(
        base_dir / target_file, "wb"
    ) as out_file:
        shutil.copyfileobj(resp, out_file)
        resp.release_conn()
    with gzip.open(base_dir / target_file, "rb") as f_in, open(
        base_dir / target_file[:-3], "wb"
    ) as f_out:
        shutil.copyfileobj(f_in, f_out)
    os.unlink(base_dir / target_file)

mnist_ds = Input(path=base_dir.as_posix())

Dengan menentukan Input, Anda membuat referensi ke lokasi sumber data. Data tetap berada di lokasi yang ada, sehingga tidak ada biaya penyimpanan tambahan yang dikeluarkan.

Membuat komponen untuk membangun alur

Tugas klasifikasi gambar dapat dibagi menjadi tiga langkah: menyiapkan data, melatih model, dan menilai model.

Komponen Azure Machine Learning adalah bagian kode mandiri yang menyelesaikan satu langkah dalam alur pembelajaran mesin. Dalam artikel ini, Anda membuat tiga komponen untuk tugas klasifikasi gambar:

• Menyiapkan data untuk pelatihan dan pengujian
• Melatih jaringan neural untuk klasifikasi gambar menggunakan data pelatihan
• Menilai model menggunakan data pengujian

Untuk setiap komponen, Anda menyelesaikan langkah-langkah berikut:

1. Siapkan skrip Python yang berisi logika eksekusi
2. Menentukan antarmuka komponen
3. Tambahkan metadata komponen lainnya, termasuk lingkungan runtime dan perintah untuk menjalankan komponen

Bagian berikutnya menunjukkan cara membuat komponen dengan dua cara. Untuk dua komponen pertama, Anda menggunakan fungsi Python. Untuk komponen ketiga, Anda menggunakan definisi YAML.

Membuat komponen persiapan data

Komponen pertama dalam alur ini mengonversi file fashion_ds data terkompresi menjadi dua file .csv, satu untuk pelatihan dan yang lainnya untuk penilaian. Anda menggunakan fungsi Python untuk menentukan komponen ini.

Jika Anda mengikuti contoh dalam repositori contoh Azure Machine Learning, file sumber sudah tersedia di prep folder . Folder ini berisi dua file untuk membangun komponen: prep_component.py, yang menentukan komponen, dan conda.yaml, yang menentukan lingkungan runtime komponen.

Menentukan komponen menggunakan fungsi Python

command_component() Dengan menggunakan fungsi sebagai dekorator, Anda dapat dengan mudah menentukan antarmuka komponen, metadatanya, dan kode untuk dijalankan dari fungsi Python. Setiap fungsi Python yang didekorasi diubah menjadi spesifikasi statis tunggal (YAML) yang dapat diproses oleh layanan alur.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

Kode sebelumnya mendefinisikan komponen dengan nama tampilan Prep Data menggunakan dekorator @command_component.

• name adalah pengidentifikasi unik komponen

• version adalah versi komponen saat ini. Komponen dapat memiliki beberapa versi

• display_name adalah nama tampilan komponen yang ramah untuk UI

• description menjelaskan tugas yang dapat diselesaikan komponen

• environment menentukan lingkungan runtime untuk komponen menggunakan file conda.yaml

  File conda.yaml berisi semua paket yang digunakan untuk komponen:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• Fungsi ini prepare_data_component mendefinisikan satu input untuk input_data dan dua output untuk training_data dan test_data

  • input_data adalah jalur data input
  • training_data dan test_data merupakan jalur data output untuk data pelatihan dan data pengujian

• Komponen mengonversi data dari input_data menjadi training_data file .csv untuk data pelatihan dan test_data file .csv untuk data pengujian

Di antarmuka pengguna studio, komponen muncul sebagai:

• Blok dalam grafik alur
• input_data, training_data, dan test_data adalah port komponen, yang terhubung ke komponen lain untuk streaming data

Anda sekarang telah menyiapkan semua file sumber untuk komponen.Prep Data

Membuat komponen pelatihan model

Di bagian ini, Anda membuat komponen menggunakan fungsi Python untuk melatih model klasifikasi gambar, seperti yang Anda lakukan dengan komponen Prep Data.

Karena logika pelatihan lebih kompleks, Anda menempatkan kode pelatihan dalam file Python terpisah.

File sumber untuk komponen ini ada di train folder dalam repositori contoh Azure Machine Learning. Folder ini berisi tiga file untuk membuat komponen:

• train.py berisi logika untuk melatih model
• train_component.py menentukan antarmuka komponen dan mengimpor fungsi dari train.py
• conda.yaml menentukan lingkungan runtime komponen

Dapatkan skrip yang berisi logika

File train.py berisi fungsi Python normal yang melakukan logika untuk melatih jaringan neural Keras untuk klasifikasi gambar. Untuk melihat kode, lihat file train.py di GitHub.

Menentukan komponen menggunakan fungsi Python

Setelah menentukan fungsi pelatihan, Anda dapat menggunakan @command_component di Azure Machine Learning SDK v2 untuk membungkus fungsi Anda sebagai komponen untuk digunakan dalam alur Azure Machine Learning:

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

Kode sebelumnya mendefinisikan komponen dengan nama Train Image Classification Keras tampilan menggunakan @command_component.

Fungsi keras_train_component mendefinisikan:

• Satu input, input_data, untuk data pelatihan sumber
• Satu input, epochs, yang menentukan jumlah epoch yang akan digunakan selama proses pelatihan
• Satu output, output_model, yang menentukan jalur output untuk file model

Nilai default epochs adalah 10. Logika komponen ini berasal dari train() fungsi dalam train.py.

Komponen model pelatihan memiliki konfigurasi yang lebih kompleks daripada komponen siapkan data. conda.yaml terlihat seperti ini:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

Anda sekarang telah menyiapkan semua file sumber untuk komponen.Train Image Classification Keras

Membuat komponen penilaian model

Di bagian ini, Anda membuat komponen untuk memberikan skor pada model terlatih menggunakan spesifikasi YAML dan skrip.

Jika Anda mengikuti contoh dalam repositori contoh Azure Machine Learning, file sumber sudah tersedia di score folder . Folder ini berisi tiga file untuk membuat komponen:

• score.py berisi kode sumber komponen
• score.yaml menentukan antarmuka dan detail komponen lainnya
• conda.yaml menentukan lingkungan runtime komponen

Dapatkan skrip yang berisi logika

File score.py berisi fungsi Python normal yang melakukan logika penilaian model:

from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from tensorflow.keras.layers import BatchNormalization
from tensorflow.keras.utils import to_categorical
from keras.callbacks import Callback
from keras.models import load_model

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

    img_rows, img_cols = 28, 28
    input_shape = (img_rows, img_cols, 1)

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

Kode dalam score.py mengambil tiga argumen baris perintah: input_data, , input_modeldan output_result. Program menilai model input menggunakan data input lalu menghasilkan hasilnya.

Tentukan komponen menggunakan YAML

Di bagian ini, Anda mempelajari cara membuat spesifikasi komponen dalam format spesifikasi komponen YAML yang valid. File ini menentukan informasi berikut:

• Metadata: Nama, nama tampilan, versi, jenis, dan sebagainya
• Antarmuka: Masukan dan keluaran
• Perintah, kode, dan lingkungan: Perintah, kode, dan lingkungan yang digunakan untuk menjalankan komponen

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04

• name adalah pengidentifikasi unik komponen. Nama tampilannya adalah Score Image Classification Keras
• Komponen ini memiliki dua input dan satu output
• Jalur kode sumber ditentukan di bagian code . Saat komponen berjalan di cloud, semua file dari jalur tersebut diunggah sebagai rekam jepret komponen
• Bagian command menentukan perintah yang akan dijalankan saat komponen berjalan
• Bagian environment ini berisi citra Docker dan file YAML conda. File sumber berada di repositori sampel

Anda sekarang memiliki semua file sumber untuk komponen penilaian model.

Memuat komponen untuk membangun alur

Anda dapat mengimpor komponen persiapan data dan komponen pelatihan model, yang didefinisikan oleh fungsi Python, sama seperti fungsi Python normal.

Kode berikut mengimpor fungsi prepare_data_component() dan keras_train_component() dari file prep_component.py di folder prep dan file train_component di folder train.

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

Anda dapat menggunakan load_component() fungsi untuk memuat komponen skor, yang ditentukan oleh YAML.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Memuat komponen terdaftar dari ruang kerja

Catatan

Untuk memuat komponen terdaftar dari ruang kerja, Anda harus terlebih dahulu mengonfigurasi koneksi ruang kerja seperti yang dijelaskan di bagian Dapatkan akses ke ruang kerja Anda . Objek ml_client diperlukan untuk operasi berikut.

Jika Anda memiliki komponen yang sudah terdaftar di ruang kerja, Anda dapat memuatnya secara langsung menggunakan metode .ml_client.components.get() Pendekatan ini berguna ketika Anda ingin menggunakan kembali komponen yang sebelumnya didaftarkan oleh Anda atau dibagikan oleh anggota tim lain.

# Load a registered component by name and version
registered_component = ml_client.components.get(
    name="my_registered_component", 
    version="1.0.0"
)

# Load the latest version of a registered component
latest_component = ml_client.components.get(
    name="my_registered_component"
)

Anda dapat mencantumkan semua komponen yang tersedia di ruang kerja Anda untuk menemukan komponen yang Anda butuhkan:

# List all components in the workspace
components = ml_client.components.list()
for component in components:
    print(f"Name: {component.name}, Version: {component.version}")

Setelah dimuat, Anda dapat menggunakan komponen terdaftar dalam alur Anda persis seperti komponen yang dimuat dari file lokal atau fungsi Python.

Bangun alur Anda

Anda telah membuat dan memuat semua komponen dan memasukkan data untuk membangun alur. Anda sekarang dapat menyusunnya ke dalam alur:

Catatan

Untuk menggunakan komputasi tanpa server, tambahkan from azure.ai.ml.entities import ResourceConfiguration ke bagian atas file. Kemudian ganti:

• default_compute=cpu_compute_target dengan default_compute="serverless"
• train_node.compute = gpu_compute_target dengan train_node.resources = ResourceConfiguration(instance_type="Standard_NC6s_v3", instance_count=2)

# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

Alur kerja memiliki komputasi default cpu_compute_target. Jika Anda tidak menentukan komputasi untuk simpul tertentu, simpul tersebut berjalan pada komputasi default.

Saluran memiliki masukan tingkat saluran, pipeline_input_data. Anda dapat menetapkan nilai untuk input alur saat mengirimkan tugas alur.

Alur berisi tiga simpul: prepare_data_node, , train_nodedan score_node:

• Penggunaan input_data dan prepare_data_node menggunakan nilai dari pipeline_input_data
• Output input_data dari train_nodetraining_data adalah output dari prepare_data_node.
• Yang input_data dari score_node adalah test_data output dari prepare_data_node, dan input_model adalah output_model dari train_node
• Karena train_node melatih model CNN, Anda dapat menentukan pengaturan komputasinya dengan gpu_compute_target untuk meningkatkan performa pelatihan.

Kirim pekerjaan alur Anda

Setelah membuat alur, Anda dapat mengirimkan pekerjaan ke ruang kerja Anda. Untuk mengirimkan pekerjaan, Anda harus terlebih dahulu menyambungkan ke ruang kerja.

Dapatkan akses ke ruang kerja Anda

Mengonfigurasi identitas

Anda menggunakan DefaultAzureCredential untuk mendapatkan akses ke ruang kerja. DefaultAzureCredential harus mampu menangani sebagian besar skenario autentikasi Azure SDK.

Jika DefaultAzureCredential tidak berfungsi untuk Anda, lihat contoh kredensial konfigurasi dan Paket identitas ini.

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Mendapatkan pegangan ke ruang kerja yang memiliki sumber daya komputasi

Buat MLClient objek untuk mengelola layanan Azure Machine Learning. Jika Anda menggunakan komputasi tanpa server, Anda tidak perlu membuat komputasi ini.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Penting

Cuplikan kode ini mengharapkan file JSON konfigurasi ruang kerja disimpan di direktori saat ini atau induknya. Untuk informasi selengkapnya tentang membuat ruang kerja, lihat Membuat sumber daya ruang kerja. Untuk informasi selengkapnya tentang menyimpan konfigurasi ke file, lihat Membuat file konfigurasi ruang kerja.

Kirim pekerjaan pipeline ke ruang kerja

Sekarang setelah Anda memiliki kendali atas ruang kerja Anda, Anda dapat mengirimkan pekerjaan pipeline Anda.

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

Kode sebelumnya mengirimkan pekerjaan alur klasifikasi gambar ini ke eksperimen yang disebut pipeline_samples. Ini secara otomatis membuat eksperimen jika eksperimen tersebut belum ada. pipeline_input_data menggunakan fashion_ds.

Panggilan untuk mengirimkan eksperimen selesai dengan cepat dan menghasilkan output yang mirip dengan ini:

Percobaan	Nama	Tipe	Keadaan	Halaman detail
pipeline_samples	sharp_pipe_4gvqx6h1fb	alur	Mempersiapkan	Tautan ke studio Azure Machine Learning

Anda dapat memantau jalannya pipa dengan memilih tautan. Atau Anda dapat menunggunya selesai dengan menjalankan kode ini:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Penting

Eksekusi alur pertama membutuhkan waktu sekitar 15 menit. Semua dependensi diunduh, gambar Docker dibuat, dan lingkungan Python disediakan dan dibuat. Menjalankan alur lagi membutuhkan lebih sedikit waktu karena sumber daya tersebut digunakan kembali alih-alih dibuat. Namun, waktu eksekusi total untuk alur bergantung pada beban kerja skrip Anda dan proses yang berjalan di setiap langkah dalam alur.

Periksa output dan debug alur Anda di UI

Anda dapat memilih Link to Azure Machine Learning studio, yang merupakan halaman detail pekerjaan dari alur Anda. Anda melihat grafik alur:

Anda dapat memeriksa log dan output setiap komponen dengan mengklik kanan komponen, atau memilih komponen untuk membuka panel detailnya. Untuk mempelajari selengkapnya tentang cara men-debug alur Anda di UI, lihat Menggunakan studio Azure Machine Learning untuk men-debug kegagalan alur.

(Opsional) Mendaftarkan komponen ke ruang kerja

Di bagian sebelumnya, Anda membuat alur menggunakan tiga komponen untuk menyelesaikan tugas klasifikasi gambar. Anda juga dapat mendaftarkan komponen ke ruang kerja Anda sehingga dapat dibagikan dan digunakan kembali dalam ruang kerja. Contoh berikut menunjukkan cara mendaftarkan komponen persiapan data:

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

Anda dapat menggunakan ml_client.components.get() untuk mendapatkan komponen terdaftar berdasarkan nama dan versi. Anda dapat menggunakan ml_client.components.create_or_update() untuk mendaftarkan komponen yang sebelumnya dimuat dari fungsi Python atau YAML.

Langkah berikutnya

• Untuk contoh selengkapnya tentang cara membangun alur menggunakan SDK pembelajaran mesin, lihat contoh repositori
• Untuk informasi tentang menggunakan UI studio untuk mengirimkan dan men-debug alur, lihat Membuat dan menjalankan alur pembelajaran mesin menggunakan komponen dengan studio Azure Machine Learning
• Untuk informasi tentang menggunakan Azure Machine Learning CLI untuk membuat komponen dan alur, lihat Membuat dan menjalankan alur pembelajaran mesin menggunakan komponen dengan Azure Machine Learning CLI
• Untuk informasi tentang mengimplementasikan pipeline ke produksi menggunakan batch endpoints, lihat Cara mengimplementasikan pipeline dengan batch endpoints