Tutorial: Membangun alur Azure Machine Learning untuk klasifikasi gambar

  • Artikel

BERLAKU UNTUK:Python SDK azureml v1

Catatan

Untuk tutorial yang menggunakan SDK v2 untuk membangun alur, lihat Tutorial: Menggunakan alur ML untuk alur kerja ML produksi dengan Python SDK v2 di Jupyter Notebook.

Dalam tutorial ini, Anda akan mempelajari cara membuat alur Azure Machine Learning untuk menyiapkan data dan melatih model pembelajaran mesin. 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.

Dalam tutorial ini, Anda menyelesaikan tugas-tugas berikut:

  • Mengonfigurasi ruang kerja
  • Membuat Eksperimen untuk menahan pekerjaan Anda
  • Menentukan ComputeTarget untuk melakukan pekerjaan
  • Membuat Himpunan Data tempat menyimpan data terkompresi
  • Membuat langkah alur guna menyiapkan data untuk pelatihan
  • Menentukan Lingkungan runtime bahasa umum untuk melakukan pelatihan
  • Membuat langkah alur untuk menentukan jaringan saraf dan melakukan pelatihan
  • Menyusun Alur dari langkah-langkah alur
  • Menjalankan alur dalam eksperimen
  • Meninjau output langkah-langkah dan jaringan saraf terlatih
  • Mendaftarkan model untuk penggunaan lebih lanjut

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

Prasyarat

  • Selesaikan Buat sumber daya untuk memulai jika Anda belum memiliki ruang kerja Azure Machine Learning.
  • Lingkungan Python tempat Anda menginstal paket azureml-core dan azureml-pipeline. 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.

Penting

Saat ini, rilis Python terbaru yang kompatibel dengan azureml-pipeline adalah Python 3.8. Jika Anda mengalami kesulitan saat menginstal paket azureml-pipeline, pastikan bahwa python --version adalah rilis yang kompatibel. Konsultasikan dokumentasi manajer lingkungan virtual Python Anda (venv, conda, dan sebagainya) untuk instruksi.

Memulai sesi Python interaktif

Tutorial ini menggunakan Python SDK untuk Azure Machine Learning untuk membuat dan mengontrol alur Azure Machine Learning. Tutorial ini mengasumsikan bahwa Anda akan menjalankan cuplikan kode secara interaktif, baik di lingkungan REPL Python atau di buku catatan Jupyter.

  • Tutorial ini didasarkan pada buku catatan yang image-classification.ipynb ditemukan di python-sdk/tutorial/using-pipelines direktori repositori Contoh Azure Machine Learning . Kode sumber untuk langkah-langkahnya sendiri berada di subdirektori keras-mnist-fashion.

Mengimpor jenis

Impor semua jenis Azure Machine Learning yang Anda perlukan untuk tutorial ini:

import os
import azureml.core
from azureml.core import (
    Workspace,
    Experiment,
    Dataset,
    Datastore,
    ComputeTarget,
    Environment,
    ScriptRunConfig
)
from azureml.data import OutputFileDatasetConfig
from azureml.core.compute import AmlCompute
from azureml.core.compute_target import ComputeTargetException
from azureml.pipeline.steps import PythonScriptStep
from azureml.pipeline.core import Pipeline

# check core SDK version number
print("Azure Machine Learning SDK Version: ", azureml.core.VERSION)

Versi Azure Machine Learning SDK harus 1.37 atau lebih tinggi. Jika bukan versi tersebut, tingkatkan dengan pip install --upgrade azureml-core.

Mengonfigurasi ruang kerja

Buat objek ruang kerja dari ruang kerja Azure Machine Learning yang ada.

workspace = Workspace.from_config()

Penting

Cuplikan kode ini mengharapkan 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.

Membuat infrastruktur untuk alur Anda

Buat objek Experiment untuk menahan hasil alur eksekusi Anda:

exp = Experiment(workspace=workspace, name="keras-mnist-fashion")

Buat ComputeTarget yang mewakili sumber daya mesin tempat alur Anda akan berjalan. Jaringan saraf sederhana yang digunakan dalam tutorial ini melatih hanya dalam beberapa menit, bahkan pada mesin berbasis CPU. Jika Anda ingin menggunakan GPU untuk pelatihan, atur use_gpu ke True. Proses penentuan target komputasi umumnya memakan waktu sekitar lima menit.

use_gpu = False

# choose a name for your cluster
cluster_name = "gpu-cluster" if use_gpu else "cpu-cluster"

found = False
# Check if this compute target already exists in the workspace.
cts = workspace.compute_targets
if cluster_name in cts and cts[cluster_name].type == "AmlCompute":
    found = True
    print("Found existing compute target.")
    compute_target = cts[cluster_name]
if not found:
    print("Creating a new compute target...")
    compute_config = AmlCompute.provisioning_configuration(
        vm_size= "STANDARD_NC6" if use_gpu else "STANDARD_D2_V2"
        # vm_priority = 'lowpriority', # optional
        max_nodes=4,
    )

    # Create the cluster.
    compute_target = ComputeTarget.create(workspace, cluster_name, compute_config)

    # Can poll for a minimum number of nodes and for a specific timeout.
    # If no min_node_count is provided, it will use the scale settings for the cluster.
    compute_target.wait_for_completion(
        show_output=True, min_node_count=None, timeout_in_minutes=10
    )
# For a more detailed view of current AmlCompute status, use get_status().print(compute_target.get_status().serialize())

Catatan

Ketersediaan GPU tergantung pada kuota langganan Azure Anda serta kapasitas Azure. Lihat Mengelola dan meningkatkan kuota sumber daya dengan Azure Machine Learning.

Membuat himpunan data untuk data yang disimpan Azure

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. Fashion-MNIST didistribusikan dalam bentuk biner terkompresi yang sama dengan database digit tulisan tangan asli.

Untuk membuat Dataset yang merujuk data berbasis Web, jalankan:

data_urls = ["https://data4mldemo6150520719.blob.core.windows.net/demo/mnist-fashion"]
fashion_ds = Dataset.File.from_files(data_urls)

# list the files referenced by fashion_ds
print(fashion_ds.to_path())

Kode ini selesai dengan cepat. Data yang mendasarinya tetap berada di sumber daya penyimpanan Azure yang ditentukan dalam array data_urls.

Membuat langkah alur persiapan data

Langkah pertama dalam alur ini akan mengonversi file data terkompresi fashion_ds menjadi himpunan data di ruang kerja Anda sendiri, yang terdiri dari file CSV yang siap digunakan dalam pelatihan. Setelah terdaftar di ruang kerja, kolaborator Anda dapat mengakses data ini untuk kepentingan analisis dan pelatihan sendiri, serta tujuan lain

datastore = workspace.get_default_datastore()
prepared_fashion_ds = OutputFileDatasetConfig(
    destination=(datastore, "outputdataset/{run-id}")
).register_on_complete(name="prepared_fashion_ds")

Kode di atas menentukan himpunan data yang didasarkan pada output dari langkah alur. File yang diproses yang mendasarinya akan dimasukkan ke dalam penyimpanan blob datastore default ruang kerja di jalur yang ditentukan dalam destination. Himpunan data akan didaftarkan di ruang kerja dengan nama prepared_fashion_ds.

Membuat sumber langkah alur

Kode yang telah Anda jalankan sejauh ini telah membuat dan mengontrol sumber daya Azure. Sekarang saatnya untuk menulis kode yang melakukan langkah pertama dalam domain.

Jika Anda mengikuti contoh dalam repositori Contoh Azure Machine Learning, file sumber sudah tersedia sebagai keras-mnist-fashion/prepare.py.

Namun, jika Anda bekerja dari awal sendiri, buat subdirektori bernama keras-mnist-fashion/. Buat file baru, kemudian tambahkan kode berikut ke dalamnya, dan beri nama file prepare.py.

# prepare.py
# Converts MNIST-formatted files at the passed-in input path to a passed-in output path
import os
import sys

# Conversion routine for MNIST binary format
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()

# The MNIST-formatted source
mounted_input_path = sys.argv[1]
# The output directory at which the outputs will be written
mounted_output_path = sys.argv[2]

# Create the output directory
os.makedirs(mounted_output_path, exist_ok=True)

# Convert the training data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/train-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/train-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_train.csv"),
    60000,
)

# Convert the test data
convert(
    os.path.join(mounted_input_path, "mnist-fashion/t10k-images-idx3-ubyte"),
    os.path.join(mounted_input_path, "mnist-fashion/t10k-labels-idx1-ubyte"),
    os.path.join(mounted_output_path, "mnist_test.csv"),
    10000,
)

Kode dalam prepare.py mengambil dua argumen baris perintah: yang pertama ditugaskan ke mounted_input_path, dan yang kedua ke mounted_output_path. Jika subdirektori tersebut tidak ada, panggilan untuk os.makedirs akan membuatnya. Kemudian, program ini akan mengubah data pelatihan dan pengujian, lalu menghasilkan file yang dipisahkan koma ke mounted_output_path.

Menentukan langkah alur

Kembali ke lingkungan Python yang Anda gunakan untuk menentukan alur, jalankan kode ini guna membuat PythonScriptStep untuk kode persiapan Anda:

script_folder = "./keras-mnist-fashion"

prep_step = PythonScriptStep(
    name="prepare step",
    script_name="prepare.py",
    # On the compute target, mount fashion_ds dataset as input, prepared_fashion_ds as output
    arguments=[fashion_ds.as_named_input("fashion_ds").as_mount(), prepared_fashion_ds],
    source_directory=script_folder,
    compute_target=compute_target,
    allow_reuse=True,
)

Panggilan untuk PythonScriptStep menentukan bahwa, saat langkah alur dijalankan:

  • Semua file dalam direktori script_folder akan diunggah ke compute_target
  • Di antara file sumber yang diunggah tersebut, file prepare.py akan dijalankan
  • Himpunan data fashion_ds dan prepared_fashion_ds akan diinstal di compute_target dan muncul sebagai direktori
  • Jalur ke file fashion_ds akan menjadi argumen pertama untuk prepare.py. Pada prepare.py, argumen ini ditetapkan untuk mounted_input_path
  • Jalur menuju prepared_fashion_ds akan menjadi argumen kedua untuk prepare.py. Pada prepare.py, argumen ini ditetapkan untuk mounted_output_path
  • Karena allow_reuse adalah True, argumen tersebut tidak akan dijalankan kembali sampai file sumber atau inputnya berubah
  • PythonScriptStep ini akan diberi nama prepare step

Modularitas dan penggunaan kembali adalah keuntungan utama dari alur. Azure Machine Learning dapat secara otomatis menentukan kode sumber atau perubahan Himpunan Data. Output langkah yang tidak terpengaruh akan digunakan kembali tanpa menjalankan ulang langkah-langkah tersebut lagi jika allow_reuse adalah True. Jika suatu langkah bergantung pada sumber data di luar Azure Machine Learning yang dapat berubah (misalnya, URL yang berisi data penjualan), atur allow_reuse ke False, dan langkah alur akan berjalan setiap kali alur dijalankan.

Membuat langkah pelatihan

Setelah data dikonversi dari format terkompresi ke file CSV, data tersebut dapat digunakan untuk melatih jaringan saraf konvolusional.

Membuat sumber langkah pelatihan

Dengan alur yang lebih besar, sebaiknya tempatkan kode sumber setiap langkah di direktori terpisah (src/prepare/, src/train/, dan sebagainya), tetapi untuk tutorial ini, cukup gunakan atau buat file train.py di direktori sumber keras-mnist-fashion/ yang sama.

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

import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from azureml.core import Run

# dataset object from the run
run = Run.get_context()
dataset = run.input_datasets["prepared_fashion_ds"]

# split dataset into train and test set
(train_dataset, test_dataset) = dataset.random_split(percentage=0.8, seed=111)

# load dataset into pandas dataframe
data_train = train_dataset.to_pandas_dataframe()
data_test = test_dataset.to_pandas_dataframe()

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

X = np.array(data_train.iloc[:, 1:])
y = to_categorical(np.array(data_train.iloc[:, 0]))

# here we split validation data to optimiza classifier during training
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=13)

# test data
X_test = np.array(data_test.iloc[:, 1:])
y_test = to_categorical(np.array(data_test.iloc[:, 0]))


X_train = (
    X_train.reshape(X_train.shape[0], img_rows, img_cols, 1).astype("float32") / 255
)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
X_val = X_val.reshape(X_val.shape[0], img_rows, img_cols, 1).astype("float32") / 255

batch_size = 256
num_classes = 10
epochs = 10

# construct neuron network
model = Sequential()
model.add(
    Conv2D(
        32,
        kernel_size=(3, 3),
        activation="relu",
        kernel_initializer="he_normal",
        input_shape=input_shape,
    )
)
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), activation="relu"))
model.add(Dropout(0.4))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(num_classes, activation="softmax"))

model.compile(
    loss=keras.losses.categorical_crossentropy,
    optimizer=keras.optimizers.Adam(),
    metrics=["accuracy"],
)

# start an Azure ML run
run = Run.get_context()


class LogRunMetrics(Callback):
    # callback at the end of every epoch
    def on_epoch_end(self, epoch, log):
        # log a value repeated which creates a list
        run.log("Loss", log["loss"])
        run.log("Accuracy", log["accuracy"])


history = model.fit(
    X_train,
    y_train,
    batch_size=batch_size,
    epochs=epochs,
    verbose=1,
    validation_data=(X_val, y_val),
    callbacks=[LogRunMetrics()],
)

score = model.evaluate(X_test, y_test, verbose=0)

# log a single value
run.log("Final test loss", score[0])
print("Test loss:", score[0])

run.log("Final test accuracy", score[1])
print("Test accuracy:", score[1])

plt.figure(figsize=(6, 3))
plt.title("Fashion MNIST with Keras ({} epochs)".format(epochs), fontsize=14)
plt.plot(history.history["accuracy"], "b-", label="Accuracy", lw=4, alpha=0.5)
plt.plot(history.history["loss"], "r--", label="Loss", lw=4, alpha=0.5)
plt.legend(fontsize=12)
plt.grid(True)

# log an image
run.log_image("Loss v.s. Accuracy", plot=plt)

# create a ./outputs/model folder in the compute target
# files saved in the "./outputs" folder are automatically uploaded into run history
os.makedirs("./outputs/model", exist_ok=True)

# serialize NN architecture to JSON
model_json = model.to_json()
# save model JSON
with open("./outputs/model/model.json", "w") as f:
    f.write(model_json)
# save model weights
model.save_weights("./outputs/model/model.h5")
print("model saved in ./outputs/model folder")

Sebagian besar kode ini harusnya sudah familier bagi pengembang ML:

  • Data dipartisi menjadi set pelatihan dan validasi untuk pelatihan, dan sebagian tes lain untuk penilaian akhir
  • Bentuk inputnya 28x28x1 (hanya 1 karena inputnya skala abu-abu), akan ada 256 input dalam satu batch, dan ada 10 kelas
  • Jumlah epoch pelatihan akan menjadi 10
  • Model ini memiliki tiga lapisan konvolusional, dengan pooling dan dropout maksimum, yang diikuti oleh lapisan padat dan head softmax
  • Model ini diinstal selama 10 epoch dan kemudian dievaluasi
  • Arsitektur model ditulis ke outputs/model/model.json dan bobot ke outputs/model/model.h5

Meskipun, beberapa kode bersifat khusus untuk Azure Machine Learning. run = Run.get_context() mengambil objek Run, yang berisi konteks layanan saat ini. Sumber train.py menggunakan objek run ini untuk mengambil himpunan data input melalui namanya (alternatif untuk kode di prepare.py yang diambil himpunan data melalui array argv argumen script).

Objek run ini juga digunakan untuk mencatat kemajuan pelatihan di akhir setiap epoch, dan, pada akhir pelatihan, untuk mencatat grafik tingkat kehilangan dan akurasi dari waktu ke waktu.

Membuat langkah alur pelatihan

Langkah pelatihan memiliki konfigurasi yang sedikit lebih kompleks daripada langkah persiapan. Langkah persiapan hanya menggunakan pustaka Python standar. Umumnya, Anda harus memodifikasi lingkungan runtime bahasa umum tempat kode sumber Anda berjalan.

Buat file conda_dependencies.yml dengan konten berikut:

dependencies:
- python=3.7
- pip:
  - azureml-core
  - azureml-dataset-runtime
  - keras==2.4.3
  - tensorflow==2.4.3
  - numpy
  - scikit-learn
  - pandas
  - matplotlib

Kelas Environment mewakili lingkungan runtime bahasa umum tempat tugas pembelajaran mesin berjalan. Kaitkan spesifikasi di atas dengan kode pelatihan dengan:

keras_env = Environment.from_conda_specification(
    name="keras-env", file_path="./conda_dependencies.yml"
)

train_cfg = ScriptRunConfig(
    source_directory=script_folder,
    script="train.py",
    compute_target=compute_target,
    environment=keras_env,
)

Membuat langkah pelatihan itu sendiri menggunakan kode yang mirip dengan kode yang digunakan untuk membuat langkah persiapan:

train_step = PythonScriptStep(
    name="train step",
    arguments=[
        prepared_fashion_ds.read_delimited_files().as_input(name="prepared_fashion_ds")
    ],
    source_directory=train_cfg.source_directory,
    script_name=train_cfg.script,
    runconfig=train_cfg.run_config,
)

Membuat dan menjalankan alur

Sekarang setelah Anda menentukan input dan output data dan membuat langkah-langkah alur Anda, Anda dapat menyusunnya menjadi alur dan menjalankannya:

pipeline = Pipeline(workspace, steps=[prep_step, train_step])
run = exp.submit(pipeline)

Objek Pipeline yang telah Anda buat berjalan di dalam workspace Anda, dan terdiri atas langkah-langkah persiapan dan pelatihan yang telah Anda tentukan.

Catatan

Alur ini memiliki grafik dependensi yang sederhana: langkah pelatihan bergantung pada langkah persiapan, dan langkah persiapan bergantung pada himpunan data fashion_ds. Alur produksi akan sering memiliki dependensi yang jauh lebih kompleks. Langkah-langkah mungkin bergantung pada beberapa langkah upstram, perubahan kode sumber pada langkah awal mungkin memiliki konsekuensi yang luas, dan sebagainya. Azure Machine Learning melacak kekhawatiran ini untuk Anda. Anda hanya perlu meneruskan dalam array steps, dan Azure Machine Learning akan menangani perhitungan grafik eksekusi.

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

Submitted PipelineRun 5968530a-abcd-1234-9cc1-46168951b5eb
Link to Azure Machine Learning Portal: https://ml.azure.com/runs/abc-xyz...

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

run.wait_for_completion(show_output=True)

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.

Setelah alur selesai, Anda dapat mengambil metrik yang Anda catat dalam langkah pelatihan:

run.find_step_run("train step")[0].get_metrics()

Jika puas dengan metrik tersebut, Anda dapat mendaftarkan model di ruang kerja:

run.find_step_run("train step")[0].register_model(
    model_name="keras-model",
    model_path="outputs/model/",
    datasets=[("train test data", fashion_ds)],
)

Membersihkan sumber daya

Jangan selesaikan bagian ini jika Anda berencana untuk menjalankan tutorial Azure Machine Learning lainnya.

Menghentikan instans komputasi

Jika Anda menggunakan instans komputasi, hentikan VM saat Anda tidak menggunakannya untuk mengurangi biaya.

  1. Di ruang kerja Anda, pilih Komputasi.

  2. Dari daftar, pilih nama instans komputasi.

  3. Pilih Hentikan.

  4. Ketika Anda siap untuk menggunakan server lagi, pilih Mulai.

Menghapus semuanya

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

  1. Di portal Microsoft Azure, di menu sebelah kiri, pilih Grup sumber daya.
  2. Dalam daftar grup sumber daya, pilih grup sumber daya yang Anda buat.
  3. Pilih Hapus grup sumber daya.
  4. Masukkan nama grup sumber daya. Kemudian, pilih Hapus.

Anda juga dapat menyimpan grup sumber daya, tetapi menghapus satu ruang kerja. Tampilkan properti ruang kerja, lalu pilih Hapus.

Langkah berikutnya

Dalam tutorial ini, Anda telah menggunakan jenis berikut:

  • Workspace mewakili ruang kerja Azure Machine Learning Anda. Jenis tersebut berisi:
    • Experiment yang berisi hasil eksekusi pelatihan alur Anda
    • Dataset yang memuat data yang disimpan di datastore Fashion-MNIST dengan malas
    • ComputeTarget yang mewakili mesin tempat langkah-langkah alur berjalan
    • Environment yang merupakan lingkungan runtime bahasa umum tempat langkah-langkah alur berjalan
    • Pipeline yang menyusun langkah-langkah PythonScriptStep menjadi satu kesatuan
    • Model yang telah Anda daftarkan setelah puas dengan proses pelatihan

Objek Workspace yang berisi referensi ke sumber daya lain (buku catatan, titik akhir, dan sebagainya) yang tidak digunakan dalam tutorial ini. Untuk informasi lebih lanjut, lihat Apakah yang dimaksud dengan ruang kerja Azure Machine Learning?.

OutputFileDatasetConfig mempromosikan output eksekusi ke himpunan data berbasis file. Untuk informasi lebih lanjut mengenai himpunan data dan penggunaan data, lihat Cara mengakses data.

Untuk informasi lebih lanjur mengenai target dan lingkungan komputasi, lihat Apakah yang dimaksud dengan target komputasi di Azure Machine Learning? dan Apakah yang dimaksud dengan lingkungan Azure Machine Learning?

ScriptRunConfig mengaitkan ComputeTarget dan Environment dengan file sumber Python. PythonScriptStep mengambil ScriptRunConfig tersebut dan menentukan input dan outputnya, yang dalam alur ini, merupakan himpunan data file yang dibangun oleh OutputFileDatasetConfig.

Untuk contoh lebih lanjut mengenai cara membangun alur dengan menggunakan SDK pembelajaran mesin, lihat repositori contoh.