Membuat dan menjalankan alur pembelajaran mesin menggunakan komponen dengan Azure Pembelajaran Mesin SDK v2

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

Dalam artikel ini, Anda mempelajari cara membuat alur Azure Machine Learning menggunakan Python SDK v2 untuk menyelesaikan tugas klasifikasi gambar yang 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, bukan infrastruktur dan otomatisasi.

Contoh tersebut melatih jaringan saraf konvolusional Keras kecil untuk mengklasifikasikan gambar dalam himpunan data Fashion MNIST. Alur terlihat seperti berikut.

Di artikel ini, Anda menyelesaikan tugas-tugas berikut:

• Siapkan data input untuk pekerjaan alur
• Membuat tiga komponen untuk menyiapkan data, melatih, dan menilai
• Buat Alur dari komponen
• Mendapatkan akses ke ruang kerja dengan komputasi
• Mengirimkan pekerjaan alur
• Tinjau output dari komponen dan jaringan saraf yang terlatih
• (Opsional) Daftarkan komponen untuk digunakan kembali dan dibagikan 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 sekarang.

Prasyarat

• Ruang kerja Azure Pembelajaran Mesin - jika Anda tidak memilikinya, selesaikan tutorial Membuat sumber daya.

• Lingkungan Python tempat Anda memasang Azure Machine Learning Python SDK v2 - petunjuk pemasangan - periksa bagian 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 contoh repositori

  Untuk menjalankan contoh pelatihan, pertama-tama kloning repositori contoh dan ubah ke direktori sdk:

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

Memulai sesi Python interaktif

Artikel ini menggunakan Python SDK untuk Azure Pembelajaran Mesin untuk membuat dan mengontrol alur Azure Pembelajaran Mesin. Artikel tersebut mengasumsikan bahwa Anda akan menjalankan cuplikan kode secara interaktif di lingkungan Python REPL atau notebook Jupyter.

Artikel ini didasarkan pada buku catatan image_classification_keras_minist_convnet.ipynb yang ditemukan di sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet direktori repositori Contoh Pembelajaran Mesin Azure.

Mengimpor pustaka yang diperlukan

Impor semua perpustakaan yang diperlukan Azure Machine Learning yang Anda perlukan 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 ini.

Fashion-MNIST adalah himpunan data gambar mode yang dibagi menjadi 10 kelas. Setiap gambar adalah gambar skala abu-abu berukuran 28x28, dan ada 60.000 pelatihan serta 10.000 gambar uji. Sebagai masalah klasifikasi gambar, Fashion-MNIST lebih sulit daripada database digit tulisan tangan MNIST klasik. Ini didistribusikan dalam bentuk biner terkompresi yang sama dengan basis data digit tulisan tangan asli.

Impor semua pustaka azure Pembelajaran Mesin diperlukan yang akan Anda butuhkan.

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.

Buat komponen untuk membangun alur

Tugas klasifikasi citra dapat dibagi menjadi tiga langkah: menyiapkan data, melatih model, dan model skor.

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

• Siapkan data untuk pelatihan dan pengujian
• Melatih jaringan neural untuk klasifikasi gambar menggunakan data pelatihan
• Skor model menggunakan data uji

Untuk setiap komponen, Anda perlu menyiapkan hal berikut:

1. Siapkan skrip Python yang berisi logika eksekusi

2. Menentukan antarmuka komponen

3. Tambahkan metadata lain dari komponen, termasuk lingkungan run-time, perintah untuk menjalankan komponen, dan lain-lain.

Bagian berikutnya akan menampilkan komponen buat dengan dua cara berbeda: dua komponen pertama menggunakan fungsi Python dan komponen ketiga menggunakan definisi YAML.

Buat komponen persiapan data

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

Jika Anda mengikuti contoh dalam repositori contoh Azure Pembelajaran Mesin, file sumber sudah tersedia di prep/ folder. Folder ini berisi dua file untuk membuat komponen: prep_component.py, yang mendefinisikan komponen dan conda.yaml, yang menentukan lingkungan waktu proses komponen.

Menentukan komponen menggunakan fungsi Python

Dengan menggunakan command_component() fungsi sebagai dekorator, Anda dapat dengan mudah menentukan antarmuka, metadata, dan kode komponen untuk dijalankan dari fungsi Python. Setiap fungsi Python yang didekorasi akan 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 di atas mendefinisikan komponen dengan nama tampilan Prep Data menggunakan @command_component dekorator:

• name adalah pengidentifikasi unik komponen.

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

• display_name adalah nama tampilan komponen yang ramah di UI, yang tidak unik.

• description biasanya menjelaskan tugas apa yang dapat diselesaikan oleh komponen ini.

• environment menentukan lingkungan waktu proses untuk komponen ini. Lingkungan komponen ini menentukan gambar buruh pelabuhan dan merujuk ke file conda.yaml.

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

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

• Fungsi prepare_data_component mendefinisikan satu masukan untuk input_data dan dua keluaran untuk training_data dan test_data. input_data adalah jalur data masukan. training_data dan test_data adalah jalur data keluaran untuk data latih dan data uji.

• Komponen ini mengubah data dari input_data menjadi csv data pelatihan menjadi training_data dan csv data pengujian menjadi test_data.

Berikut adalah tampilan komponen di UI studio.

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

Sekarang, Anda telah menyiapkan semua file sumber untuk komponen Prep Data.

Buat komponen model kereta

Di bagian ini, Anda akan membuat komponen untuk melatih model klasifikasi gambar dalam fungsi Python seperti Prep Data komponen.

Perbedaannya adalah karena logika pelatihan lebih rumit, Anda dapat meletakkan kode pelatihan asli dalam file Python yang terpisah.

File sumber komponen ini berada di bawah train/ folder dalam repositori contoh Azure Pembelajaran Mesin. Folder ini berisi tiga file untuk membuat komponen:

• train.py: berisi logika aktual untuk melatih model.
• train_component.py: mendefinisikan antarmuka komponen dan mengimpor fungsi di train.py.
• conda.yaml: mendefinisikan lingkungan waktu proses komponen.

Dapatkan skrip yang berisi logika eksekusi

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

Menentukan komponen menggunakan fungsi Python

Setelah berhasil menentukan fungsi pelatihan, Anda dapat menggunakan @command_component di Azure Pembelajaran Mesin SDK v2 untuk membungkus fungsi Anda sebagai komponen, yang dapat digunakan di alur Azure Pembelajaran Mesin.

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 di atas mendefinisikan komponen dengan nama tampilan Train Image Classification Keras menggunakan @command_component:

• Fungsi keras_train_component mendefinisikan satu masukan input_data tempat asal data pelatihan, satu masukan epochs yang menentukan epoch selama pelatihan, dan satu keluaran output_model tempat mengeluarkan file model. Nilai default epochs adalah 10. Logika eksekusi komponen ini berasal dari fungsi train() di train.py atas.

Komponen train-model memiliki konfigurasi yang sedikit lebih kompleks daripada komponen prep-data. conda.yaml adalah seperti berikut:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.7.11
  - 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

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

Buat komponen model skor

Di bagian ini, selain komponen sebelumnya, Anda akan membuat komponen untuk menilai model terlatih melalui spesifikasi dan skrip Yaml.

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

• score.py: berisi kode sumber komponen.
• score.yaml: mendefinisikan antarmuka dan detail komponen lainnya.
• conda.yaml: mendefinisikan lingkungan waktu proses komponen.

Dapatkan skrip yang berisi logika eksekusi

File score.py berisi fungsi Python normal, yang melakukan logika model pelatihan.

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 di score.py membutuhkan tiga argumen baris perintah: input_data, input_model dan output_result. Program menskor model input menggunakan data masukan dan kemudian mengeluarkan hasil penskoran.

Tentukan komponen melalui Yaml

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

• Metadata: nama, display_name, versi, jenis, dan sebagainya.
• Antarmuka: input dan output
• Perintah, kode & 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 sumbernya ditentukan di bagian code dan saat komponen dijalankan di cloud, semua file dari jalur itu akan diunggah sebagai cuplikan komponen ini.
• Bagian command menentukan perintah yang akan dijalankan saat menjalankan komponen ini.
• Bagian environment berisi gambar buruh pelabuhan dan file conda yaml. File sumber ada di repositori contoh.

Sekarang, Anda memiliki semua file sumber untuk komponen model skor.

Muat komponen untuk membangun alur

Untuk komponen prep-data dan komponen train-model yang ditentukan oleh fungsi Python, Anda dapat mengimpor komponen seperti fungsi Python normal.

Dalam kode berikut, Anda mengimpor fungsi prepare_data_component() dan keras_train_component() dari file prep_component.py di bawah folder prep dan file train_component di bawah 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)

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

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

Bangun alur Anda

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

Catatan

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

• default_compute=cpu_compute_target,dengandefault_compute="serverless",
• train_node.compute = gpu_compute_targetdengantrain_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 memiliki komputasi default cpu_compute_target, yang berarti jika Anda tidak menentukan komputasi untuk node tertentu, node tersebut akan berjalan pada komputasi default.

Alur memiliki input level alur pipeline_input_data. Anda dapat menetapkan nilai ke input alur saat mengirimkan tugas alur.

Alur berisi tiga node, prepare_data_node, train_node dan score_node.

• input_data dari prepare_data_node menggunakan nilai pipeline_input_data.

• input_data dari train_node berasal dari training_data keluaran dari prepare_data_node.

• input_data dari score_node berasal dari test_data output dari prepare_data_node, dan input_model dari output_model train_node.

• Karena train_node akan melatih model CNN, Anda dapat menentukan komputasinya sebagai gpu_compute_target, yang dapat meningkatkan kinerja pelatihan.

Kirim pekerjaan alur Anda

Sekarang Anda telah membangun alur, Anda dapat mengirimkan ke ruang kerja Anda. Untuk mengirimkan pekerjaan, Anda harus terlebih dahulu terhubung ke ruang kerja.

Dapatkan akses ke ruang kerja Anda

Konfigurasikan kredensial

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

Referensi untuk kredensial lainnya yang tersedia jika tidak berfungsi untuk Anda: konfigurasi contoh kredensial, dokumen referensi identitas-azure.

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

Dapatkan pegangan ke ruang kerja dengan komputasi

Buat objek MLClient untuk mengelola layanan Azure Machine Learning. Jika Anda menggunakan komputasi tanpa server maka 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 terkait pembuatan ruang kerja, lihat Membuat sumber daya ruang kerja. Untuk informasi selengkapnya tentang menyimpan konfigurasi ke file, lihat Membuat file konfigurasi ruang kerja.

Kirim pekerjaan alur ke ruang kerja

Sekarang Anda memiliki pegangan untuk ruang kerja Anda, Anda dapat mengirimkan pekerjaan alur Anda.

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

Kode di atas mengirimkan pekerjaan alur klasifikasi gambar ini ke eksperimen yang disebut pipeline_samples. Ini akan membuat eksperimen secara otomatis jika tidak ada. pipeline_input_data menggunakan fashion_ds.

Panggilan ke pipeline_jobmenghasilkan keluaran yang mirip dengan:

Panggilan untuk submitExperiment selesai dengan cepat, dan menghasilkan output yang mirip dengan:

Percobaan	Nama	Tipe	Keadaan	Halaman Detail
pipeline_samples	sharp_pipe_4gvqx6h1fb	Alur	Mempersiapkan	Tautan ke studio Azure Machine Learning.

Anda dapat memantau alur yang dijalankan dengan membuka tautan atau Anda dapat memblokir hingga selesai dengan menjalankan:

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

Penting

Eksekusi alur pertama memakan waktu sekitar 15 menit. Semua dependensi harus diunduh, gambar Docker dibuat, dan lingkungan Python diprovisikan dan dibuat. Menjalankan alur lagi membutuhkan waktu yang jauh lebih sedikit karena sumber daya tersebut digunakan kembali daripada dibuat. Namun, durasi untuk alur bergantung pada beban kerja skrip Anda dan proses yang berjalan di setiap langkah alur.

Keluarkan keluaran dan debug alur Anda di UI

Anda dapat membuka Link to Azure Machine Learning studio, yang merupakan laman detail pekerjaan alur Anda. Anda akan melihat grafik alur seperti berikut.

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 Cara menggunakan kegagalan alur debug.

(Opsional) Daftarkan komponen ke ruang kerja

Di bagian sebelumnya, Anda telah membangun alur menggunakan tiga komponen untuk E2E menyelesaikan tugas klasifikasi gambar. Anda juga dapat mendaftarkan komponen ke ruang kerja Anda sehingga dapat dibagikan dan dilanjutkan di dalam ruang kerja. Berikut ini adalah contoh untuk mendaftarkan komponen prep-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)

Menggunakan ml_client.components.get(), Anda bisa mendapatkan komponen terdaftar berdasarkan nama dan versi. Menggunakan ml_client.components.create_or_update(), Anda dapat mendaftarkan komponen yang sebelumnya dimuat dari fungsi Python atau yaml.

Langkah berikutnya

• Untuk contoh lebih lanjut mengenai cara membangun alur dengan menggunakan SDK pembelajaran mesin, lihat repositori contoh.
• Untuk cara menggunakan UI studio untuk mengirim dan men-debug alur Anda, lihat cara membuat alur menggunakan komponen di UI.
• Untuk cara menggunakan Azure Machine Learning CLI untuk membuat komponen dan alur, lihat cara membuat alur menggunakan komponen dengan CLI.
• Untuk cara menyebarkan alur ke dalam produksi menggunakan Titik Akhir Batch, lihat cara menyebarkan alur dengan titik akhir batch.