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 de Azure Machine Learning Python SDK v2 om een taak voor afbeeldingsclassificatie te voltooien. Deze pijplijn bevat 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 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:

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 waarop Azure Machine Learning Python SDK v2 is 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. 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 sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet map van de opslagplaats met Azure Machine Learning-voorbeelden .

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 modeafbeeldingen die zijn onderverdeeld in 10 klassen. Elke afbeelding is een 28 x 28 grijswaardenbeeld. Er zijn 60.000 trainingsafbeeldingen en 10.000 testafbeeldingen.

import urllib3
import shutil
import gzip
import os
from pathlib import Path
from azure.ai.ml import Input

base_url = "https://azureopendatastorage.blob.core.windows.net/mnist/"
base_dir = Path("mnist")
if not base_dir.exists():
    base_dir.mkdir(parents=True)

c = urllib3.PoolManager()
for target_file in [
    "train-images-idx3-ubyte.gz",
    "train-labels-idx1-ubyte.gz",
    "t10k-images-idx3-ubyte.gz",
    "t10k-labels-idx1-ubyte.gz",
]:
    if (base_dir / target_file[:-3]).exists():
        continue
    with c.request("GET", base_url + target_file, preload_content=False) as resp, open(
        base_dir / target_file, "wb"
    ) as out_file:
        shutil.copyfileobj(resp, out_file)
        resp.release_conn()
    with gzip.open(base_dir / target_file, "rb") as f_in, open(
        base_dir / target_file[:-3], "wb"
    ) as f_out:
        shutil.copyfileobj(f_in, f_out)
    os.unlink(base_dir / target_file)

mnist_ds = Input(path=base_dir.as_posix())

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:

• 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 voert u de volgende stappen uit:

1. Het Python-script voorbereiden dat de uitvoeringslogica bevat
2. De interface van het onderdeel definiëren
3. Voeg andere metagegevens van het onderdeel toe, inclusief de runtime-omgeving en de opdracht om het onderdeel uit te voeren

In de volgende secties 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) 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 gebruiksvriendelijke weergavenaam van het onderdeel voor de UI

• description beschrijft de taak die het onderdeel kan voltooien

• environment hiermee geeft u de runtime-omgeving voor het onderdeel met behulp van een 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 input_data en twee uitvoer voor training_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-bestand voor trainingsgegevens en een test_data .csv-bestand voor testgegevens.

In de gebruikersinterface van studio wordt een onderdeel weergegeven als:

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

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 met behulp van een Python-functie, net als bij het Prep Data onderdeel.

Omdat de trainingslogica complexer 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 uit 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 voor gebruik 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:

• Eén invoer, input_datavoor brontrainingsgegevens
• Eén invoer, epochswaarmee het aantal tijdvakken wordt opgegeven dat tijdens de training moet worden gebruikt
• Eé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 trainmodelonderdeel heeft een complexere configuratie dan het onderdeel gegevensvoorbereiding. 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 met behulp van 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 modelscorelogica 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 met 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 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 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")

Geregistreerde componenten laden vanuit de werkruimte

Als u onderdelen hebt die al zijn geregistreerd in uw werkruimte, kunt u ze rechtstreeks laden met behulp van de ml_client.components.get() methode. Deze aanpak is handig als u onderdelen die eerder door u zijn geregistreerd of die door andere teamleden zijn geregistreerd, opnieuw wilt gebruiken.

# Load a registered component by name and version
registered_component = ml_client.components.get(
    name="my_registered_component", 
    version="1.0.0"
)

# Load the latest version of a registered component
latest_component = ml_client.components.get(
    name="my_registered_component"
)

U kunt alle beschikbare onderdelen in uw werkruimte weergeven om de onderdelen te vinden die u nodig hebt:

# List all components in the workspace
components = ml_client.components.list()
for component in components:
    print(f"Name: {component.name}, Version: {component.version}")

Zodra het bestand is geladen, kunt u geregistreerde onderdelen in uw pijplijn gebruiken, net zoals onderdelen die zijn geladen vanuit lokale bestanden of Python-functies.

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:

# 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 of 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 een CNN-model traint, kunt u de rekenkracht specificeren voor gpu_compute_target om de trainingsprestaties te verbeteren.

Uw pijplijntaak verzenden

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

Toegang krijgen tot uw werkruimte

Inloggegevens configureren

U gebruikt DefaultAzureCredential 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))

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 voor het verzenden van het experiment wordt snel voltooid en produceert uitvoer die er ongeveer als volgt uit ziet:

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

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

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 secties hebt u een pijplijn gemaakt met 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 met 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 implementeren met batcheindpunten voor meer informatie over het implementeren van pijplijnen in productie met behulp van batch-eindpunten