Udostępnij za pośrednictwem

Samouczek: tworzenie potoku usługi Azure Machine Learning na potrzeby klasyfikacji obrazów

  • Artykuł

DOTYCZY: Zestaw SDK języka Python azureml w wersji 1

Uwaga

Aby zapoznać się z samouczkiem korzystającym z zestawu SDK w wersji 2 do kompilowania potoku, zobacz Samouczek: używanie potoków uczenia maszynowego dla produkcyjnych przepływów pracy uczenia maszynowego z zestawem Python SDK w wersji 2 w notesie Jupyter Notebook.

Z tego samouczka dowiesz się, jak utworzyć potok usługi Azure Machine Learning w celu przygotowania danych i wytrenowania modelu uczenia maszynowego. Potoki uczenia maszynowego optymalizują przepływ pracy z szybkością, przenośnością i ponownym użyciem, dzięki czemu można skupić się na uczeniu maszynowym zamiast infrastruktury i automatyzacji.

W tym przykładzie wytrenuje małą sieć neuronową Keras w celu klasyfikowania obrazów w zestawie danych Fashion MNIST .

W tym samouczku wykonasz następujące zadania:

  • Konfigurowanie obszaru roboczego
  • Tworzenie eksperymentu w celu przechowywania pracy
  • Aprowizuj element ComputeTarget, aby wykonać pracę
  • Tworzenie zestawu danych, w którym mają być przechowywane skompresowane dane
  • Tworzenie kroku potoku w celu przygotowania danych do trenowania
  • Definiowanie środowiska uruchomieniowego, w którym ma być wykonywane szkolenie
  • Tworzenie kroku potoku w celu zdefiniowania sieci neuronowej i wykonania trenowania
  • Tworzenie potoku z kroków potoku
  • Uruchamianie potoku w eksperymencie
  • Przejrzyj dane wyjściowe kroków i wytrenowanego sieci neuronowej
  • Rejestrowanie modelu w celu dalszego użycia

Jeśli nie masz subskrypcji platformy Azure, przed rozpoczęciem utwórz bezpłatne konto. Wypróbuj bezpłatną lub płatną wersję usługi Azure Machine Learning już dziś.

Wymagania wstępne

  • Ukończ tworzenie zasobów, aby rozpocząć pracę , jeśli nie masz jeszcze obszaru roboczego usługi Azure Machine Learning.
  • Środowisko języka Python, w którym zainstalowano pakiety azureml-core i azureml-pipeline . To środowisko służy do definiowania i kontrolowania zasobów usługi Azure Machine Learning i jest oddzielone od środowiska używanego w czasie wykonywania trenowania.

Ważne

Obecnie najnowsza wersja języka Python zgodna z językiem azureml-pipeline Python to Python 3.8. Jeśli masz trudności z instalacją azureml-pipeline pakietu, upewnij się, że python --version jest to zgodna wersja. Aby uzyskać instrukcje, condazapoznaj się z dokumentacją menedżera środowiska wirtualnego języka Python (venvitd.).

Uruchamianie interakcyjnej sesji języka Python

W tym samouczku do tworzenia potoku usługi Azure Machine Learning i kontrolowania potoku usługi Azure Machine Learning jest używany zestaw SDK języka Python dla usługi Azure Machine Learning. W samouczku założono, że będziesz uruchamiać fragmenty kodu interaktywnie w środowisku REPL języka Python lub notesie Jupyter.

  • Ten samouczek jest oparty na notesie image-classification.ipynb znajdującym się w python-sdk/tutorial/using-pipelines katalogu repozytorium Przykłady usługi Azure Machine Learning. Kod źródłowy kroków znajduje się w podkatalogu keras-mnist-fashion .

Typy importu

Zaimportuj wszystkie typy usługi Azure Machine Learning, które będą potrzebne w tym samouczku:

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)

Wersja zestawu AZURE Machine Learning SDK powinna być 1.37 lub nowsza. Jeśli tak nie jest, przeprowadź uaktualnienie za pomocą polecenia pip install --upgrade azureml-core.

Konfigurowanie obszaru roboczego

Utwórz obiekt obszaru roboczego z istniejącego obszaru roboczego usługi Azure Machine Learning.

workspace = Workspace.from_config()

Ważne

Ten fragment kodu oczekuje, że konfiguracja obszaru roboczego zostanie zapisana w bieżącym katalogu lub jego elemencie nadrzędnym. Aby uzyskać więcej informacji na temat tworzenia obszaru roboczego, zobacz Tworzenie zasobów obszaru roboczego. Aby uzyskać więcej informacji na temat zapisywania konfiguracji w pliku, zobacz Tworzenie pliku konfiguracji obszaru roboczego.

Tworzenie infrastruktury dla potoku

Experiment Utwórz obiekt do przechowywania wyników przebiegów potoku:

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

Utwórz obiekt ComputeTarget reprezentujący zasób maszyny, na którym zostanie uruchomiony potok. Prosta sieć neuronowa używana w tym samouczku trenuje w ciągu kilku minut nawet na maszynie opartej na procesorze CPU. Jeśli chcesz użyć procesora GPU do trenowania, ustaw wartość use_gpuTrue. Aprowizowanie docelowego obiektu obliczeniowego trwa zwykle około pięciu minut.

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

Uwaga

Dostępność procesora GPU zależy od limitu przydziału subskrypcji platformy Azure i pojemności platformy Azure. Zobacz Zwiększanie limitów przydziału zasobów i zarządzanie nimi przy użyciu usługi Azure Machine Learning.

Tworzenie zestawu danych dla danych przechowywanych na platformie Azure

Fashion-MNIST to zestaw danych obrazów mody podzielonych na 10 klas. Każdy obraz jest obrazem o skali szarości 28x28 i 60 000 treningów i 10 000 obrazów testowych. Jako problem z klasyfikacją obrazów moda-MNIST jest trudniejsza niż klasyczna baza danych cyfr odręcznych MNIST. Jest on dystrybuowany w tej samej skompresowanej postaci binarnej co oryginalna baza danych cyfr odręcznych .

Aby utworzyć element Dataset odwołujący się do danych opartych na sieci Web, uruchom polecenie:

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

Ten kod zostanie szybko ukończony. Dane bazowe pozostają w zasobie usługi Azure Storage określonym w tablicy data_urls .

Tworzenie kroku potoku przygotowywania danych

Pierwszy krok w tym potoku spowoduje przekonwertowanie skompresowanych plików fashion_ds danych na zestaw danych we własnym obszarze roboczym składającym się z plików CSV gotowych do użycia podczas trenowania. Po zarejestrowaniu się w obszarze roboczym współpracownicy mogą uzyskiwać dostęp do tych danych do własnych analiz, szkoleń itd.

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

Powyższy kod określa zestaw danych oparty na danych wyjściowych kroku potoku. Podstawowe przetworzone pliki zostaną umieszczone w domyślnym magazynie obiektów blob magazynu danych obszaru roboczego w ścieżce określonej w destinationpliku . Zestaw danych zostanie zarejestrowany w obszarze roboczym o nazwie prepared_fashion_ds.

Tworzenie źródła kroku potoku

Kod, który został wykonany do tej pory, zawiera tworzenie i kontrolowanie zasobów platformy Azure. Nadszedł czas na napisanie kodu, który wykonuje pierwszy krok w domenie.

Jeśli korzystasz z przykładu w repozytorium Przykłady usługi Azure Machine Learning, plik źródłowy jest już dostępny jako keras-mnist-fashion/prepare.py.

Jeśli pracujesz od podstaw, utwórz podkatalog o nazwie keras-mnist-fashion/. Utwórz nowy plik, dodaj do niego następujący kod i nadaj mu prepare.pynazwę .

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

Kod w pliku prepare.py przyjmuje dwa argumenty wiersza polecenia: pierwszy jest przypisany do mounted_input_path i drugi do mounted_output_path. Jeśli ten podkatalog nie istnieje, wywołaj metodę , aby ją utworzyć os.makedirs . Następnie program konwertuje dane szkoleniowe i testowe oraz generuje pliki rozdzielane przecinkami na mounted_output_path.

Określanie kroku potoku

Po powrocie do środowiska języka Python, którego używasz do określania potoku, uruchom ten kod, aby utworzyć PythonScriptStep kod przygotowania:

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

Wywołanie polecenia PythonScriptStep określa, że po uruchomieniu kroku potoku:

  • Wszystkie pliki w script_folder katalogu są przekazywane do folderu compute_target
  • Wśród przekazanych plików źródłowych zostanie uruchomiony plik prepare.py
  • Zestawy fashion_ds danych i prepared_fashion_ds zostaną zainstalowane na obiekcie compute_target i będą wyświetlane jako katalogi
  • Ścieżka do fashion_ds plików będzie pierwszym argumentem .prepare.py W prepare.pysystemie ten argument jest przypisywany do mounted_input_path
  • Ścieżka do prepared_fashion_ds elementu będzie drugim argumentem .prepare.py W prepare.pysystemie ten argument jest przypisywany do mounted_output_path
  • Ze względu allow_reuse na to True, że nie zostanie ono uruchomione ponownie, dopóki nie zmienią się jego pliki źródłowe ani dane wejściowe
  • Będzie to PythonScriptStep nazwane prepare step

Modułowość i ponowne użycie to kluczowe zalety potoków. Usługa Azure Machine Learning może automatycznie określać kod źródłowy lub zmiany zestawu danych. Dane wyjściowe kroku, którego nie dotyczy problem, będą ponownie używane bez ponownego uruchamiania kroków, jeśli allow_reuse ma wartość True. Jeśli krok opiera się na źródle danych zewnętrznym dla usługi Azure Machine Learning, które może ulec zmianie (na przykład adres URL zawierający dane sprzedaży), ustawiono allow_reuseFalse wartość , a krok potoku będzie uruchamiany za każdym razem, gdy potok zostanie uruchomiony.

Tworzenie kroku trenowania

Po przekonwertowaniu danych ze skompresowanego formatu na pliki CSV można go użyć do trenowania splotowej sieci neuronowej.

Tworzenie źródła kroku trenowania

W przypadku większych potoków dobrym rozwiązaniem jest umieszczenie kodu źródłowego każdego kroku w osobnym katalogu (src/prepare/src/train/itd.), ale w tym samouczku wystarczy użyć lub utworzyć plik train.py w tym samym keras-mnist-fashion/ katalogu źródłowym.

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

Większość tego kodu powinna być znana deweloperom uczenia maszynowego:

  • Dane są podzielone na zestawy trenowania i sprawdzania poprawności na potrzeby trenowania oraz oddzielny podzbiór testowy na potrzeby końcowego oceniania
  • Kształt wejściowy to 28x28x1 (tylko 1, ponieważ dane wejściowe są w skali szarości), w partii będzie 256 danych wejściowych i istnieje 10 klas
  • Liczba epok treningowych będzie 10
  • Model ma trzy warstwy splotowe z maksymalną pulą i listą rozwijaną, a następnie gęstą warstwą i głową softmax
  • Model jest dopasowany do 10 epok, a następnie oceniany
  • Architektura modelu jest zapisywana w elementach outputs/model/model.json i wagach do outputs/model/model.h5

Część kodu jest jednak specyficzna dla usługi Azure Machine Learning. run = Run.get_context()Run pobiera obiekt, który zawiera bieżący kontekst usługi. Źródło train.py używa tego run obiektu do pobierania wejściowego zestawu danych za pośrednictwem jego nazwy (alternatywy dla kodu w prepare.py tym, który pobrał zestaw danych za pośrednictwem argv tablicy argumentów skryptu).

Obiekt run jest również używany do rejestrowania postępu trenowania na końcu każdej epoki i, na końcu trenowania, w celu rejestrowania wykresu utraty i dokładności w czasie.

Tworzenie kroku potoku trenowania

Krok trenowania ma nieco bardziej złożoną konfigurację niż krok przygotowania. Krok przygotowywania używał tylko standardowych bibliotek języka Python. Częściej należy zmodyfikować środowisko uruchomieniowe, w którym jest uruchamiany kod źródłowy.

Utwórz plik conda_dependencies.yml z następującą zawartością:

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

Klasa Environment reprezentuje środowisko uruchomieniowe, w którym jest uruchamiane zadanie uczenia maszynowego. Skojarz powyższą specyfikację z kodem treningowym z:

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

Utworzenie samego kroku trenowania używa kodu podobnego do kodu użytego do utworzenia kroku przygotowania:

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

Tworzenie i uruchamianie potoku

Po określeniu danych wejściowych i wyjściowych oraz utworzeniu kroków potoku możesz utworzyć je w potoku i uruchomić go:

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

Utworzony Pipeline obiekt jest uruchamiany w obiekcie workspace i składa się z określonych kroków przygotowania i trenowania.

Uwaga

Ten potok ma prosty graf zależności: krok trenowania opiera się na kroku przygotowania, a krok przygotowania opiera się na fashion_ds zestawie danych. Potoki produkcyjne często mają znacznie bardziej złożone zależności. Kroki mogą polegać na wielu krokach nadrzędnych, zmiana kodu źródłowego we wczesnym kroku może mieć daleko idące konsekwencje itd. Usługa Azure Machine Learning śledzi te obawy. Potrzebujesz tylko przekazać tablicę steps , a usługa Azure Machine Learning zajmuje się obliczanie wykresu wykonywania.

Wywołanie metody submitExperiment do wykonania jest szybkie i generuje dane wyjściowe podobne do następujących:

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

Uruchomienie potoku można monitorować, otwierając link lub blokując je do momentu jego zakończenia, uruchamiając polecenie:

run.wait_for_completion(show_output=True)

Ważne

Pierwsze uruchomienie potoku trwa około 15 minut. Wszystkie zależności muszą być pobierane, tworzony jest obraz platformy Docker, a środowisko języka Python jest aprowizowane i tworzone. Ponowne uruchomienie potoku zajmuje znacznie mniej czasu, ponieważ te zasoby są ponownie używane zamiast tworzenia. Jednak całkowity czas wykonywania potoku zależy od obciążenia skryptów i procesów uruchomionych w każdym kroku potoku.

Po zakończeniu potoku możesz pobrać metryki zarejestrowane w kroku trenowania:

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

Jeśli metryki są zadowalające, możesz zarejestrować model w obszarze roboczym:

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

Czyszczenie zasobów

Nie ukończ tej sekcji, jeśli planujesz uruchomić inne samouczki usługi Azure Machine Learning.

Zatrzymywanie wystąpienia obliczeniowego

Jeśli użyto wystąpienia obliczeniowego, zatrzymaj maszynę wirtualną, gdy nie używasz jej w celu obniżenia kosztów.

  1. W obszarze roboczym wybierz pozycję Obliczenia.

  2. Z listy wybierz nazwę wystąpienia obliczeniowego.

  3. Wybierz pozycję Zatrzymaj.

  4. Gdy wszystko będzie gotowe do ponownego użycia serwera, wybierz pozycję Uruchom.

Usuń wszystko

Jeśli nie planujesz używać utworzonych zasobów, usuń je, aby uniknąć naliczania opłat.

  1. W witrynie Azure Portal w menu po lewej stronie wybierz pozycję Grupy zasobów.
  2. Na liście grup zasobów wybierz utworzoną grupę zasobów.
  3. Wybierz pozycję Usuń grupę zasobów.
  4. Wpisz nazwę grupy zasobów. Następnie wybierz pozycję Usuń.

Możesz też zachować grupę zasobów i usunąć jeden obszar roboczy. Wyświetl właściwości obszaru roboczego, a następnie wybierz pozycję Usuń.

Następne kroki

W tym samouczku użyto następujących typów:

  • Obiekt Workspace reprezentuje obszar roboczy usługi Azure Machine Learning. Zawarte:
    • Element Experiment zawierający wyniki przebiegów trenowania potoku
    • Te Dataset leniwie załadowane dane przechowywane w magazynie danych Fashion-MNIST
    • Element ComputeTarget reprezentujący maszyny, na których są uruchamiane kroki potoku
    • Jest Environment to środowisko uruchomieniowe, w którym są uruchamiane kroki potoku
    • To Pipeline , które komponuje PythonScriptStep kroki w całości
    • Zarejestrowana Model po zakończeniu procesu trenowania

Obiekt Workspace zawiera odwołania do innych zasobów (notesów, punktów końcowych itd.), które nie zostały użyte w tym samouczku. Aby uzyskać więcej informacji, zobacz Co to jest obszar roboczy usługi Azure Machine Learning?.

Element OutputFileDatasetConfig promuje dane wyjściowe przebiegu do zestawu danych opartego na plikach. Aby uzyskać więcej informacji na temat zestawów danych i pracy z danymi, zobacz Jak uzyskać dostęp do danych.

Aby uzyskać więcej informacji na temat docelowych obiektów obliczeniowych i środowisk, zobacz Co to są cele obliczeniowe w usłudze Azure Machine Learning? i Co to są środowiska usługi Azure Machine Learning?

Obiekt ScriptRunConfig kojarzy element ComputeTarget i Environment z plikami źródłowymi języka Python. Element PythonScriptStep przyjmuje to ScriptRunConfig i definiuje jego dane wejściowe i wyjściowe, które w tym potoku to zestaw danych plików utworzony przez program OutputFileDatasetConfig.

Aby uzyskać więcej przykładów tworzenia potoków przy użyciu zestawu SDK uczenia maszynowego, zobacz przykładowe repozytorium.