Machine Learning-pijplijnen maken en uitvoeren met behulp van onderdelen met de Azure 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 Python SDK v2 om een taak voor afbeeldingsclassificatie te voltooien met drie stappen: gegevens voorbereiden, een afbeeldingsclassificatiemodel trainen en het model beoordelen. 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 . De pijplijn ziet er als volgt uit.

In dit artikel voert u de volgende taken uit:

• Invoergegevens voorbereiden voor de pijplijntaak
• Drie onderdelen maken om de gegevens voor te bereiden, te trainen en te scoren
• Een pijplijn samenstellen van de onderdelen
• Toegang krijgen tot de werkruimte met compute
• De pijplijntaak verzenden
• Controleer de uitvoer van de onderdelen en het getrainde neurale netwerk
• (Optioneel) Het onderdeel registreren 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

• Azure Machine Learning-werkruimte: als u er nog geen hebt, voltooit u de zelfstudie Resources maken.

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

• Opslagplaats met kloonvoorbeelden

  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 Python SDK voor Azure Machine Learning gebruikt om een Azure Machine Learning-pijplijn te maken en te beheren. In het artikel wordt ervan uitgegaan dat u de codefragmenten interactief uitvoert in een Python REPL-omgeving of een Jupyter-notebook.

Dit artikel is gebaseerd op het image_classification_keras_minist_convnet.ipynb-notebook in de map van de sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet opslagplaats azure Machine Learning-voorbeelden .

Vereiste bibliotheken importeren

Importeer alle vereiste bibliotheken voor Azure Machine Learning 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 deze pijplijn voor afbeeldingsclassificatie.

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.

Importeer alle vereiste bibliotheken voor Azure Machine Learning die u nodig hebt.

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 een pijplijn

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

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

• Gegevens voorbereiden voor training en testen
• Een neuraal netwerk trainen voor afbeeldingsclassificatie met behulp van trainingsgegevens
• Het model beoordelen met behulp van testgegevens

Voor elk onderdeel moet u het volgende voorbereiden:

1. Het Python-script voorbereiden met de uitvoeringslogica

2. De interface van het onderdeel definiëren

3. Voeg andere metagegevens van het onderdeel toe, inclusief runtimeomgeving, opdracht om het onderdeel uit te voeren, enzovoort.

In de volgende sectie worden de onderdelen voor het maken op twee verschillende manieren weergegeven: de eerste twee onderdelen met behulp van de Python-functie en het derde onderdeel met behulp van de YAML-definitie.

Het gegevensvoorbereidingsonderdeel maken

Het eerste onderdeel in deze pijplijn converteert de gecomprimeerde gegevensbestanden naar fashion_ds twee CSV-bestanden, één voor training en de andere voor scoren. U gebruikt de 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 prep/ de 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 de Python-functie

Door de functie als decorator te gebruiken command_component() , kunt u eenvoudig de interface, metagegevens en code van het onderdeel definiëren om uit te voeren vanuit een Python-functie. Elke ingerichte Python-functie wordt omgezet in één statische specificatie (YAML) 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 bovenstaande code definieert een onderdeel met weergavenaam Prep Data met behulp van @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 in de gebruikersinterface, wat niet uniek is.

• description beschrijft meestal welke taak dit onderdeel kan voltooien.

• environment hiermee geeft u de runtime-omgeving voor dit onderdeel. De omgeving van dit onderdeel geeft een docker-installatiekopieën op en verwijst naar het conda.yaml bestand.

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

  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 training_data input_data en test_data. input_data is invoergegevenspad. training_data en test_data zijn uitvoergegevenspaden voor trainingsgegevens en testgegevens.

• Met dit onderdeel worden de gegevens geconverteerd naar input_data een csv-bestand met trainingsgegevens naar training_data en een CSV-testgegevens naar test_data.

Hieronder ziet u hoe een onderdeel eruitziet in de gebruikersinterface van studio.

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

Nu hebt u alle bronbestanden voor het Prep Data onderdeel voorbereid.

Het onderdeel train-model maken

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

Het verschil is dat omdat de trainingslogica ingewikkelder is, u de oorspronkelijke trainingscode in een afzonderlijk Python-bestand kunt plaatsen.

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

• train.py: bevat de werkelijke logica om het model te trainen.
• train_component.py: definieert de interface van het onderdeel en importeert de functie in train.py.
• conda.yaml: definieert de runtime-omgeving van het onderdeel.

Een script ophalen met uitvoeringslogica

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

Onderdeel definiëren met behulp van de Python-functie

Nadat u de trainingsfunctie hebt gedefinieerd, kunt u in Azure Machine Learning SDK v2 uw @command_component 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 bovenstaande code definieert een onderdeel met weergavenaam Train Image Classification Keras met behulp van @command_component:

• De keras_train_component functie definieert één invoer input_data waaruit trainingsgegevens afkomstig zijn, één invoer epochs die epochs opgeeft tijdens de training en één uitvoer output_model waarin het modelbestand wordt uitgevoerd. De standaardwaarde is epochs 10. De uitvoeringslogica van dit onderdeel is van train() de bovenstaande functie train.py .

Het onderdeel train-model heeft een iets complexere configuratie dan het prep-gegevensonderdeel. Dit 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

Nu hebt u alle bronbestanden voor het Train Image Classification Keras onderdeel voorbereid.

Het onderdeel scoremodel maken

In deze sectie, met uitzondering van de vorige onderdelen, 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 score/ de 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 met uitvoeringslogica

Het score.py bestand bevat een normale Python-functie die de logica van het trainingsmodel uitvoert.

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 heeft drie opdrachtregelargumenten: input_dataen input_model output_result. Het programma scoret het invoermodel met behulp van invoergegevens en voert vervolgens het scoreresultaat uit.

Onderdeel definiëren via Yaml

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

• Metagegevens: naam, display_name, versie, type, enzovoort.
• Interface: invoer en uitvoer
• Opdracht, code, & omgeving: de opdracht, code en omgeving die wordt 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 ervan wordt gedefinieerd in de sectie en wanneer het onderdeel wordt uitgevoerd in de code cloud, worden alle bestanden van dat pad geüpload als momentopname van dit onderdeel.
• In command de sectie wordt de opdracht opgegeven die moet worden uitgevoerd tijdens het uitvoeren van dit onderdeel.
• De environment sectie bevat een docker-installatiekopieën en een conda yaml-bestand. Het bronbestand bevindt zich in de voorbeeldopslagplaats.

U hebt nu alle bronbestanden voor het scoremodelonderdeel.

Onderdelen laden om een pijplijn te bouwen

Voor het voorbereiden van gegevensonderdelen en het trainmodelonderdeel dat is gedefinieerd door de Python-functie, kunt u de onderdelen net als normale Python-functies importeren.

In de volgende code importeert prepare_data_component() en keras_train_component() werkt u uit het bestand onder prep respectievelijk map prep_component.py en train_component bestand onder 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)

Voor het scoreonderdeel dat is gedefinieerd door yaml, kunt u de functie gebruiken load_component() om te laden.

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

Uw pijplijn bouwen

Nu u alle onderdelen en invoergegevens hebt gemaakt en geladen om de pijplijn te bouwen. U kunt ze samenstellen in een pijplijn:

Notitie

Als u serverloze berekeningen wilt gebruiken, voegt from azure.ai.ml.entities import ResourceConfiguration u deze toe aan de bovenkant. 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 standaard berekenen cpu_compute_target, wat betekent dat als u geen rekenkracht opgeeft voor een specifiek knooppunt, dat knooppunt wordt uitgevoerd op de standaard compute.

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

De pijplijn bevat drie knooppunten, prepare_data_node, train_node en score_node.

• De input_data waarde prepare_data_node van pipeline_input_data.

• De input_data of train_node is afkomstig uit de training_data uitvoer van de prepare_data_node.

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

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

Uw pijplijntaak verzenden

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

Toegang krijgen tot uw werkruimte

Referentie configureren

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

Naslaginformatie voor meer beschikbare referenties als dit niet voor u werkt: referentievoorbeeld configureren, referentiedocument voor Azure-identity.

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 configuratiebestand voor een werkruimte maken voor meer informatie over de configuratie als bestand opslaan.

Pijplijntaak verzenden naar werkruimte

U hebt nu een ingang voor uw werkruimte. U kunt uw pijplijntaak verzenden.

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

De bovenstaande code verzendt deze pijplijntaak voor afbeeldingsclassificatie om te experimenteren met de naam pipeline_samples. Het experiment wordt automatisch gemaakt als dit niet bestaat. Het pipeline_input_data gebruik .fashion_ds

De aanroep om uitvoer te pipeline_jobproduceren die vergelijkbaar is met:

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

Experiment	Name	Type	Status	De pagina met details
pipeline_samples	sharp_pipe_4gvqx6h1fb	pijpleiding	Voorbereiden	Koppeling naar Azure Machine Learning-studio.

U kunt de pijplijnuitvoering controleren door de koppeling te openen of u kunt blokkeren totdat deze is voltooid door het volgende 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 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.

Uitvoer uitchecken en fouten opsporen in uw pijplijn in de gebruikersinterface

U kunt de Link to Azure Machine Learning studiopagina met taakdetails van uw pijplijn openen. U ziet de pijplijngrafiek als volgt.

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 Fouten in pijplijnfouten gebruiken voor meer informatie over het opsporen van fouten in uw pijplijn in de gebruikersinterface.

(Optioneel) Onderdelen registreren bij 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 in de werkruimte kunnen worden teruggezet. Hieronder volgt een voorbeeld voor het registreren van een prep-gegevensonderdeel.

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)

Met behulp van ml_client.components.get(), kunt u een geregistreerd onderdeel op naam en versie ophalen. Met behulp van ml_client.components.create_or_update()kunt u een onderdeel registreren dat eerder is geladen vanuit de Python-functie of yaml.

Volgende stappen

• Zie de voorbeeldopslagplaats voor meer voorbeelden van het bouwen van pijplijnen met behulp van de Machine Learning SDK.
• Raadpleeg hoe u pijplijnen maakt met behulp van een onderdeel in de gebruikersinterface van Studio voor het verzenden en opsporen van fouten in uw pijplijn.
• Voor informatie over het gebruik van Azure Machine Learning CLI voor het maken van onderdelen en pijplijnen, raadpleegt u hoe u pijplijnen maakt met behulp van een onderdeel met CLI.
• Zie hoe u pijplijnen implementeert in productie met behulp van Batch-eindpunten , hoe u pijplijnen met batch-eindpunten implementeert.