Creare ed eseguire pipeline di Machine Learning usando componenti con Azure Machine Learning SDK v2

SI APPLICA A: Python SDK azure-ai-ml v2 (corrente)

Questo articolo illustra come creare una pipeline di Azure Machine Learning usando Azure Machine Learning Python SDK v2 per completare un'attività di classificazione delle immagini. Questa pipeline contiene tre passaggi: preparare i dati, eseguire il training di un modello di classificazione delle immagini e assegnare un punteggio al modello. Le pipeline di Machine Learning ottimizzano il flusso di lavoro con velocità, portabilità e riutilizzo, in modo da potersi concentrare sull'apprendimento automatico anziché sull'infrastruttura e sull'automazione.

La pipeline di esempio addestra una piccola rete neurale convoluzionale Keras per classificare le immagini nel dataset Fashion MNIST. La pipeline ha un aspetto simile al seguente:

In questo articolo vengono completate le attività seguenti:

• Preparare i dati di input per il processo della pipeline
• Creare tre componenti per preparare i dati, eseguire il training di un modello e assegnare un punteggio al modello
• Creare una pipeline dai componenti
• Ottenere l'accesso a un'area di lavoro con capacità di calcolo
• Inviare il processo della pipeline
• Esaminare l'output dei componenti e della rete neurale addestrata
• (Facoltativo) Registrare il componente per riutilizzare e condividere ulteriormente all'interno dell'area di lavoro

Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare. Provare la versione gratuita o a pagamento di Azure Machine Learning.

Prerequisiti

• Un'area di lavoro di Azure Machine Learning. Se non ne hai uno, completa l'esercitazione Creare risorse.
• Un ambiente Python con Python SDK v2 di Azure Machine Learning installato. Per istruzioni sull'installazione, vedere Introduzione. Questo ambiente serve per definire e controllare le risorse di Azure Machine Learning ed è separato dall'ambiente utilizzato in fase di esecuzione per il training.
• Un clone del repository di esempi.

Per eseguire gli esempi di training, clonare innanzitutto il repository di esempi e passare alla sdk directory :

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

Avviare una sessione Interattiva di Python

Questo articolo usa Azure Machine Learning Python SDK per creare e controllare una pipeline di Azure Machine Learning. L'articolo presuppone che i frammenti di codice siano eseguiti in modo interattivo in un ambiente PYTHON REPL o in un notebook jupyter.

Questo articolo si basa sul notebook image_classification_keras_minist_convnet.ipynb nella directory sdk/python/jobs/pipelines/2e_image_classification_keras_minist_convnet del repository degli esempi di Azure Machine Learning.

Importare le librerie obbligatorie

Importare tutte le librerie di Azure Machine Learning necessarie per questo articolo:

# 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

Preparare i dati di input per il processo della pipeline

È necessario preparare i dati di input per la pipeline di classificazione delle immagini.

Fashion MNIST è un set di dati di immagini di moda suddivise in 10 classi. Ogni immagine è un'immagine 28 x 28 in tonalità di grigio. Sono disponibili 60.000 immagini di training e 10.000 immagini di test.

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

Definendo un Input, si crea un riferimento al percorso dell'origine dati. I dati rimangono nell'attuale posizione, quindi non si incorre in costi aggiuntivi di archiviazione.

Creare componenti per la compilazione della pipeline

L'attività di classificazione delle immagini può essere suddivisa in tre passaggi: preparare i dati, eseguire il training del modello e assegnare un punteggio al modello.

Un componente di Azure Machine Learning è un frammento di codice autonomo che completa un passaggio in una pipeline di Machine Learning. In questo articolo vengono creati tre componenti per l'attività di classificazione delle immagini:

• Preparare i dati per il training e il test
• Addestrare una rete neurale per la classificazione di immagini usando i dati di addestramento
• Assegnare un punteggio al modello usando i dati di test

Per ogni componente, completare questi passaggi:

1. Preparare lo script Python che contiene la logica di esecuzione
2. Definire l'interfaccia del componente
3. Aggiungere altri metadati del componente, inclusi l'ambiente di runtime e il comando per eseguire il componente

Le sezioni successive illustrano come creare i componenti in due modi. Per i primi due componenti, si usa una funzione Python. Per il terzo componente si usa la definizione YAML.

Creare il componente di preparazione dei dati

Il primo componente di questa pipeline converte i file di dati compressi di fashion_ds in due file .csv, uno per il training e l'altro per l'assegnazione dei punteggi. Usare una funzione Python per definire questo componente.

Se si segue l'esempio nel repository degli esempi di Azure Machine Learning, i file di origine sono già disponibili nella prep cartella . Questa cartella contiene due file per costruire il componente : prep_component.py, che definisce il componente e conda.yaml, che definisce l'ambiente di runtime del componente.

Definire un componente usando una funzione Python

Usando la command_component() funzione come elemento Decorator, è possibile definire facilmente l'interfaccia del componente, i relativi metadati e il codice da eseguire da una funzione Python. Ogni funzione Python decorata viene trasformata in una singola specifica statica (YAML) che il servizio pipeline può elaborare.

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

Il codice precedente definisce un componente con il nome visualizzato Prep Data usando il decoratore @command_component.

• name è l'identificatore univoco del componente

• version è la versione corrente del componente. Un componente può avere più versioni

• display_name è un nome visualizzato amichevole del componente per l'interfaccia utente

• description descrive l'attività che il componente può completare

• environment specifica l'ambiente di runtime per il componente usando un file conda.yaml

  Il conda.yaml file contiene tutti i pacchetti usati per il componente:

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

• La prepare_data_component funzione definisce un input per input_data e due output per training_data e test_data

  • input_data è il percorso dei dati di input
  • training_data e test_data sono percorsi di dati di output per i dati di training e i dati di test

• Il componente converte i dati da input_data in un training_data file di .csv per i dati di training e un test_data file di .csv per i dati di test

Nell'interfaccia utente di Studio un componente viene visualizzato come segue:

• Un blocco in un grafico di una pipeline
• input_data, training_datae test_data sono porte del componente, che si connettono ad altri componenti per il flusso di dati

A questo punto sono stati preparati tutti i file di origine per il Prep Data componente.

Creare il componente di training del modello

In questa sezione viene creato un componente per il training del modello di classificazione delle immagini usando una funzione Python, come si è fatto con il Prep Data componente .

Poiché la logica di training è più complessa, inserire il codice di training in un file Python separato.

I file di origine per questo componente si trovano nella train cartella nel repository degli esempi di Azure Machine Learning. Questa cartella contiene tre file per costruire il componente:

• train.py contiene la logica per eseguire il training del modello
• train_component.py definisce l'interfaccia del componente e importa la funzione da train.py
• conda.yaml definisce l'ambiente di runtime del componente

Ottenere uno script contenente la logica

Il train.py file contiene una normale funzione Python che esegue la logica per il training di una rete neurale Keras per la classificazione delle immagini. Per visualizzare il codice, vedere il file train.py in GitHub.

Definire il componente usando una funzione Python

Dopo aver definito la funzione di training, è possibile usare @command_component in Azure Machine Learning SDK v2 per eseguire il wrapping della funzione come componente da usare nelle pipeline di Azure Machine Learning:

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)

Il codice precedente definisce un componente con il nome Train Image Classification Keras visualizzato usando @command_component.

La keras_train_component funzione definisce:

• Un input, input_data, per i dati di training di origine
• Un input, epochs, che specifica il numero di epoche da usare durante l'addestramento
• Un output, output_model, che specifica il percorso di output per il file del modello

Il valore predefinito di epochs è 10. La logica di questo componente deriva dalla train() funzione in train.py.

Il componente del modello di training ha una configurazione più complessa rispetto al componente di preparazione dei dati. conda.yaml assomiglia a questo:

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

A questo punto sono stati preparati tutti i file di origine per il Train Image Classification Keras componente.

Creare il componente di assegnazione dei punteggi del modello

In questa sezione, si crea un componente per assegnare un punteggio al modello addestrato utilizzando la specifica e lo script YAML.

Se si segue l'esempio nel repository degli esempi di Azure Machine Learning, i file di origine sono già disponibili nella score cartella . Questa cartella contiene tre file per costruire il componente:

• score.py contiene il codice sorgente del componente
• score.yaml definisce l'interfaccia e altri dettagli del componente
• conda.yaml definisce l'ambiente di runtime del componente

Ottenere uno script contenente la logica

Il score.py file contiene una normale funzione Python che esegue la logica di assegnazione dei punteggi del modello:

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)

Il codice in score.py accetta tre argomenti della riga di comando: input_data, input_modele output_result. Il programma assegna un punteggio al modello di input usando i dati di input e quindi restituisce il risultato.

Definire il componente usando YAML

In questa sezione viene illustrato come creare una specifica del componente nel formato di specifica del componente YAML valido. Questo file specifica le informazioni seguenti:

• Metadati: nome, nome visualizzato, versione, tipo e così via
• Interfaccia: input e output
• Comando, codice e ambiente: comando, codice e ambiente usati per eseguire il componente

$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 è l'identificatore univoco del componente. Il nome visualizzato è Score Image Classification Keras
• Questo componente ha due input e un output
• Il percorso del codice sorgente è definito nella code sezione . Quando il componente viene eseguito nel cloud, tutti i file di tale percorso vengono caricati come snapshot del componente
• La command sezione specifica il comando da eseguire quando viene eseguito il componente
• La environment sezione contiene un'immagine Docker e un file YAML conda. Il file di origine si trova nel repository di esempio

Sono ora disponibili tutti i file di origine per il componente di assegnazione dei punteggi del modello.

Caricare i componenti per compilare una pipeline

È possibile importare il componente di preparazione dei dati e il componente di training del modello, definiti dalle funzioni Python, proprio come le normali funzioni Python.

Il codice seguente importa rispettivamente le prepare_data_component() funzioni e keras_train_component() dal prep_component.py file nella prep cartella e il train_component file nella train cartella .

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

È possibile usare la load_component() funzione per caricare il componente score, definito da YAML.

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

Caricare i componenti registrati dall'area di lavoro

Nota

Per caricare i componenti registrati dall'area di lavoro, è prima necessario configurare la connessione all'area di lavoro come descritto nella sezione Ottenere l'accesso all'area di lavoro . L'oggetto ml_client è necessario per le operazioni seguenti.

Se si dispone di componenti già registrati nell'area di lavoro, è possibile caricarli direttamente usando il ml_client.components.get() metodo . Questo approccio è utile quando si desidera riutilizzare i componenti registrati in precedenza dall'utente o condivisi da altri membri del team.

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

È possibile elencare tutti i componenti disponibili nell'area di lavoro per trovare quelli necessari:

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

Dopo il caricamento, è possibile usare i componenti registrati nella pipeline esattamente come i componenti caricati da file locali o funzioni Python.

Creare la pipeline

Sono stati creati e caricati tutti i componenti e i dati di input per costruire la pipeline. È ora possibile comporli in una pipeline:

Nota

Per usare il calcolo serverless, aggiungere from azure.ai.ml.entities import ResourceConfiguration all'inizio del file. Sostituire quindi:

• default_compute=cpu_compute_target con default_compute="serverless"
• train_node.compute = gpu_compute_target con 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)

La pipeline ha un ambiente di calcolo predefinito cpu_compute_target. Se non si specifica il calcolo per un nodo specifico, tale nodo viene eseguito nel calcolo predefinito.

La pipeline ha un input a livello di pipeline: pipeline_input_data. È possibile assegnare un valore all'input della pipeline quando si invia un processo della pipeline.

La pipeline contiene tre nodi: prepare_data_node, train_nodee score_node:

• L'oggetto input_data di prepare_data_node utilizza il valore di pipeline_input_data
• L'input_data di train_node è l'output training_data di prepare_data_node
• Il parametro input_data di score_node è l'output test_data di prepare_data_node e il parametro input_model è il parametro output_model di train_node
• Poiché train_node esegue il training di un modello CNN, è possibile specificarne il calcolo come per gpu_compute_target, per migliorare le prestazioni di training

Inviare il processo della pipeline

Dopo aver costruito la pipeline, è possibile inviare il processo all'area di lavoro. Per inviare un'attività, è prima necessario connettersi a un'area di lavoro.

Ottenere l'accesso all'area di lavoro

Configurare le credenziali

Si usa DefaultAzureCredential per ottenere l'accesso all'area di lavoro. DefaultAzureCredential deve essere in grado di gestire la maggior parte degli scenari di autenticazione di Azure SDK.

Se DefaultAzureCredential non funziona, vedere questo esempio di configurazione delle credenziali e il pacchetto di identità.

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

Ottenere un handle a un'area di lavoro con un ambiente di calcolo

Creare un MLClient oggetto per gestire i servizi di Azure Machine Learning. Se si usa il calcolo serverless, non è necessario creare questi calcoli.

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

Importante

Questo frammento di codice prevede che il file JSON di configurazione dell'area di lavoro venga salvato nella directory corrente o nel relativo elemento padre. Per altre informazioni sulla creazione di un'area di lavoro, vedere Creare risorse dell'area di lavoro. Per altre informazioni sul salvataggio della configurazione in un file, vedere Creare un file di configurazione dell'area di lavoro.

Inviare il processo della pipeline all'area di lavoro

Ora che si dispone di un handle per l'area di lavoro, è possibile inviare il processo della pipeline:

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

Il codice precedente invia un processo di pipeline per la classificazione delle immagini a un esperimento denominato pipeline_samples. Crea automaticamente l'esperimento se non esiste. pipeline_input_data usa fashion_ds.

La chiamata a inviare l'esperimento viene completata rapidamente e produce un output simile al seguente:

Esperimento	Nome	Tipo	Stato	Pagina dei dettagli
pipeline_samples	sharp_pipe_4gvqx6h1fb	oleodotto	Preparazione	Collegamento ad Azure Machine Learning Studio

È possibile monitorare l'esecuzione della pipeline selezionando il collegamento. In alternativa, è possibile attendere il completamento eseguendo questo codice:

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

Importante

La prima esecuzione della pipeline richiede circa 15 minuti. Tutte le dipendenze vengono scaricate, viene creata un'immagine Docker e viene eseguito il provisioning e la creazione dell'ambiente Python. L'esecuzione della pipeline richiede di nuovo meno tempo perché tali risorse vengono riutilizzate anziché create. Tuttavia, il runtime totale per la pipeline dipende dal carico di lavoro degli script e dai processi eseguiti in ogni passaggio della pipeline.

Controllare gli output ed eseguire il debug della pipeline nell'interfaccia utente

È possibile selezionare Link to Azure Machine Learning studio, ovvero la pagina dei dettagli del processo della pipeline. Viene visualizzato il grafico della pipeline:

È possibile controllare i log e gli output di ogni componente facendo clic con il pulsante destro del mouse sul componente oppure selezionando il componente per aprire il relativo riquadro dei dettagli. Per altre informazioni su come eseguire il debug della pipeline nell'interfaccia utente, vedere Usare Azure Machine Learning Studio per eseguire il debug degli errori della pipeline.

(Facoltativo) Registrare i componenti nell'area di lavoro

Nelle sezioni precedenti è stata creata una pipeline usando tre componenti per completare un'attività di classificazione delle immagini. È anche possibile registrare i componenti nell'area di lavoro in modo che possano essere condivisi e riutilizzati all'interno dell'area di lavoro. L'esempio seguente illustra come registrare il componente di preparazione dei dati:

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)

È possibile usare ml_client.components.get() per ottenere un componente registrato in base al nome e alla versione. È possibile usare ml_client.components.create_or_update() per registrare un componente caricato in precedenza da una funzione Python o YAML.

Passaggi successivi

• Per altri esempi di come compilare pipeline con Machine Learning SDK, vedere il repository di esempio
• Per informazioni sull'uso dell'interfaccia utente di Studio per inviare ed eseguire il debug di una pipeline, vedere Creare ed eseguire pipeline di Machine Learning usando componenti con Azure Machine Learning Studio
• Per informazioni sull'uso dell'interfaccia della riga di comando di Azure Machine Learning per creare componenti e pipeline, vedere Creare ed eseguire pipeline di Machine Learning usando componenti con l'interfaccia della riga di comando di Azure Machine Learning
• Per informazioni sulla distribuzione di pipeline nell'ambiente di produzione tramite endpoint batch, vedere Come distribuire pipeline con endpoint batch