Eseguire il training dei modelli con l'interfaccia della riga di comando (v2) (anteprima)

L Azure Machine Learning'interfaccia della riga di comando di Azure (v2) è un'estensione dell'interfaccia della riga di comando di Azure che consente di accelerare il processo di training del modello durante la scalabilità verticale e orizzontale nel calcolo di Azure, con il ciclo di vita del modello monitorato e controllabile.

Il training di un modello di Machine Learning è in genere un processo iterativo. Gli strumenti moderni rendono più semplice che mai eseguire il training di modelli più grandi su più dati più velocemente. I processi manuali precedentemente noiosi, come l'ottimizzazione degli iperparametri e anche la selezione degli algoritmi, sono spesso automatizzati. Con l'interfaccia della riga di comando di Azure Machine Learning (v2), è possibile tenere traccia dei processi (e dei modelli) in un'area di lavoro con sweep di iperparamezzi, scalabilità verticale su calcolo di Azure ad alte prestazioni e scalabilità orizzontale tramite training distribuito.

Importante

Questa funzionalità è attualmente in anteprima pubblica. Questa versione di anteprima viene fornita senza contratto di servizio e non è consigliata per carichi di lavoro di produzione. Alcune funzionalità potrebbero non essere supportate o potrebbero presentare funzionalità limitate. Per altre informazioni, vedere Condizioni supplementari per l'utilizzo delle anteprime di Microsoft Azure.

Prerequisiti

Suggerimento

Per un ambiente di sviluppo completo con convalida dello schema e completamento automatico per gli YARL del processo, usare Visual Studio Code e l'estensione Azure Machine Learning .

Clonare il repository di esempi

Per eseguire gli esempi di training, clonare prima il repository degli esempi e passare alla cli directory:

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

--depth 1L'uso di clona solo il commit più recente nel repository, riducendo il tempo necessario per completare l'operazione.

Creare il calcolo

È possibile creare un cluster Azure Machine Learning di calcolo dalla riga di comando. Ad esempio, i comandi seguenti creeranno un cluster cpu-cluster denominato e uno denominato gpu-cluster .

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 8
az ml compute create -n gpu-cluster --type amlcompute --min-instances 0 --max-instances 4 --size Standard_NC12

A questo punto non viene addebitato il calcolo come e cpu-cluster rimarrà a zero nodi fino gpu-cluster all'invio di un processo. Altre informazioni su come gestire e ottimizzare i costi per AmlCompute.

I processi di esempio seguenti in questo articolo usano uno di cpu-cluster o gpu-cluster . Modificare questi nomi nei processi di esempio in questo articolo in base alle esigenze in base al nome dei cluster. Usare az ml compute create -h per altri dettagli sulle opzioni di creazione di calcolo.

Hello world

Per l'Azure Machine Learning dell'interfaccia della riga di comando (v2), i processi vengono creati in formato YAML. Un processo aggrega:

  • Versione da eseguire
  • Come eseguirlo
  • Dove eseguirlo

Il processo "hello world" include tutti e tre:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: python:latest
compute: azureml:cpu-cluster

Avviso

Python deve essere installato nell'ambiente usato per i processi. Eseguire apt-get update -y && apt-get install python3 -y nel Dockerfile per eseguire l'installazione, se necessario, o derivare da un'immagine di base con Python già installato.

Suggerimento

In tutti gli esempi è possibile convalidare lo schema e il completamento automatico se si crea file $schema: YAML in $schema:con l Azure Machine Learning estensione .

Che è possibile eseguire:

az ml job create -f jobs/basics/hello-world.yml --web

Suggerimento

Il --web parametro tenterà di aprire il processo in Azure Machine Learning Studio usando il Web browser predefinito. Il --stream parametro può essere usato per trasmettere i log alla console e bloccare altri comandi.

Override dei valori durante la creazione o l'aggiornamento

È possibile eseguire l'override dei valori di specifica del processo YAML usando --set durante la creazione o l'aggiornamento di un processo. Ad esempio:

az ml job create -f jobs/basics/hello-world.yml \
  --set environment.image="python:3.8" \
  --web

Nomi dei processi

La maggior parte dei comandi diversi da e richiedono , ovvero il nome di un processo az ml jobcreate o list--name/-n "ID esecuzione" in studio. Non impostare direttamente la proprietà di un processo durante la creazione name perché deve essere univoca per ogni area di lavoro. Azure Machine Learning genera un GUID casuale per il nome del processo se non è impostato, che può essere ottenuto dall'output della creazione del processo nell'interfaccia della riga di comando o copiando la proprietà "RUN ID" nelle API studio e MLflow.

Per automatizzare i processi negli script e nei flussi CI/CD, è possibile acquisire il nome di un processo quando viene creato tramite query e rimozione dell'output aggiungendo --query name -o tsv . Le specifiche variano in base alla shell, ma per Bash:

run_id=$(az ml job create -f jobs/basics/hello-world.yml --query name -o tsv)

Usare quindi $run_id nei comandi update successivi, ad esempio , o showstream :

az ml job show -n $run_id --web

Organizzare i processi

Per organizzare i processi, è possibile impostare un nome visualizzato, un nome dell'esperimento, una descrizione e tag. Le descrizioni supportano la sintassi markdown in studio. Queste proprietà sono modificabili dopo la creazione di un processo. Esempio completo:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: python:latest
compute: azureml:cpu-cluster
tags:
  hello: world
display_name: hello-world-example
experiment_name: hello-world-example
description: |
  # Azure Machine Learning "hello world" job

  This is a "hello world" job running in the cloud via Azure Machine Learning!

  ## Description

  Markdown is supported in the studio for job descriptions! You can edit the description there or via CLI.

È possibile eseguire questo processo, in cui queste proprietà saranno immediatamente visibili in studio:

az ml job create -f jobs/basics/hello-world-org.yml --web

Usando --set è possibile aggiornare i valori modificabili dopo la creazione del processo:

az ml job update -n $run_id --set \
  display_name="updated display name" \
  experiment_name="updated experiment name" \
  description="updated description"  \
  tags.hello="updated tag"

Variabili di ambiente

È possibile impostare variabili di ambiente da usare nel processo:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo $hello_env_var
environment:
  image: python:latest
compute: azureml:cpu-cluster
environment_variables:
  hello_env_var: "hello world"

È possibile eseguire questo processo:

az ml job create -f jobs/basics/hello-world-env-var.yml --web

Avviso

È consigliabile inputs usare per parametrizzare gli argomenti in command . Vedere input e output.

Tenere traccia dei modelli e del codice sorgente

I modelli di Machine Learning di produzione devono essere controllabili (se non riproducibili). È fondamentale tenere traccia del codice sorgente per un determinato modello. Azure Machine Learning uno snapshot del codice sorgente e lo mantiene con il processo. Inoltre, il repository di origine e il commit vengono mantenuti se si eseguono processi da un repository Git.

Suggerimento

Se si segue ed è in esecuzione dal repository degli esempi, è possibile visualizzare il repository di origine ed eseguire il commit in studio in uno dei processi eseguiti fino a questo momento.

È possibile specificare la code.local_path chiave in un processo con il valore come percorso di una directory del codice sorgente. Viene creato e caricato uno snapshot della directory con il processo. Il contenuto della directory è direttamente disponibile dalla directory di lavoro del processo.

Avviso

Il codice sorgente non deve includere input di dati di grandi dimensioni per il training del modello. Usare invece gli input di dati. È possibile usare un .gitignore file nella directory del codice sorgente per escludere i file dallo snapshot. I limiti per le dimensioni dello snapshot sono 300 MB o 2000 file.

Si esamini un processo che specifica il codice:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  pip install mlflow azureml-mlflow
  &&
  python hello-mlflow.py
code:
  local_path: src
environment:
  image: python:3.8
compute: azureml:cpu-cluster

Lo script Python si trova nella directory del codice sorgente locale. Il comando richiama quindi python per eseguire lo script. Lo stesso modello può essere applicato per altri linguaggi di programmazione.

Avviso

La famiglia di processi "hello" mostrata in questo articolo è a scopo dimostrativo e non segue necessariamente le procedure consigliate. Non è consigliabile usare o simili per eseguire molti comandi in una sequenza. È invece consigliabile scrivere i comandi in un file script nella directory del codice sorgente e richiamare lo && script in command . Non è consigliabile installare le dipendenze in , come illustrato in precedenza tramite , ma tutte le dipendenze del processo devono essere specificate commandpip install come parte dell'ambiente. Per informazioni dettagliate, vedere Come gestire gli ambienti con l'interfaccia della riga di comando (v2).

Rilevamento dei modelli con MLflow

Durante l'iterazione sui modelli, i data scientist devono essere in grado di tenere traccia dei parametri del modello e delle metriche di training. Azure Machine Learning si integra con il rilevamento MLflow per abilitare la registrazione di modelli, artefatti, metriche e parametri in un processo. Per usare MLflow negli script Python, aggiungere import mlflow e chiamare o API nel codice di mlflow.log_*mlflow.autolog() training.

Avviso

I mlflow pacchetti e devono essere installati azureml-mlflow nell'ambiente Python per le funzionalità di rilevamento MLflow.

Suggerimento

La chiamata è supportata per molti framework diffusi e si occupa della maggior parte mlflow.autolog() della registrazione.

Si esaminerà ora lo script Python richiamato nel processo precedente che usa per registrare un parametro, una mlflow metrica e un artefatto:

# imports
import os
import mlflow

from random import random

# define functions
def main():
    mlflow.log_param("hello_param", "world")
    mlflow.log_metric("hello_metric", random())
    os.system(f"echo 'hello world' > helloworld.txt")
    mlflow.log_artifact("helloworld.txt")


# run functions
if __name__ == "__main__":
    # run main function
    main()

È possibile eseguire questo processo nel cloud tramite Azure Machine Learning, dove è monitorato e controllabile:

az ml job create -f jobs/basics/hello-mlflow.yml --web

Eseguire query sulle metriche con MLflow

Dopo aver eseguito i processi, è possibile eseguire query sui risultati dell'esecuzione dei processi e sulle relative metriche registrate. Python è più adatto per questa attività rispetto a un'interfaccia della riga di comando. È possibile eseguire query sulle esecuzioni e sulle relative metriche tramite e caricarsi in oggetti familiari come i mlflow dataframe Pandas per l'analisi.

Recuperare prima di tutto l'URI di rilevamento MLflow per l'area Azure Machine Learning lavoro:

az ml workspace show --query mlflow_tracking_uri -o tsv

Usare l'output di questo comando in mlflow.set_tracking_uri(<YOUR_TRACKING_URI>) da un ambiente Python con MLflow importato. Le chiamate di MLflow corrisponderanno ora ai processi nell'area Azure Machine Learning lavoro.

Input e output

I processi includono in genere input e output. Gli input possono essere parametri del modello, che potrebbero risultare disastrati per l'ottimizzazione degli iperparame aggiuntivi, o input di dati cloud montati o scaricati nella destinazione di calcolo. Gli output (ignorando le metriche) sono elementi che possono essere scritti o copiati negli output predefiniti o in un output di dati denominato.

Input letterali

Gli input letterali vengono risolti direttamente nel comando . È possibile modificare il processo "hello world" per usare input letterali:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo ${{inputs.hello_string}}
  &&
  echo ${{inputs.hello_number}}
environment:
  image: python:latest
inputs:
  hello_string: "hello world"
  hello_number: 42
compute: azureml:cpu-cluster

È possibile eseguire questo processo:

az ml job create -f jobs/basics/hello-world-input.yml --web

È possibile usare --set per eseguire l'override degli input:

az ml job create -f jobs/basics/hello-world-input.yml --set \
  inputs.hello_string="hello there" \
  inputs.hello_number=24 \
  --web

Gli input letterali in processi possono essere convertiti in input dello spazio di ricerca per sweep di iperparamezzi nel training del modello.

Input dello spazio di ricerca

Per un processo di sweep, è possibile specificare uno spazio di ricerca per gli input letterali da cui scegliere. Per l'intera gamma di opzioni per gli input dello spazio di ricerca, vedere le informazioni di riferimento sulla sintassi YAML del processo di sweep.

Avviso

I processi di sweep non sono attualmente supportati nei processi della pipeline.

Di seguito viene illustrato il concetto con un semplice script Python che accetta argomenti e registra una metrica casuale:

# imports
import os
import mlflow
import argparse

from random import random

# define functions
def main(args):
    # print inputs
    print(f"A: {args.A}")
    print(f"B: {args.B}")
    print(f"C: {args.C}")

    # log inputs as parameters
    mlflow.log_param("A", args.A)
    mlflow.log_param("B", args.B)
    mlflow.log_param("C", args.C)

    # log a random metric
    mlflow.log_metric("random_metric", random())


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

    # add arguments
    parser.add_argument("--A", type=float, default=0.5)
    parser.add_argument("--B", type=str, default="hello world")
    parser.add_argument("--C", type=float, default=1.0)

    # parse args
    args = parser.parse_args()

    # return args
    return args


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

    # run main function
    main(args)

Creare quindi un processo di sweep corrispondente:

$schema: https://azuremlschemas.azureedge.net/latest/sweepJob.schema.json
type: sweep
trial:
  command: >-
    pip install mlflow azureml-mlflow
    &&
    python hello-sweep.py
    --A ${{inputs.A}}
    --B ${{search_space.B}}
    --C ${{search_space.C}}
  code:
    local_path: src
  environment:
    image: python:3.8
inputs:
  A: 0.5
compute: azureml:cpu-cluster
sampling_algorithm: random
search_space:
  B:
    type: choice
    values: ["hello", "world", "hello world"]
  C:
    type: uniform
    min_value: 0.1
    max_value: 1.0
objective:
  goal: minimize
  primary_metric: random_metric
limits:
  max_total_trials: 4
  max_concurrent_trials: 2
  timeout: 3600
display_name: hello-sweep-example
experiment_name: hello-sweep-example
description: Hello sweep job example.

Ed eseguirlo:

az ml job create -f jobs/basics/hello-sweep.yml --web

Input di dati

Gli input di dati vengono risolti in un percorso nel file system locale del calcolo del processo. Di seguito viene illustrato il set di dati Iris classico, ospitato pubblicamente in un contenitore BLOB all'indirizzo https://azuremlexamples.blob.core.windows.net/datasets/iris.csv .

È possibile creare uno script Python che accetta il percorso del file CSV Iris come argomento, lo legge in un frame di dati, stampa le prime 5 righe e lo salva nella outputs directory.

# imports
import os
import argparse

import pandas as pd

# define functions
def main(args):
    # read in data
    df = pd.read_csv(args.iris_csv)

    # print first 5 lines
    print(df.head())

    # ensure outputs directory exists
    os.makedirs("outputs", exist_ok=True)

    # save data to outputs
    df.to_csv("outputs/iris.csv", index=False)


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

    # add arguments
    parser.add_argument("--iris-csv", type=str)

    # parse args
    args = parser.parse_args()

    # return args
    return args


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

    # run main function
    main(args)

È possibile specificare gli input URI di archiviazione di Azure, che montano o scaricano i dati nel file system locale. È possibile specificare un singolo file:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo "--iris-csv: ${{inputs.iris_csv}}"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.iris_csv}}
code:
  local_path: src
inputs:
  iris_csv: 
    file: https://azuremlexamples.blob.core.windows.net/datasets/iris.csv
environment:
  image: python:latest
compute: azureml:cpu-cluster

Quindi eseguire:

az ml job create -f jobs/basics/hello-iris-file.yml --web

Oppure specificare un'intera cartella:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  ls ${{inputs.data_dir}}
  &&
  echo "--iris-csv: ${{inputs.data_dir}}/iris.csv"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.data_dir}}/iris.csv
code:
  local_path: src
inputs:
  data_dir: 
    folder: wasbs://datasets@azuremlexamples.blob.core.windows.net/
environment:
  image: python:latest
compute: azureml:cpu-cluster

Quindi eseguire:

az ml job create -f jobs/basics/hello-iris-folder.yml --web

Dati privati

Per i dati privati in Azure Blob Archiviazione o Azure Data Lake Archiviazione connessi a Azure Machine Learning tramite un archivio dati, è possibile usare gli URI Azure Machine Learning del formato per i dati di azureml://datastores/<DATASTORE_NAME>/paths/<PATH_TO_DATA> input. Ad esempio, se si carica il file CSV Iris in una directory denominata nel contenitore BLOB corrispondente all'archivio dati denominato , è possibile modificare un processo precedente per usare il /example-data/ file nell'archivio workspaceblobstore dati:

Avviso

L'esecuzione di questi processi avrà esito negativo se il file CSV Iris non è stato copiato nello stesso percorso in workspaceblobstore .

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  echo "--iris-csv: ${{inputs.iris_csv}}"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.iris_csv}}
code:
  local_path: src
inputs:
  iris_csv: 
    file: azureml://datastores/workspaceblobstore/paths/example-data/iris.csv
environment:
  image: python:latest
compute: azureml:cpu-cluster

Oppure l'intera directory:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: >-
  ls ${{inputs.data_dir}}
  &&
  echo "--iris-csv: ${{inputs.data_dir}}/iris.csv"
  &&
  pip install pandas
  &&
  python hello-iris.py
  --iris-csv ${{inputs.data_dir}}/iris.csv
code:
  local_path: src
inputs:
  data_dir: 
    folder: azureml://datastores/workspaceblobstore/paths/example-data/
    mode: rw_mount
environment:
  image: python:latest
compute: azureml:cpu-cluster

Output predefiniti

Le ./outputs directory e ricevono un trattamento speciale ./logs Azure Machine Learning. Se si scrivono file in queste directory durante il processo, questi file verranno caricati nel processo in modo che sia comunque possibile accedervi al termine. La ./outputs cartella viene caricata alla fine del processo, mentre i file scritti ./logs in vengono caricati in tempo reale. Usare quest'ultimo se si vogliono trasmettere i log durante il processo, ad esempio i log di TensorBoard.

È possibile modificare il processo "hello world" per l'output in un file nella directory outputs predefinita invece di eseguire la stampa in stdout :

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world" > ./outputs/helloworld.txt
environment:
  image: python:latest
compute: azureml:cpu-cluster

È possibile eseguire questo processo:

az ml job create -f jobs/basics/hello-world-output.yml --web

Scaricare i log, dove helloworld.txt saranno presenti nella directory <RUN_ID>/outputs/ :

az ml job download -n $run_id

Output dei dati

È possibile specificare output di dati denominati. Verrà creata una directory nell'archivio dati predefinito che verrà montata in lettura/scrittura per impostazione predefinita.

È possibile modificare il processo "hello world" precedente per scrivere in un output di dati denominato:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world" > ${{outputs.hello_output}}/helloworld.txt
outputs:
  hello_output:
environment:
  image: python
compute: azureml:cpu-cluster

Pipeline Hello

I processi della pipeline possono eseguire più processi in parallelo o in sequenza. Se sono presenti dipendenze di input/output tra i passaggi in una pipeline, il passaggio dipendente verrà eseguito dopo il completamento degli altri passaggi.

È possibile suddividere un processo "hello world" in due processi:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
jobs:
  hello_job:
    command: echo "hello"
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
  world_job:
    command: echo "world"
    environment:
      image: python
    compute: azureml:cpu-cluster

Ed eseguirlo:

az ml job create -f jobs/basics/hello-pipeline.yml --web

I processi "hello" e "world" verranno eseguiti rispettivamente in parallelo se la destinazione di calcolo ha le risorse disponibili a tale scopo.

Per passare dati tra i passaggi in una pipeline, definire un output dei dati nel processo "hello" e un input corrispondente nel processo "world", che fa riferimento all'output del precedente:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
jobs:
  hello_job:
    command: echo "hello" && echo "world" > ${{outputs.world_output}}/world.txt
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    outputs:
      world_output:
  world_job:
    command: cat ${{inputs.world_input}}/world.txt
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    inputs:
      world_input: ${{jobs.hello_job.outputs.world_output}}

Ed eseguirlo:

az ml job create -f jobs/basics/hello-pipeline-io.yml --web

Questa volta, il processo "world" verrà eseguito dopo il completamento del processo "hello".

Per evitare la duplicazione delle impostazioni comuni tra i processi in una pipeline, è possibile impostarle all'esterno dei processi:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
compute: azureml:cpu-cluster
settings:
  environment:
    image: python:latest
jobs:
  hello_job:
    command: echo "hello"
  world_job:
    command: echo "world"

È possibile eseguire questo comando:

az ml job create -f jobs/basics/hello-pipeline-settings.yml --web

L'impostazione corrispondente in un singolo processo eseguirà l'override delle impostazioni comuni per un processo della pipeline. I concetti finora illustrati possono essere combinati in un processo di pipeline in tre passaggi con i processi "A", "B" e "C". Il processo "C" ha una dipendenza dei dati dal processo "B", mentre il processo "A" può essere eseguito in modo indipendente. Il processo "A" userà anche un ambiente impostato singolarmente e associa uno dei relativi input a un input del processo della pipeline di primo livello:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
compute: azureml:cpu-cluster
settings:
  environment:
    image: python:latest
inputs:
  hello_string_top_level_input: "hello world"
jobs:
  A:
    command: echo hello ${{inputs.hello_string}}
    environment:
      image: python:3.9
    inputs:
      hello_string: ${{inputs.hello_string_top_level_input}}
  B:
    command: echo "world" >> ${{outputs.world_output}}/world.txt
    outputs:
      world_output:
  C:
    command: echo ${{inputs.world_input}}/world.txt
    inputs:
      world_input: ${{jobs.B.outputs.world_output}}

È possibile eseguire questo comando:

az ml job create -f jobs/basics/hello-pipeline-abc.yml --web

Eseguire il training di un modello

A questo punto, un modello non è ancora stato addestrato. Aggiungere codice in uno script Python con rilevamento sklearn MLflow per eseguire il training di un modello nel file CSV Iris:

# imports
import os
import mlflow
import argparse

import pandas as pd

from sklearn.svm import SVC
from sklearn.model_selection import train_test_split

# define functions
def main(args):
    # enable auto logging
    mlflow.autolog()

    # setup parameters
    params = {
        "C": args.C,
        "kernel": args.kernel,
        "degree": args.degree,
        "gamma": args.gamma,
        "coef0": args.coef0,
        "shrinking": args.shrinking,
        "probability": args.probability,
        "tol": args.tol,
        "cache_size": args.cache_size,
        "class_weight": args.class_weight,
        "verbose": args.verbose,
        "max_iter": args.max_iter,
        "decision_function_shape": args.decision_function_shape,
        "break_ties": args.break_ties,
        "random_state": args.random_state,
    }

    # read in data
    df = pd.read_csv(args.iris_csv)

    # process data
    X_train, X_test, y_train, y_test = process_data(df, args.random_state)

    # train model
    model = train_model(params, X_train, X_test, y_train, y_test)


def process_data(df, random_state):
    # split dataframe into X and y
    X = df.drop(["species"], axis=1)
    y = df["species"]

    # train/test split
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=0.2, random_state=random_state
    )

    # return split data
    return X_train, X_test, y_train, y_test


def train_model(params, X_train, X_test, y_train, y_test):
    # train model
    model = SVC(**params)
    model = model.fit(X_train, y_train)

    # return model
    return model


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

    # add arguments
    parser.add_argument("--iris-csv", type=str)
    parser.add_argument("--C", type=float, default=1.0)
    parser.add_argument("--kernel", type=str, default="rbf")
    parser.add_argument("--degree", type=int, default=3)
    parser.add_argument("--gamma", type=str, default="scale")
    parser.add_argument("--coef0", type=float, default=0)
    parser.add_argument("--shrinking", type=bool, default=False)
    parser.add_argument("--probability", type=bool, default=False)
    parser.add_argument("--tol", type=float, default=1e-3)
    parser.add_argument("--cache_size", type=float, default=1024)
    parser.add_argument("--class_weight", type=dict, default=None)
    parser.add_argument("--verbose", type=bool, default=False)
    parser.add_argument("--max_iter", type=int, default=-1)
    parser.add_argument("--decision_function_shape", type=str, default="ovr")
    parser.add_argument("--break_ties", type=bool, default=False)
    parser.add_argument("--random_state", type=int, default=42)

    # parse args
    args = parser.parse_args()

    # return args
    return args


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

    # run main function
    main(args)

Il framework scikit-learn è supportato da MLflow per la creazione automatica di blog, quindi una singola chiamata nello script registra tutti i parametri del modello, le metriche di training, gli artefatti del modello e alcuni artefatti aggiuntivi (in questo caso un'immagine di matrice di mlflow.autolog() confusione).

Per eseguire questa operazione nel cloud, specificare come processo:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >-
  python main.py 
  --iris-csv ${{inputs.iris_csv}}
  --C ${{inputs.C}}
  --kernel ${{inputs.kernel}}
  --coef0 ${{inputs.coef0}}
inputs:
  iris_csv: 
    file: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
  C: 0.8
  kernel: "rbf"
  coef0: 0.1
environment: azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9
compute: azureml:cpu-cluster
display_name: sklearn-iris-example
experiment_name: sklearn-iris-example
description: Train a scikit-learn SVM on the Iris dataset.

Ed eseguirlo:

az ml job create -f jobs/single-step/scikit-learn/iris/job.yml --web

Per registrare un modello, è possibile scaricare gli output e creare un modello dalla directory locale:

az ml job download -n $run_id
az ml model create -n sklearn-iris-example -l $run_id/model/

Iperparamezzi di sweep

È possibile modificare il processo precedente per eseguire lo sweep degli iperparamezzi:

$schema: https://azuremlschemas.azureedge.net/latest/sweepJob.schema.json
type: sweep
trial:
  code: 
    local_path: src
  command: >-
    python main.py 
    --iris-csv ${{inputs.iris_csv}}
    --C ${{search_space.C}}
    --kernel ${{search_space.kernel}}
    --coef0 ${{search_space.coef0}}
  environment: azureml:AzureML-sklearn-0.24-ubuntu18.04-py37-cpu:9
inputs:
  iris_csv: 
    file: wasbs://datasets@azuremlexamples.blob.core.windows.net/iris.csv
compute: azureml:cpu-cluster
sampling_algorithm: random
search_space:
  C:
    type: uniform
    min_value: 0.5
    max_value: 0.9
  kernel:
    type: choice
    values: ["rbf", "linear", "poly"]
  coef0:
    type: uniform
    min_value: 0.1
    max_value: 1
objective:
  goal: minimize
  primary_metric: training_f1_score
limits:
  max_total_trials: 20
  max_concurrent_trials: 10
  timeout: 7200
display_name: sklearn-iris-sweep-example
experiment_name: sklearn-iris-sweep-example
description: Sweep hyperparemeters for training a scikit-learn SVM on the Iris dataset.

Ed eseguirlo:

az ml job create -f jobs/single-step/scikit-learn/iris/job-sweep.yml --web

Suggerimento

Controllare la scheda "Esecuzioni figlio" in Studio per monitorare lo stato di avanzamento e visualizzare i grafici dei parametri.

Per altre opzioni di sweep, vedere le informazioni di riferimento sulla sintassi YAML del processo di sweep.

Training distribuito

Azure Machine Learning supporta il training distribuito basato su PyTorch, TensorFlow e MPI. Per informazioni dettagliate, vedere la sezione distribuita del riferimento alla sintassi YAML del processo di comando.

Ad esempio, è possibile eseguire il training di una rete neurale convoluzionale (CNN) sul set di dati CIFAR-10 usando PyTorch distribuito. Lo script completo è disponibile nel repository degli esempi.

Il set di dati CIFAR-10 in torchvision prevede come input una directory che contiene la cifar-10-batches-py directory. È possibile scaricare l'origine compressa ed estrarre in una directory locale:

mkdir data
wget "https://azuremlexamples.blob.core.windows.net/datasets/cifar-10-python.tar.gz"
tar -xvzf cifar-10-python.tar.gz -C data

Creare quindi un Azure Machine Learning set di dati dalla directory locale, che verrà caricato nell'archivio dati predefinito:

az ml dataset create --name cifar-10-example --version 1 --set local_path=data

Facoltativamente, rimuovere il file e la directory locali:

rm cifar-10-python.tar.gz
rm -r data

È possibile fare riferimento ai set di dati (solo file) in un processo usando la dataset chiave di un input di dati. Il formato è , quindi per il set di dati azureml:<DATASET_NAME>:<DATASET_VERSION> CIFAR-10 appena creato è azureml:cifar-10-example:1 .

Dopo aver creato il set di dati, è possibile creare un processo PyTorch distribuito per eseguire il training del modello:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
code: 
  local_path: src
command: >-
  python train.py 
  --epochs ${{inputs.epochs}}
  --learning-rate ${{inputs.learning_rate}}
  --data-dir ${{inputs.cifar}}
inputs:
  epochs: 1
  learning_rate: 0.2
  cifar:
    dataset: azureml:cifar-10-example:1
environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
compute: azureml:gpu-cluster
distribution:
  type: pytorch 
  process_count_per_instance: 2
resources:
  instance_count: 2
display_name: pytorch-cifar-distributed-example
experiment_name: pytorch-cifar-distributed-example
description: Train a basic convolutional neural network (CNN) with PyTorch on the CIFAR-10 dataset, distributed via PyTorch.

Ed eseguirlo:

az ml job create -f jobs/single-step/pytorch/cifar-distributed/job.yml --web

Creare una pipeline di training

L'esempio CIFAR-10 precedente si traduce bene in un processo di pipeline. Il processo precedente può essere suddiviso in tre processi per l'orchestrazione in una pipeline:

  • "get-data" per eseguire uno script Bash da scaricare ed estrarre cifar-10-batches-py
  • "train-model" per prendere i dati ed eseguire il training di un modello con PyTorch distribuito
  • "eval-model" per prendere i dati e il modello con training e valutare l'accuratezza

Sia "train-model" che "eval-model" avranno una dipendenza dall'output del processo "get-data". Inoltre, "eval-model" avrà una dipendenza dall'output del processo "train-model". Di conseguenza, i tre processi verranno eseguiti in sequenza.

È possibile orchestrare questi tre processi all'interno di un processo della pipeline:

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: cifar-10-pipeline-example
experiment_name: cifar-10-pipeline-example
jobs:
  get-data:
    command: bash main.sh ${{outputs.cifar}}
    code:
      local_path: src/get-data
    environment:
      image: python:latest
    compute: azureml:cpu-cluster
    outputs:
      cifar:
  train-model:
    command: >-
      python main.py
      --data-dir ${{inputs.cifar}}
      --epochs ${{inputs.epochs}}
      --model-dir ${{outputs.model_dir}}
    code:
      local_path: src/train-model
    inputs:
      epochs: 1
      cifar: ${{jobs.get-data.outputs.cifar}}
    outputs:
      model_dir:
    environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
    compute: azureml:gpu-cluster
    distribution:
      type: pytorch
      process_count_per_instance: 2
    resources:
      instance_count: 2
  eval-model:
    command: >-
      python main.py
      --data-dir ${{inputs.cifar}}
      --model-dir ${{inputs.model_dir}}/model
    code:
      local_path: src/eval-model
    environment: azureml:AzureML-pytorch-1.9-ubuntu18.04-py37-cuda11-gpu:6
    compute: azureml:gpu-cluster
    distribution:
      type: pytorch
      process_count_per_instance: 2
    resources:
      instance_count: 1
    inputs:
      cifar: ${{jobs.get-data.outputs.cifar}}
      model_dir: ${{jobs.train-model.outputs.model_dir}}

Quindi eseguire:

az ml job create -f jobs/pipelines/cifar-10/job.yml --web

Pipelines possono essere scritti anche usando componenti riutilizzabili. Per altre informazioni, vedere Creare ed eseguire pipeline di Machine Learning basate su componenti con l'interfaccia della Azure Machine Learning comando (anteprima).

Passaggi successivi