Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Machine Learning SDK v2

VAN TOEPASSING OP: Python SDK azure-ai-ml v2 (actueel)

In dit artikel leert u hoe u een Azure Machine Learning-pijplijn bouwt met behulp van de Azure Machine Learning Python SDK v2 om een taak voor afbeeldingsclassificatie te voltooien die drie stappen bevat: gegevens voorbereiden, een afbeeldingsclassificatiemodel trainen en het model beoordelen. Machine Learning-pijplijnen optimaliseren uw werkstroom met snelheid, draagbaarheid en hergebruik, zodat u zich kunt richten op machine learning in plaats van infrastructuur en automatisering.

De voorbeeldpijplijn traint een klein Keras-convolutioneel neuraal netwerk om afbeeldingen te classificeren in de Fashion MNIST-gegevensset. De pijplijn ziet er als volgt uit:

In dit artikel voert u de volgende taken uit:

• Invoergegevens voorbereiden voor de pijplijntaak.
• Maak drie onderdelen om de gegevens voor te bereiden, een afbeelding te trainen en het model te beoordelen.
• Bouw een pijplijn van de onderdelen.
• Krijg toegang tot een werkruimte met rekenkracht.
• Verzend de pijplijntaak.
• Controleer de uitvoer van de onderdelen en het getrainde neurale netwerk.
• (Optioneel) Registreer het onderdeel voor verder hergebruik en delen binnen de werkruimte.

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

• Een Azure Machine Learning-werkruimte. Als u nog geen resource hebt, voltooi de Zelfstudie Resources Maken.

• Een Python-omgeving waarin u Azure Machine Learning Python SDK v2 hebt geïnstalleerd. Zie Aan de slag voor installatie-instructies. 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.

• Een kloon van de opslagplaats met voorbeelden.

  Als u de trainingsvoorbeelden wilt uitvoeren, kloont u eerst de opslagplaats met voorbeelden en gaat u naar de sdk map:

  git clone --depth 1 https://github.com/Azure/azureml-examples
  cd azureml-examples/sdk
  

Een interactieve Python-sessie starten

In dit artikel wordt de Azure Machine Learning Python SDK gebruikt om een Azure Machine Learning-pijplijn te maken en te beheren. Het artikel is geschreven op basis van de veronderstelling dat u de codefragmenten interactief uitvoert in een Python REPL-omgeving of een Jupyter-notebook.

Dit artikel is gebaseerd op de image_classification_keras_minist_convnet.ipynb-notebook , die u kunt vinden in de map van de sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet opslagplaats met Voorbeelden van Azure Machine Learning .

Vereiste bibliotheken importeren

Importeer alle Azure Machine Learning-bibliotheken die u nodig hebt voor dit artikel:

# import required libraries
from azure.identity import DefaultAzureCredential, InteractiveBrowserCredential

from azure.ai.ml import MLClient
from azure.ai.ml.dsl import pipeline
from azure.ai.ml import load_component

Invoergegevens voorbereiden voor uw pijplijntaak

U moet de invoergegevens voorbereiden voor de pijplijn voor afbeeldingsclassificatie.

Fashion MNIST is een gegevensset met modeafbeeldingen die zijn onderverdeeld in 10 klassen. Elke afbeelding is een 28 x 28 grijswaardenbeeld. Er zijn 60.000 trainingsafbeeldingen en 10.000 testafbeeldingen. Als probleem met afbeeldingsclassificatie is Fashion MNIST lastiger dan de klassieke met de hand geschreven MNIST-database. Het wordt gedistribueerd in dezelfde gecomprimeerde binaire vorm als de oorspronkelijke handgeschreven cijferdatabase.

Door een Inputte definiëren, maakt u een verwijzing naar de locatie van de gegevensbron. De gegevens blijven bewaard op de bestaande locatie, dus maakt u geen extra opslagkosten.

Onderdelen maken voor het bouwen van de pijplijn

De taak voor afbeeldingsclassificatie kan worden gesplitst in drie stappen: gegevens voorbereiden, het model trainen en het model beoordelen.

Een Azure Machine Learning-onderdeel is een zelfstandig stukje code dat één stap in een machine learning-pijplijn voltooit. In dit artikel maakt u drie onderdelen voor de taak voor afbeeldingsclassificatie:

• Bereid gegevens voor op training en test deze.
• Train een neuraal netwerk voor afbeeldingsclassificatie met behulp van trainingsgegevens.
• Score het model met behulp van testgegevens.

Voor elk onderdeel moet u deze stappen uitvoeren:

1. Bereid het Python-script voor dat de uitvoeringslogica bevat.

2. Definieer de interface van het onderdeel.

3. Voeg andere metagegevens van het onderdeel toe, inclusief de runtime-omgeving en de opdracht om het onderdeel uit te voeren.

In de volgende sectie ziet u hoe u de onderdelen op twee manieren maakt. Voor de eerste twee onderdelen gebruikt u een Python-functie. Voor het derde onderdeel gebruikt u de YAML-definitie.

Het onderdeel voor gegevensvoorbereiding maken

Het eerste onderdeel in deze pijplijn converteert de gecomprimeerde gegevensbestanden van fashion_ds twee .csv bestanden, één voor training en het andere voor scoren. U gebruikt een Python-functie om dit onderdeel te definiëren.

Als u het voorbeeld in de opslagplaats met Voorbeelden van Azure Machine Learning volgt, zijn de bronbestanden al beschikbaar in de prep map. Deze map bevat twee bestanden om het onderdeel samen te stellen: prep_component.py, waarmee het onderdeel wordt gedefinieerd en conda.yaml, waarmee de runtime-omgeving van het onderdeel wordt gedefinieerd.

Onderdeel definiëren met behulp van een Python-functie

Met behulp van de command_component() functie als decorator kunt u eenvoudig de interface van het onderdeel, de metagegevens en de code definiëren die moet worden uitgevoerd vanuit een Python-functie. Elke gedecoreerde Python-functie wordt omgezet in één statische specificatie (YAML-bestand) die de pijplijnservice kan verwerken.

# Converts MNIST-formatted files at the passed-in input path to training data output path and test data output path
import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="prep_data",
    version="1",
    display_name="Prep Data",
    description="Convert data to CSV file, and split to training and test data",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def prepare_data_component(
    input_data: Input(type="uri_folder"),
    training_data: Output(type="uri_folder"),
    test_data: Output(type="uri_folder"),
):
    convert(
        os.path.join(input_data, "train-images-idx3-ubyte"),
        os.path.join(input_data, "train-labels-idx1-ubyte"),
        os.path.join(training_data, "mnist_train.csv"),
        60000,
    )
    convert(
        os.path.join(input_data, "t10k-images-idx3-ubyte"),
        os.path.join(input_data, "t10k-labels-idx1-ubyte"),
        os.path.join(test_data, "mnist_test.csv"),
        10000,
    )


def convert(imgf, labelf, outf, n):
    f = open(imgf, "rb")
    l = open(labelf, "rb")
    o = open(outf, "w")

    f.read(16)
    l.read(8)
    images = []

    for i in range(n):
        image = [ord(l.read(1))]
        for j in range(28 * 28):
            image.append(ord(f.read(1)))
        images.append(image)

    for image in images:
        o.write(",".join(str(pix) for pix in image) + "\n")
    f.close()
    o.close()
    l.close()

De voorgaande code definieert een onderdeel met weergavenaam Prep Data met behulp van de @command_component decorator:

• name is de unieke id van het onderdeel.

• version is de huidige versie van het onderdeel. Een onderdeel kan meerdere versies hebben.

• display_name is een beschrijvende weergavenaam van het onderdeel voor de gebruikersinterface. Het is niet uniek.

• description beschrijft meestal de taak die het onderdeel kan voltooien.

• environment hiermee geeft u de runtime-omgeving voor het onderdeel. De omgeving van dit component specificeert een Docker-image en verwijst naar het conda.yaml bestand.

  Het conda.yaml bestand bevat alle pakketten die voor het onderdeel worden gebruikt:

  name: imagekeras_prep_conda_env
  channels:
    - defaults
  dependencies:
    - python=3.7.11
    - pip=20.0
    - pip:
      - mldesigner==0.1.0b4
  

• De prepare_data_component functie definieert één invoer voor en twee uitvoer voor input_datatraining_data en test_data. input_data is het pad naar invoergegevens. training_data en test_data zijn uitvoergegevenspaden voor trainingsgegevens en testgegevens.

• Het onderdeel converteert de gegevens van input_data naar een training_data .csv om gegevens te trainen en naar een test_data .csv om gegevens te testen.

Dit is hoe een onderdeel eruitziet in de gebruikersinterface van studio:

• Een onderdeel is een blok in een pijplijngrafiek.
• input_data, training_dataen test_data zijn poorten van het onderdeel, die verbinding maken met andere onderdelen voor het streamen van gegevens.

U hebt nu alle bronbestanden voor het Prep Data onderdeel voorbereid.

Het modeltrainingsonderdeel maken

In deze sectie maakt u een onderdeel voor het trainen van het model voor afbeeldingsclassificatie in een Python-functie, net als bij het Prep Data onderdeel.

Omdat de trainingslogica ingewikkelder is, plaatst u de trainingscode in een afzonderlijk Python-bestand.

De bronbestanden voor dit onderdeel bevinden zich in de train map in de opslagplaats met Voorbeelden van Azure Machine Learning. Deze map bevat drie bestanden om het onderdeel samen te stellen:

• train.py bevat de logica voor het trainen van het model.
• train_component.py definieert de interface van het onderdeel en importeert de functie die zich in train.py.
• conda.yaml definieert de runtime-omgeving van het onderdeel.

Een script ophalen dat de logica bevat

Het train.py bestand bevat een normale Python-functie die de logica uitvoert voor het trainen van een Keras-neuraal netwerk voor afbeeldingsclassificatie. Zie het train.py-bestand op GitHub om de code weer te geven.

Het onderdeel definiëren met behulp van een Python-functie

Nadat u de trainingsfunctie hebt gedefinieerd, kunt @command_component u in de Azure Machine Learning SDK v2 uw functie verpakken als onderdeel dat kan worden gebruikt in Azure Machine Learning-pijplijnen:

import os
from pathlib import Path
from mldesigner import command_component, Input, Output


@command_component(
    name="train_image_classification_keras",
    version="1",
    display_name="Train Image Classification Keras",
    description="train image classification with keras",
    environment=dict(
        conda_file=Path(__file__).parent / "conda.yaml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
)
def keras_train_component(
    input_data: Input(type="uri_folder"),
    output_model: Output(type="uri_folder"),
    epochs=10,
):
    # avoid dependency issue, execution logic is in train() func in train.py file
    from train import train

    train(input_data, output_model, epochs)

De voorgaande code definieert een onderdeel met weergavenaam Train Image Classification Keras met behulp van @command_component.

• De keras_train_component functie definieert één invoer, input_datavoor brontrainingsgegevens, één invoer, epochswaarmee het aantal tijdvakken wordt opgegeven dat tijdens de training moet worden gebruikt en één uitvoer, output_modelwaarmee het uitvoerpad voor het modelbestand wordt opgegeven. De standaardwaarde is epochs 10. De logica van dit onderdeel is afkomstig van de train() functie in train.py.

Het treinmodelcomponent heeft een iets complexere configuratie dan het gegevens voorbereiden component. Het conda.yaml ziet er als volgt uit:

name: imagekeras_train_conda_env
channels:
  - defaults
dependencies:
  - python=3.8
  - pip=20.2
  - pip:
    - mldesigner==0.1.0b12
    - azureml-mlflow==1.50.0
    - tensorflow==2.7.0
    - numpy==1.21.4
    - scikit-learn==1.0.1
    - pandas==1.3.4
    - matplotlib==3.2.2
    - protobuf==3.20.0

U hebt nu alle bronbestanden voor het Train Image Classification Keras onderdeel voorbereid.

Het modelscoreonderdeel maken

In deze sectie maakt u een onderdeel om het getrainde model te scoren via YAML-specificatie en -script.

Als u het voorbeeld in de opslagplaats met Voorbeelden van Azure Machine Learning volgt, zijn de bronbestanden al beschikbaar in de score map. Deze map bevat drie bestanden om het onderdeel samen te stellen:

• score.py bevat de broncode van het onderdeel.
• score.yaml definieert de interface en andere details van het onderdeel.
• conda.yaml definieert de runtime-omgeving van het onderdeel.

Een script ophalen dat de logica bevat

Het score.py bestand bevat een normale Python-functie waarmee de logica van het trainingsmodel wordt uitgevoerd:

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

import argparse
from pathlib import Path
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import mlflow


def get_file(f):

    f = Path(f)
    if f.is_file():
        return f
    else:
        files = list(f.iterdir())
        if len(files) == 1:
            return files[0]
        else:
            raise Exception("********This path contains more than one file*******")


def parse_args():
    # setup argparse
    parser = argparse.ArgumentParser()

    # add arguments
    parser.add_argument(
        "--input_data", type=str, help="path containing data for scoring"
    )
    parser.add_argument(
        "--input_model", type=str, default="./", help="input path for model"
    )

    parser.add_argument(
        "--output_result", type=str, default="./", help="output path for model"
    )

    # parse args
    args = parser.parse_args()

    # return args
    return args


def score(input_data, input_model, output_result):

    test_file = get_file(input_data)
    data_test = pd.read_csv(test_file, header=None)

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

    # Read test data
    X_test = np.array(data_test.iloc[:, 1:])
    y_test = to_categorical(np.array(data_test.iloc[:, 0]))
    X_test = (
        X_test.reshape(X_test.shape[0], img_rows, img_cols, 1).astype("float32") / 255
    )

    # Load model
    files = [f for f in os.listdir(input_model) if f.endswith(".h5")]
    model = load_model(input_model + "/" + files[0])

    # Log metrics of the model
    eval = model.evaluate(X_test, y_test, verbose=0)

    mlflow.log_metric("Final test loss", eval[0])
    print("Test loss:", eval[0])

    mlflow.log_metric("Final test accuracy", eval[1])
    print("Test accuracy:", eval[1])

    # Score model using test data
    y_predict = model.predict(X_test)
    y_result = np.argmax(y_predict, axis=1)

    # Output result
    np.savetxt(output_result + "/predict_result.csv", y_result, delimiter=",")


def main(args):
    score(args.input_data, args.input_model, args.output_result)


# run script
if __name__ == "__main__":
    # parse args
    args = parse_args()

    # call main function
    main(args)

De code in score.py neemt drie opdrachtregelargumenten aan: input_data, input_model en output_result. Het programma beoordeelt het invoermodel met behulp van invoergegevens en voert vervolgens het resultaat uit.

Het onderdeel definiëren via YAML

In deze sectie leert u hoe u een onderdeelspecificatie maakt in de geldige indeling van de YAML-onderdeelspecificatie. Dit bestand geeft de volgende informatie op:

• Metagegevens. Naam, weergavenaam, versie, type, enzovoort.
• Interface. Invoer en uitvoer.
• Opdracht, code en omgeving. De opdracht, code en omgeving die worden gebruikt om het onderdeel uit te voeren.

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: score_image_classification_keras
display_name: Score Image Classification Keras
inputs:
  input_data: 
    type: uri_folder
  input_model:
    type: uri_folder
outputs:
  output_result:
    type: uri_folder
code: ./
command: python score.py --input_data ${{inputs.input_data}} --input_model ${{inputs.input_model}} --output_result ${{outputs.output_result}}
environment:
  conda_file: ./conda.yaml
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04

• name is de unieke id van het onderdeel. De weergavenaam is Score Image Classification Keras.
• Dit onderdeel heeft twee invoer en één uitvoer.
• Het broncodepad wordt gedefinieerd in de code sectie. Wanneer het onderdeel wordt uitgevoerd in de cloud, worden alle bestanden van dat pad geüpload als momentopname van het onderdeel.
• In command de sectie wordt de opdracht opgegeven die moet worden uitgevoerd wanneer het onderdeel wordt uitgevoerd.
• De environment sectie bevat een Docker-image en een conda YAML-bestand. Het bronbestand bevindt zich in de voorbeeldopslagplaats.

U hebt nu alle bronbestanden voor het score-onderdeel van het model.

De onderdelen laden om een pijplijn te bouwen

U kunt het gegevensvoorbereidingsonderdeel en het modeltrainingsonderdeel, die zijn gedefinieerd door Python-functies, importeren, net zoals normale Python-functies.

Met de volgende code importeert u respectievelijk de prepare_data_component() en keras_train_component() functies uit het prep_component.py bestand in de prep map en het train_component bestand in de train map.

%load_ext autoreload
%autoreload 2

# load component function from component python file
from prep.prep_component import prepare_data_component
from train.train_component import keras_train_component

# print hint of components
help(prepare_data_component)
help(keras_train_component)

U kunt de load_component() functie gebruiken om het scoreonderdeel te laden. Dit wordt gedefinieerd door YAML.

# load component function from yaml
keras_score_component = load_component(source="./score/score.yaml")

Uw pijplijn bouwen

U hebt alle onderdelen en invoergegevens gemaakt en geladen om de pijplijn te bouwen. U kunt deze nu samenstellen in een pijplijn:

Notitie

Als u serverloze berekeningen wilt gebruiken, voegt u deze from azure.ai.ml.entities import ResourceConfiguration toe aan het begin van het bestand. Vervang vervolgens:

• default_compute=cpu_compute_target met default_compute="serverless".
• train_node.compute = gpu_compute_target met train_node.resources = "ResourceConfiguration(instance_type="Standard_NC6s_v3",instance_count=2).

# define a pipeline containing 3 nodes: Prepare data node, train node, and score node
@pipeline(
    default_compute=cpu_compute_target,
)
def image_classification_keras_minist_convnet(pipeline_input_data):
    """E2E image classification pipeline with keras using python sdk."""
    prepare_data_node = prepare_data_component(input_data=pipeline_input_data)

    train_node = keras_train_component(
        input_data=prepare_data_node.outputs.training_data
    )
    train_node.compute = gpu_compute_target

    score_node = keras_score_component(
        input_data=prepare_data_node.outputs.test_data,
        input_model=train_node.outputs.output_model,
    )


# create a pipeline
pipeline_job = image_classification_keras_minist_convnet(pipeline_input_data=mnist_ds)

De pijplijn heeft een standaardrekenproces cpu_compute_target. Als u geen rekenkracht opgeeft voor een specifiek knooppunt, wordt dat knooppunt uitgevoerd op de standaard rekenkracht.

De pijplijn heeft een invoer op pijplijnniveau, pipeline_input_data. U kunt een waarde toewijzen aan pijplijninvoer wanneer u een pijplijntaak verzendt.

De pijplijn bevat drie knooppunten: prepare_data_node, train_nodeen score_node.

• De input_data van prepare_data_node gebruikt de waarde van pipeline_input_data.

• De input_data van train_node is de training_data uitvoer van prepare_data_node.

• De input_data van score_node is de test_data uitvoer van prepare_data_node, en de input_model is de output_model van train_node.

• Omdat train_node u een CNN-model traint, kunt u de berekening opgeven als de gpu_compute_target. Hierdoor kunnen de trainingsprestaties worden verbeterd.

Uw pijplijntaak verzenden

Nu u de pijplijn hebt gemaakt, kunt u de taak verzenden naar uw werkruimte. Als u een taak wilt verzenden, moet u eerst verbinding maken met een werkruimte.

Toegang krijgen tot uw werkruimte

Inloggegevens configureren

U gebruikt DefaultAzureCredential dit om toegang te krijgen tot de werkruimte. DefaultAzureCredential moet in staat zijn om de meeste Azure SDK-verificatiescenario's af te handelen.

Als DefaultAzureCredential niet voor u werkt, bekijkt u dit configuratievoorbeeld en het identity package.

try:
    credential = DefaultAzureCredential()
    # Check if given credential can get token successfully.
    credential.get_token("https://management.azure.com/.default")
except Exception as ex:
    # Fall back to InteractiveBrowserCredential in case DefaultAzureCredential not work
    credential = InteractiveBrowserCredential()

Een ingang ophalen naar een werkruimte met rekenkracht

Maak een MLClient object voor het beheren van Azure Machine Learning-services. Als u serverloze berekeningen gebruikt, hoeft u deze berekeningen niet te maken.

# Get a handle to workspace
ml_client = MLClient.from_config(credential=credential)

# Retrieve an already attached Azure Machine Learning Compute.
cpu_compute_target = "cpu-cluster"
print(ml_client.compute.get(cpu_compute_target))
gpu_compute_target = "gpu-cluster"
print(ml_client.compute.get(gpu_compute_target))

Belangrijk

In dit codefragment wordt verwacht dat het JSON-bestand van de werkruimteconfiguratie wordt opgeslagen in de huidige map of het bovenliggende bestand. Zie Werkruimteresources maken voor meer informatie over het maken van een werkruimte. Zie Een werkruimteconfiguratiebestand maken voor meer informatie over het opslaan van de configuratie in een bestand.

De pijplijntaak verzenden naar de werkruimte

Nu u controle hebt over uw werkruimte, kunt u uw pipeline taak verzenden.

pipeline_job = ml_client.jobs.create_or_update(
    pipeline_job, experiment_name="pipeline_samples"
)
pipeline_job

Met de voorgaande code wordt deze pijplijntaak voor afbeeldingsclassificatie verzonden naar een experiment met de naam pipeline_samples. Het experiment wordt automatisch gemaakt als het niet bestaat. pipeline_input_data gebruikt fashion_ds.

De aanroep om het experiment in te dienen, wordt snel voltooid. Het produceert uitvoer die vergelijkbaar is met:

Experiment	Naam	Typologie	Toestand	Detailpagina
pipeline_samples	sharp_pipe_4gvqx6h1fb	pijpleiding	Voorbereiden	Koppeling naar Azure Machine Learning-studio.

U kunt de pijplijnuitvoering controleren door de koppeling te selecteren. U kunt deze ook blokkeren totdat deze is voltooid door deze code uit te voeren:

# wait until the job completes
ml_client.jobs.stream(pipeline_job.name)

Belangrijk

De eerste pijplijnuitvoering duurt ongeveer 15 minuten. Alle afhankelijkheden worden gedownload, er wordt een Docker-afbeelding 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 workload van uw scripts en de processen die in elke pijplijnstap worden uitgevoerd.

Uitvoer controleren en fouten opsporen in uw pijplijn in de gebruikersinterface

U kunt de Link to Azure Machine Learning studiopagina met taakdetails van uw pijplijn selecteren. U ziet de pijplijngrafiek:

U kunt de logboeken en uitvoer van elk onderdeel controleren door met de rechtermuisknop op het onderdeel te klikken of het onderdeel te selecteren om het detailvenster te openen. Zie Azure Machine Learning Studio gebruiken om fouten in pijplijnen op te sporen voor meer informatie over het opsporen van fouten in uw pijplijn in de gebruikersinterface.

(Optioneel) Onderdelen registreren in de werkruimte

In de vorige sectie hebt u een pijplijn gemaakt met behulp van drie onderdelen om een afbeeldingsclassificatietaak te voltooien. U kunt onderdelen ook registreren bij uw werkruimte, zodat ze kunnen worden gedeeld en opnieuw kunnen worden gebruikt in de werkruimte. In het volgende voorbeeld ziet u hoe u het gegevensvoorbereidingsonderdeel registreert:

try:
    # try get back the component
    prep = ml_client.components.get(name="prep_data", version="1")
except:
    # if not exists, register component using following code
    prep = ml_client.components.create_or_update(prepare_data_component)

# list all components registered in workspace
for c in ml_client.components.list():
    print(c)

U kunt ml_client.components.get() een geregistreerd onderdeel ophalen via naam en versie. U kunt een ml_client.components.create_or_update() onderdeel registreren dat eerder is geladen vanuit een Python-functie of YAML.

Volgende stappen

• Zie de voorbeeldopslagplaats voor meer voorbeelden van het bouwen van pijplijnen met behulp van de Machine Learning SDK.
• Zie Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen in Azure Machine Learning Studio voor meer informatie over het gebruik van de gebruikersinterface van Studio om een pijplijn te verzenden en fouten op te sporen.
• Zie Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Azure Machine Learning CLI voor meer informatie over het gebruik van de Azure Machine Learning CLI om onderdelen en pijplijnen te maken.
• Zie Pijplijnen met batcheindpunten implementeren voor informatie over het implementeren van pijplijnen in productie met behulp van batcheindpunten.