Delen via

Zelfstudie: Een Azure Machine Learning-pijplijn bouwen voor afbeeldingsclassificatie

  • Artikel

VAN TOEPASSING OP: Python SDK azureml v1

Notitie

Zie Zelfstudie: ML-pijplijnen gebruiken voor productie-ML-werkstromen 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 te classificeren in de Fashion MNIST-gegevensset .

In deze zelfstudie voert u de volgende taken uit:

  • Werkruimte configureren
  • Een experiment maken om uw werk vast te houden
  • Een ComputeTarget inrichten om het werk uit te voeren
  • Een gegevensset maken waarin gecomprimeerde gegevens worden opgeslagen
  • Een pijplijnstap maken om de gegevens voor te bereiden op 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 samenstellen 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 als de azureml-core azureml-pipeline pakketten hebt geïnstalleerd. Deze omgeving is bedoeld voor het definiëren en beheren van uw Azure Machine Learning-resources en is gescheiden van de omgeving die tijdens runtime wordt gebruikt voor training.

Belangrijk

Momenteel is python 3.8 compatibel met azureml-pipeline de meest recente Python-release. Als u problemen ondervindt bij het installeren van het azureml-pipeline pakket, controleert u of dit 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.

Importtypen

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 het 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 om de resultaten van de pijplijnuitvoeringen op te slaan:

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

Maak een ComputeTarget resource die de machineresource vertegenwoordigt waarop uw pijplijn wordt uitgevoerd. Het eenvoudige neurale netwerk dat in deze zelfstudie wordt gebruikt, traint in slechts een paar minuten, zelfs op een CPU-computer. Als u een GPU wilt gebruiken voor training, stelt u deze 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 op Azure opgeslagen gegevens

Fashion-MNIST is een gegevensset met modeafbeeldingen die zijn 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 afbeeldingsclassificatie is Fashion-MNIST moeilijker dan de klassieke met de hand geschreven MNIST-database. Het wordt gedistribueerd in dezelfde gecomprimeerde binaire vorm als de oorspronkelijke handgeschreven cijferdatabase .

Als u een Dataset gegevens 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 wordt snel voltooid. De onderliggende gegevens blijven aanwezig in de Azure-opslagresource die is opgegeven in de data_urls matrix.

De pijplijnstap voor gegevensvoorbereiding maken

Met de eerste stap in deze pijplijn worden de gecomprimeerde gegevensbestanden fashion_ds geconverteerd naar een gegevensset in uw eigen werkruimte die bestaat uit CSV-bestanden die klaar zijn voor gebruik in de training. Zodra ze zijn geregistreerd bij de werkruimte, hebben uw medewerkers 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 blobopslag van het standaardgegevensarchief 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 die de eerste stap in het domein uitvoert.

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.pyeen 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 bevat prepare.py twee opdrachtregelargumenten: de eerste wordt toegewezen mounted_input_path aan en de tweede aan mounted_output_path. Als deze submap niet bestaat, wordt de aanroep om deze te os.makedirs maken. Vervolgens converteert het programma de trainings- en testgegevens en voert het de door komma's gescheiden bestanden uit naar de mounted_output_path.

De pijplijnstap opgeven

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

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 om aan te PythonScriptStep geven 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 gegevenssets worden gekoppeld aan de compute_target en worden weergegeven als mappen
  • Het pad naar de fashion_ds bestanden is het eerste argument voor prepare.py. In prepare.py, dit argument is toegewezen aan mounted_input_path
  • Het pad naar het prepared_fashion_ds is het tweede argument voor prepare.py. In prepare.py, dit argument is toegewezen aan mounted_output_path
  • Omdat allow_reuse dit is True, wordt het pas opnieuw uitgevoerd als de bronbestanden of invoer zijn gewijzigd
  • Deze PythonScriptStep naam krijgt de naam prepare step

Modulariteit en hergebruik zijn belangrijke voordelen van pijplijnen. Azure Machine Learning kan automatisch de wijzigingen in de broncode of gegevensset bepalen. De uitvoer van een stap die niet wordt beïnvloed, wordt opnieuw gebruikt zonder de stappen opnieuw uit te voeren als allow_reuse dat het is True. Als een stap afhankelijk is van een gegevensbron buiten Azure Machine Learning die kan veranderen (bijvoorbeeld een URL die verkoopgegevens bevat), wordt ingesteld allow_reuse False op 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

Met grotere pijplijnen is het een goed idee om de broncode van elke stap in een afzonderlijke map (src/prepare/, src/train/enzovoort) te plaatsen, maar voor deze zelfstudie hoeft u alleen het bestand train.py in dezelfde keras-mnist-fashion/ bronmap te gebruiken of te maken.

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 en een afzonderlijke testsubset voor de definitieve score
  • De invoershape is 28x28x1 (slechts 1 omdat de invoer grijswaarden is), er zullen 256 invoer in een batch zijn 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-kop
  • Het model is geschikt voor 10 epochs en vervolgens geëvalueerd
  • De modelarchitectuur wordt geschreven naar outputs/model/model.json en de gewichten outputs/model/model.h5

Sommige 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 voor het vastleggen van de voortgang van de training aan het einde van elk tijdvak en, aan het einde van de training, om de grafiek van verlies en nauwkeurigheid in de loop van de tijd te registreren.

De stap voor de trainingspijplijn maken

De trainingsstap heeft een iets complexere configuratie dan de voorbereidingsstap. De voorbereidingsstap heeft 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,
)

Het maken van de trainingsstap zelf maakt gebruik van code 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 broncodewijziging in een vroege stap kan verregaande 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 ervoor dat de uitvoeringsgrafiek wordt berekend.

De aanroep van de Experiment bewerking submit 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 hebt geregistreerd in de trainingsstap:

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 vertegenwoordiging van uw Azure Machine Learning-werkruimte. Het bevat:
    • De Experiment resultaten van trainingsuitvoeringen van uw pijplijn
    • De Dataset gegevens die lui zijn geladen in het Fashion-MNIST-gegevensarchief
    • De ComputeTarget machine(s) waarop de pijplijnstappen worden uitgevoerd
    • Dit Environment is de runtime-omgeving waarin de pijplijnstappen worden uitgevoerd
    • De Pipeline stappen die de PythonScriptStep stappen in een geheel vormen
    • De Model registratie nadat u tevreden bent over 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?

De OutputFileDatasetConfig uitvoer van een uitvoering naar een gegevensset op basis van bestanden wordt gepromoot. Zie Hoe u toegang hebt 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?

Hiermee ScriptRunConfig worden een ComputeTarget en Environment met Python-bronbestanden gekoppeld. A PythonScriptStep neemt dat ScriptRunConfig en definieert de invoer en uitvoer, die in deze pijplijn de bestandsgegevensset is die is gebouwd door de OutputFileDatasetConfig.

Zie de voorbeeldopslagplaats voor meer voorbeelden van het bouwen van pijplijnen met behulp van de Machine Learning SDK.