Membuat dan menjalankan alur pembelajaran mesin dengan menggunakan komponen dengan 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 dengan menggunakan Azure Machine Learning 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 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:

• Siapkan data input untuk pekerjaan sistem pipeline.
• Buat tiga komponen untuk menyiapkan data, melatih gambar, dan menilai model.
• Buat rangkaian dari komponen.
• Dapatkan akses ke ruang kerja yang memiliki komputasi.
• Mengirimkan pekerjaan alur.
• Tinjau hasil keluaran dari komponen dan jaringan neural yang 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 tempat Anda menginstal Azure Machine Learning Python SDK v2. Untuk petunjuk penginstalan, lihat Memulai. Lingkungan ini untuk menentukan dan mengontrol sumber daya Azure Machine Learning Anda dan terpisah dari lingkungan yang digunakan pada runtime untuk pelatihan.

• Klon dari repositori contoh.

  Untuk menjalankan contoh pelatihan, pertama-tama klon repositori contoh dan buka 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 ditulis berdasarkan asumsi bahwa Anda akan menjalankan cuplikan kode secara interaktif di lingkungan Python REPL atau notebook Jupyter.

Artikel ini didasarkan pada notebook image_classification_keras_minist_convnet.ipynb, yang dapat Anda temukan dalam 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. Sebagai masalah klasifikasi gambar, Fashion MNIST lebih menantang daripada database digit tulisan tangan MNIST klasik. Ini didistribusikan dalam bentuk biner terkompresi yang sama dengan database digit tulisan tangan asli.

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:

• Siapkan data untuk pelatihan dan uji.
• Latih jaringan neural untuk klasifikasi gambar dengan menggunakan data pelatihan.
• Menilai model dengan menggunakan data pengujian.

Untuk setiap komponen, Anda perlu menyelesaikan langkah-langkah berikut:

1. Siapkan skrip Python yang berisi logika eksekusi.

2. Tentukan 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 dengan menggunakan fungsi Python

Dengan menggunakan command_component() fungsi sebagai dekorator, Anda dapat dengan mudah menentukan antarmuka komponen, metadatanya, dan kode 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 sebelumnya mendefinisikan komponen dengan nama tampilan Prep Data dengan menggunakan dekorator @command_component.

• 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 untuk UI. Ini tidak unik.

• description biasanya menjelaskan tugas yang dapat diselesaikan komponen.

• environment menentukan lingkungan runtime untuk komponen. Lingkungan komponen ini menentukan gambar Docker dan mengacu pada conda.yaml file.

  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 prepare_data_component mendefinisikan satu masukan untuk input_data dan dua keluaran untuk training_data dan test_data. input_data adalah jalur data input. training_data dan test_data adalah jalur data keluaran untuk data latih dan data uji.

• Komponen mengonversi data dari input_data menjadi training_data .csv untuk melatih data dan test_data .csv untuk menguji data.

Seperti inilah tampilan komponen di antarmuka pengguna 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.

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

Membuat komponen pelatihan model

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

Karena logika pelatihan lebih rumit, Anda akan 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 yang ada di 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.

Tentukan komponen dengan menggunakan fungsi Python

Setelah menentukan fungsi pelatihan, Anda dapat menggunakan @command_component di Azure Machine Learning SDK v2 untuk membungkus fungsi Anda sebagai komponen yang dapat 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 yang memiliki nama tampilan Train Image Classification Keras dengan menggunakan @command_component.

• Fungsi ini keras_train_component mendefinisikan satu input, input_data, untuk data pelatihan sumber, satu input, epochs, yang menentukan jumlah epoch yang akan digunakan selama pelatihan, dan 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 sedikit 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 menilai model terlatih melalui spesifikasi dan skrip YAML.

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 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 dalam score.py mengambil tiga argumen baris perintah: input_data, , input_modeldan output_result. Program menilai model input dengan menggunakan data input lalu menghasilkan hasilnya.

Tentukan komponen melalui YAML

Di bagian ini, Anda akan 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 . Ketika komponen dijalankan di cloud, semua file dari jalur tersebut akan 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")

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 akan 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_node, dan score_node.

• input_data dari prepare_data_node menggunakan nilai pipeline_input_data.

• input_data dari train_node adalah output training_data dari prepare_data_node.

• Contoh input_data dari score_node adalah test_data output dari prepare_data_node, dan input_model adalah contoh output_model dari train_node.

• Karena train_node melatih model CNN, Anda dapat menentukan komputasinya menjadi gpu_compute_target. Melakukannya dapat meningkatkan performa pelatihan.

Kirim pekerjaan alur Anda

Sekarang setelah Anda membangun 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 akan 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. Ini 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 memblokirnya hingga 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 waktu yang jauh lebih sedikit karena sumber daya tersebut digunakan kembali daripada 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 akan 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 dengan 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 dengan menggunakan SDK pembelajaran mesin, lihat contoh repositori.
• Untuk informasi tentang menggunakan antarmuka pengguna 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 menyebarkan alur ke dalam produksi dengan menggunakan titik akhir batch, lihat Cara menyebarkan alur dengan titik akhir batch.