Zelfstudie: Een Azure Machine Learning-pijplijn bouwen voor afbeeldingsclassificatie

VAN TOEPASSING OP:Python SDK azureml v1

Notitie

Zie Zelfstudie: ML-pijplijnen gebruiken voor ml-productiewerkstromen met Python SDK v2 in een Jupyter Notebook voor een zelfstudie waarin SDK v2 wordt gebruikt om een pijplijn te bouwen.

In deze zelfstudie leert u hoe u een Azure Machine Learning-pijplijn bouwt om gegevens voor te bereiden en een machine learning-model te trainen. Machine Learning-pijplijnen optimaliseren uw werkstroom met snelheid, draagbaarheid en hergebruik, zodat u zich kunt concentreren op machine learning in plaats van op infrastructuur en automatisering.

In het voorbeeld wordt een klein Keras-convolutionele neurale netwerk getraind om afbeeldingen in de gegevensset Fashion MNIST te classificeren.

In deze zelfstudie voert u de volgende taken uit:

• Werkruimte configureren
• Een experiment maken om uw werk op te slaan
• Een ComputeTarget inrichten om het werk te doen
• Een gegevensset maken waarin gecomprimeerde gegevens moeten worden opgeslagen
• Een pijplijnstap maken om de gegevens voor te bereiden voor training
• Een runtime-omgeving definiëren waarin training moet worden uitgevoerd
• Een pijplijnstap maken om het neurale netwerk te definiëren en de training uit te voeren
• Een pijplijn opstellen vanuit de pijplijnstappen
• De pijplijn uitvoeren in het experiment
• Bekijk de uitvoer van de stappen en het getrainde neurale netwerk
• Het model registreren voor verder gebruik

Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint. Probeer vandaag nog de gratis of betaalde versie van Azure Machine Learning.

Vereisten

• Voltooi Resources maken om aan de slag te gaan als u nog geen Azure Machine Learning-werkruimte hebt.
• Een Python-omgeving waarin u zowel de azureml-coreazureml-pipeline pakketten als de pakketten hebt geïnstalleerd. Deze omgeving is bedoeld voor het definiëren en beheren van uw Azure Machine Learning-resources en staat los van de omgeving die tijdens runtime wordt gebruikt voor training.

Belangrijk

Momenteel is python 3.8 de meest recente versie die compatibel is met azureml-pipeline Python. Als u problemen ondervindt bij het installeren van het azureml-pipeline pakket, controleert u of het python --version een compatibele release is. Raadpleeg de documentatie van uw virtuele Python-omgevingsmanager (venv, condaenzovoort) voor instructies.

Een interactieve Python-sessie starten

In deze zelfstudie wordt de Python SDK voor Azure Machine Learning gebruikt om een Azure Machine Learning-pijplijn te maken en te beheren. In de zelfstudie wordt ervan uitgegaan dat u de codefragmenten interactief uitvoert in een Python REPL-omgeving of een Jupyter-notebook.

• Deze zelfstudie is gebaseerd op het image-classification.ipynb notebook in de python-sdk/tutorial/using-pipelines map van de opslagplaats Azure Machine Learning-voorbeelden . De broncode voor de stappen zelf bevindt zich in de keras-mnist-fashion submap.

Typen importeren

Importeer alle Azure Machine Learning-typen die u nodig hebt voor deze zelfstudie:

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)

De versie van de Azure Machine Learning SDK moet 1.37 of hoger zijn. Als dat niet zo is, voert u een upgrade uit met pip install --upgrade azureml-core.

Werkruimte configureren

Maak een werkruimteobject op basis van de bestaande Azure Machine Learning-werkruimte.

workspace = Workspace.from_config()

Belangrijk

Dit codefragment verwacht dat de werkruimteconfiguratie wordt opgeslagen in de huidige of de bovenliggende map. Zie Werkruimteresources maken voor meer informatie over het maken van een werkruimte. Zie Een configuratiebestand voor een werkruimte maken voor meer informatie over de configuratie als bestand opslaan.

De infrastructuur voor uw pijplijn maken

Maak een Experiment -object voor het opslaan van de resultaten van uw pijplijnuitvoeringen:

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

Maak een ComputeTarget die de machineresource vertegenwoordigt waarop uw pijplijn wordt uitgevoerd. Het eenvoudige neurale netwerk dat in deze zelfstudie wordt gebruikt, traint in slechts enkele minuten, zelfs op een computer op basis van CPU. Als u een GPU wilt gebruiken voor training, stelt u in use_gpu op True. Het inrichten van een rekendoel duurt over het algemeen ongeveer vijf minuten.

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

Notitie

Gpu-beschikbaarheid is afhankelijk van het quotum van uw Azure-abonnement en van de Azure-capaciteit. Raadpleeg Quota voor resources beheren en verhogen met Azure Machine Learning.

Een gegevensset maken voor de in Azure opgeslagen gegevens

Fashion-MNIST is een gegevensset met modeafbeeldingen, onderverdeeld in 10 klassen. Elke afbeelding is een afbeelding van 28x28 grijswaarden en er zijn 60.000 trainings- en 10.000 testafbeeldingen. Als probleem met de classificatie van afbeeldingen is Fashion-MNIST moeilijker dan de klassieke handgeschreven MNIST-cijferdatabase. Het wordt gedistribueerd in dezelfde gecomprimeerde binaire vorm als de oorspronkelijke handgeschreven cijferdatabase .

Als u een Dataset wilt maken die verwijst naar de webgegevens, voert u het volgende uit:

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

Deze code is snel voltooid. De onderliggende gegevens blijven aanwezig in de Azure-opslagresource die is opgegeven in de data_urls matrix.

De pijplijnstap voor gegevensvoorbereiding maken

De eerste stap in deze pijplijn converteert de gecomprimeerde gegevensbestanden van fashion_ds naar een gegevensset in uw eigen werkruimte die bestaat uit CSV-bestanden die klaar zijn voor gebruik in de training. Na registratie bij de werkruimte hebben uw samenwerkers toegang tot deze gegevens voor hun eigen analyse, training, enzovoort

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

De bovenstaande code geeft een gegevensset op die is gebaseerd op de uitvoer van een pijplijnstap. De onderliggende verwerkte bestanden worden in de standaardblobopslag van de werkruimte geplaatst op het pad dat is opgegeven in destination. De gegevensset wordt geregistreerd in de werkruimte met de naam prepared_fashion_ds.

De bron van de pijplijnstap maken

De code die u tot nu toe hebt uitgevoerd, heeft Azure-resources gemaakt en beheerd. Nu is het tijd om code te schrijven waarmee de eerste stap in het domein wordt uitgevoerd.

Als u het voorbeeld in de opslagplaats Azure Machine Learning-voorbeelden volgt, is het bronbestand al beschikbaar als keras-mnist-fashion/prepare.py.

Als u helemaal opnieuw werkt, maakt u een submap met de naam keras-mnist-fashion/. Maak een nieuw bestand, voeg de volgende code eraan toe en geef het bestand prepare.pyde naam .

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

De code in prepare.py heeft twee opdrachtregelargumenten: de eerste wordt toegewezen aan mounted_input_path en de tweede aan mounted_output_path. Als deze submap niet bestaat, wordt deze door de aanroep naar os.makedirs gemaakt. Vervolgens converteert het programma de training- en testgegevens en voert het de door komma's gescheiden bestanden uit naar de mounted_output_path.

De pijplijnstap opgeven

Terug in de Python-omgeving die u gebruikt om de pijplijn op te geven, voert u deze code uit om een PythonScriptStep te maken voor uw voorbereidingscode:

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

De aanroep naar PythonScriptStep geeft aan dat wanneer de pijplijnstap wordt uitgevoerd:

• Alle bestanden in de script_folder map worden geüpload naar de compute_target
• Onder de geüploade bronbestanden wordt het bestand prepare.py uitgevoerd
• De fashion_ds gegevenssets en prepared_fashion_ds worden gekoppeld aan de compute_target en worden weergegeven als mappen
• Het pad naar de fashion_ds bestanden is het eerste argument naar prepare.py. In prepare.pywordt dit argument toegewezen aan mounted_input_path
• Het pad naar de prepared_fashion_ds is het tweede argument naar prepare.py. In prepare.pywordt dit argument toegewezen aan mounted_output_path
• Omdat allow_reuse is True, wordt het niet opnieuw uitgevoerd totdat de bronbestanden of invoer worden gewijzigd
• Deze PythonScriptStep krijgt de naam prepare step

Modulariteit en hergebruik zijn belangrijke voordelen van pijplijnen. Azure Machine Learning kan automatisch broncode- of gegevenssetwijzigingen bepalen. De uitvoer van een stap die niet wordt beïnvloed, wordt opnieuw gebruikt zonder de stappen opnieuw uit te voeren als allow_reuse is True. Als een stap afhankelijk is van een gegevensbron buiten Azure Machine Learning die kan worden gewijzigd (bijvoorbeeld een URL die verkoopgegevens bevat), stelt u in allow_reuse op False en wordt de pijplijnstap uitgevoerd telkens wanneer de pijplijn wordt uitgevoerd.

De trainingsstap maken

Zodra de gegevens zijn geconverteerd van de gecomprimeerde indeling naar CSV-bestanden, kunnen deze worden gebruikt voor het trainen van een convolutionele neurale netwerk.

De bron van de trainingsstap maken

Bij grotere pijplijnen is het een goede gewoonte om de broncode van elke stap in een afzonderlijke map (src/prepare/, src/train/enzovoort) te plaatsen, maar voor deze zelfstudie gebruikt of maakt u het bestand train.py in dezelfde keras-mnist-fashion/ bronmap.

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

De meeste van deze code moeten bekend zijn bij ML-ontwikkelaars:

• De gegevens worden gepartitioneerd in trainings- en validatiesets voor training en een afzonderlijke testsubset voor de uiteindelijke score
• De invoershape is 28x28x1 (slechts 1 omdat de invoer grijswaarden is), er zijn 256 invoerwaarden in een batch en er zijn 10 klassen
• Het aantal trainingstijdvakken is 10
• Het model heeft drie convolutionele lagen, met maximale pooling en dropout, gevolgd door een dichte laag en softmax head
• Het model wordt 10 epochs gebruikt en vervolgens geëvalueerd
• De modelarchitectuur wordt geschreven naar outputs/model/model.json en de gewichten naar outputs/model/model.h5

Een deel van de code is echter specifiek voor Azure Machine Learning. run = Run.get_context() haalt een Run -object op dat de huidige servicecontext bevat. De train.py bron gebruikt dit run object om de invoergegevensset op te halen via de naam (een alternatief voor de code in prepare.py die de gegevensset heeft opgehaald via de argv matrix met scriptargumenten).

Het run object wordt ook gebruikt om de trainingsvoortgang aan het einde van elk tijdvak te registreren en, aan het einde van de training, om de grafiek van verlies en nauwkeurigheid in de loop van de tijd te registreren.

De trainingspijplijnstap maken

De trainingsstap heeft een iets complexere configuratie dan de voorbereidingsstap. In de voorbereidingsstap zijn alleen standaard Python-bibliotheken gebruikt. Meestal moet u de runtime-omgeving wijzigen waarin uw broncode wordt uitgevoerd.

Maak een bestand conda_dependencies.yml met de volgende inhoud:

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

De Environment klasse vertegenwoordigt de runtime-omgeving waarin een machine learning-taak wordt uitgevoerd. Koppel de bovenstaande specificatie aan de trainingscode met:

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

Voor het maken van de trainingsstap zelf wordt code gebruikt die vergelijkbaar is met de code die wordt gebruikt om de voorbereidingsstap te maken:

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

De pijplijn maken en uitvoeren

Nu u gegevensinvoer en -uitvoer hebt opgegeven en de stappen van uw pijplijn hebt gemaakt, kunt u deze samenstellen in een pijplijn en deze uitvoeren:

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

Het Pipeline object dat u maakt, wordt uitgevoerd in uw workspace en bestaat uit de voorbereidings- en trainingsstappen die u hebt opgegeven.

Notitie

Deze pijplijn heeft een eenvoudige afhankelijkheidsgrafiek: de trainingsstap is afhankelijk van de voorbereidingsstap en de voorbereidingsstap is afhankelijk van de fashion_ds gegevensset. Productiepijplijnen hebben vaak veel complexere afhankelijkheden. Stappen kunnen afhankelijk zijn van meerdere upstream-stappen, een wijziging van de broncode in een vroege stap kan verstrekkende gevolgen hebben, enzovoort. Azure Machine Learning houdt deze problemen voor u bij. U hoeft alleen de matrix van steps door te geven en Azure Machine Learning zorgt voor het berekenen van de uitvoeringsgrafiek.

De aanroep naar submit de Experiment wordt snel voltooid en produceert uitvoer die vergelijkbaar is met:

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

U kunt de pijplijnuitvoering controleren door de koppeling te openen of u kunt blokkeren totdat deze is voltooid door het volgende uit te voeren:

run.wait_for_completion(show_output=True)

Belangrijk

De eerste pijplijnuitvoering duurt ongeveer 15 minuten. Alle afhankelijkheden moeten worden gedownload, een Docker-kopie wordt gemaakt en de Python-omgeving wordt ingericht en gemaakt. Het opnieuw uitvoeren van de pijplijn vergt aanzienlijk minder tijd, omdat deze resources opnieuw worden gebruikt in plaats van worden gemaakt. De totale runtime voor de pijplijn is echter afhankelijk van de werkbelasting van uw scripts en de processen die in elke pijplijnstap worden uitgevoerd.

Zodra de pijplijn is voltooid, kunt u de metrische gegevens ophalen die u in de trainingsstap hebt geregistreerd:

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

Als u tevreden bent met de metrische gegevens, kunt u het model registreren in uw werkruimte:

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

Resources opschonen

Voltooi deze sectie niet als u van plan bent andere Azure Machine Learning-zelfstudies uit te voeren.

Het rekenproces stoppen

Als u een rekenproces hebt gebruikt, stopt u de VM wanneer u deze niet gebruikt om de kosten te verlagen.

1. Selecteer in uw werkruimte Compute.

2. Selecteer in de lijst de naam van het rekenproces.

3. Selecteer Stoppen.

4. Wanneer u klaar bent om de server opnieuw te gebruiken, selecteert u Starten.

Alles verwijderen

Als u niet van plan bent om gebruik te maken van de resources die u hebt gemaakt, kunt u ze verwijderen zodat er geen kosten voor in rekening worden gebracht:

1. Selecteer Resourcegroepen in het linkermenu van de Azure-portal.
2. Selecteer in de lijst met resourcegroepen de resourcegroep die u hebt gemaakt.
3. Selecteer Resourcegroep verwijderen.
4. Voer de naam van de resourcegroup in. Selecteer vervolgens Verwijderen.

U kunt de resourcegroep ook bewaren en slechts één werkruimte verwijderen. Bekijk de eigenschappen van de werkruimte en selecteer vervolgens Verwijderen.

Volgende stappen

In deze zelfstudie hebt u de volgende typen gebruikt:

• De Workspace vertegenwoordigt uw Azure Machine Learning-werkruimte. Deze bevatte:
  • De Experiment die de resultaten van trainingsuitvoeringen van uw pijplijn bevat
  • De Dataset die de gegevens in het Fashion-MNIST-gegevensarchief lui heeft geladen
  • De ComputeTarget die de machine(s) vertegenwoordigt waarop de pijplijnstappen worden uitgevoerd
  • Dit Environment is de runtime-omgeving waarin de pijplijnstappen worden uitgevoerd
  • De Pipeline die de PythonScriptStep stappen samenstelt tot een geheel
  • De Model die u hebt geregistreerd nadat u tevreden bent met het trainingsproces

Het Workspace object bevat verwijzingen naar andere resources (notebooks, eindpunten, enzovoort) die niet in deze zelfstudie zijn gebruikt. Zie Wat is een Azure Machine Learning-werkruimte? voor meer informatie.

De OutputFileDatasetConfig bevordert de uitvoer van een uitvoering naar een gegevensset op basis van een bestand. Zie Toegang krijgen tot gegevens voor meer informatie over gegevenssets en het werken met gegevens.

Zie Wat zijn rekendoelen in Azure Machine Learning? en Wat zijn Azure Machine Learning-omgevingen? voor meer informatie over rekendoelen en -omgevingen.

De ScriptRunConfig koppelt een ComputeTarget en Environment aan Python-bronbestanden. Een PythonScriptStep neemt dat ScriptRunConfig en definieert de invoer en uitvoer, die in deze pijplijn de bestandsgegevensset was die is gebouwd door de OutputFileDatasetConfig.

Zie de voorbeeldopslagplaats voor meer voorbeelden van het bouwen van pijplijnen met behulp van de machine learning-SDK.