Träna modeller med CLI (v2) (förhandsversion)

Cli Azure Machine Learning (v2) är ett Azure CLI-tillägg som gör att du kan påskynda modellträningen samtidigt som du skalar upp och ut på Azure-beräkning, med modellens livscykel spårad och granskningsbar.

Att träna en maskininlärningsmodell är vanligtvis en iterativ process. Moderna verktyg gör det enklare än någonsin att träna större modeller på mer data snabbare. Tidigare omedvetna manuella processer som justering av hyperparametrar och även algoritmval automatiseras ofta. Med Azure Machine Learning CLI (v2) kan du spåra dina jobb (och modeller) på en arbetsyta med hyperparametersvepar, uppskalning av högpresterande Azure-beräkning och utskalning med distribuerad träning.

Förutsättningar

• Om du vill använda CLI (v2) måste du ha en Azure-prenumeration. Om du inte har någon Azure-prenumeration kan du skapa ett kostnadsfritt konto innan du börjar. Prova den kostnadsfria eller betalda versionen Azure Machine Learning idag.
• Installera och konfigurera CLI (v2).

Lagringsplats för klonexempel

Om du vill köra träningsexempel klonar du först lagringsplatsen för exemplen och byter till cli katalogen:

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

Om --depth 1 du använder klonar endast den senaste commit till lagringsplatsen, vilket minskar tiden för att slutföra åtgärden.

Skapa beräkning

Du kan skapa Azure Machine Learning ett beräkningskluster från kommandoraden. Följande kommandon skapar till exempel ett kluster med namnet cpu-cluster och ett med namnet 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

Du debiteras inte för beräkning i det här läget eftersom cpu-cluster och förblir noll noder gpu-cluster tills ett jobb skickas. Läs mer om hur du hanterar och optimerar kostnaden för AmlCompute.

I följande exempeljobb i den här artikeln används något av cpu-cluster eller gpu-cluster . Justera dessa namn i exempeljobben i den här artikeln efter behov efter behov efter namn på dina kluster. Använd az ml compute create -h för mer information om alternativ för att skapa beräkning.

Hello World

För Azure Machine Learning CLI (v2) skapas jobb i YAML-format. Ett jobb aggregerar:

• Vad som ska köras
• Så här kör du det
• Var du ska köra den

Jobbet "hello world" har alla tre:

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

Som du kan köra:

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

Åsidosätta värden vid skapa eller uppdatera

YAML-jobbspecifikationsvärden kan åsidosättas med hjälp --set av när du skapar eller uppdaterar ett jobb. Till exempel:

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

Jobbnamn

De az ml job flesta andra kommandon än och kräver , som är ett create list --name/-n jobbs namn eller "Run ID" i studio. Du bör inte ange egenskapen för ett jobb name direkt när du skapar det eftersom det måste vara unikt per arbetsyta. Azure Machine Learning genererar ett slumpmässigt GUID för jobbnamnet om det inte har angetts som kan hämtas från utdata från jobbskapandet i CLI eller genom att kopiera egenskapen "Kör ID" i Studio- och MLflow-API:erna.

Om du vill automatisera jobb i skript och CI/CD-flöden kan du avbilda ett jobbs namn när det skapas genom att fråga och ta bort utdata genom att lägga till --query name -o tsv . Information varierar beroende på gränssnitt, men för Bash:

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

Använd sedan $run_id i efterföljande kommandon som , eller update show stream :

az ml job show -n $run_id --web

Organisera jobb

Om du vill organisera jobb kan du ange ett visningsnamn, ett experimentnamn, en beskrivning och taggar. Beskrivningar stöder Markdown-syntax i studio. De här egenskaperna är föränderliga när ett jobb har skapats. Ett fullständigt exempel:

$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.

Du kan köra det här jobbet, där dessa egenskaper visas omedelbart i studio:

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

Med --set hjälp av kan du uppdatera de föränderliga värdena när jobbet har skapats:

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"

Miljövariabler

Du kan ange miljövariabler för användning i jobbet:

$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"

Du kan köra det här jobbet:

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

Spåra modeller och källkod

Maskininlärningsmodeller för produktion måste vara granskningsbara (om de inte kan återskapas). Det är viktigt att hålla reda på källkoden för en viss modell. Azure Machine Learning tar en ögonblicksbild av källkoden och sparar den med jobbet. Dessutom sparas källdatabasen och genomfören om du kör jobb från en Git-lagringsplats.

Du kan ange code.local_path nyckeln i ett jobb med värdet som sökväg till en källkodskatalog. En ögonblicksbild av katalogen tas och laddas upp med jobbet. Innehållet i katalogen är direkt tillgängligt från arbetskatalogen för jobbet.

Nu ska vi titta på ett jobb som anger kod:

$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

Python-skriptet finns i den lokala källkodskatalogen. Kommandot anropar sedan python för att köra skriptet. Samma mönster kan användas för andra programmeringsspråk.

Modellspårning med MLflow

När dataexperter iterera modeller måste de kunna hålla reda på modellparametrar och träningsmått. Azure Machine Learning integreras med MLflow-spårning för att möjliggöra loggning av modeller, artefakter, mått och parametrar till ett jobb. Om du vill använda MLflow i Dina Python-skript lägger du import mlflow till och mlflow.log_* anropar eller mlflow.autolog() API:er i din träningskod.

Låt oss ta en titt på Python-skriptet som anropas i jobbet ovan som använder för att logga en parameter, ett mlflow mått och en artefakt:

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

Du kan köra det här jobbet i molnet via Azure Machine Learning, där det spåras och kan granskas:

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

Köra frågor mot mått med MLflow

När du har kört jobb kanske du vill köra frågor mot jobbens körningsresultat och deras loggade mått. Python passar bättre för den här uppgiften än ett CLI. Du kan köra frågor mot körningar och deras mått via och läsa in dem i välbekanta objekt som mlflow Pandas-dataramar för analys.

Hämta först MLflow-spårnings-URI:en för Azure Machine Learning arbetsyta:

az ml workspace show --query mlflow_tracking_uri -o tsv

Använd utdata från det här kommandot i mlflow.set_tracking_uri(<YOUR_TRACKING_URI>) från en Python-miljö med importerat MLflow. MLflow-anrop motsvarar nu jobb i din Azure Machine Learning arbetsyta.

Indata och utdata

Jobb har vanligtvis indata och utdata. Indata kan vara modellparametrar, som kan användas för optimering av hyperparametrar eller molndataindata som monteras eller laddas ned till beräkningsmålet. Utdata (ignorera mått) är artefakter som kan skrivas eller kopieras till standardutdata eller namngivna datautdata.

Literala indata

Literalindata matchas direkt i kommandot . Du kan ändra vårt "hello world"-jobb så att det använder literala indata:

$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

Du kan köra det här jobbet:

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

Du kan använda för --set att åsidosätta indata:

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

Literala indata till jobb kan konverteras till sökutrymmesinmatningar för hyperparametersvepar i modellträningen.

Indata för sökutrymme

För ett sökningsjobb kan du ange ett sökutrymme för literalindata som ska väljas från. En fullständig mängd alternativ för sökutrymmesinmatningar finns i YAML-syntaxreferensen för det avsökningsjobbet.

Nu ska vi demonstrera konceptet med ett enkelt Python-skript som tar in argument och loggar ett slumpmässigt mått:

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

Och skapa ett motsvarande sökningsjobb:

$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.

Och kör den:

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

Indata

Dataindata matchas till en sökväg i jobbbearbetningens lokala filsystem. Vi demonstrerar med den klassiska Iris-datauppsättningen, som finns offentligt i en blobcontainer på https://azuremlexamples.blob.core.windows.net/datasets/iris.csv .

Du kan skapa ett Python-skript som tar sökvägen till Iris CSV-filen som ett argument, läser in den i en dataram, skriver ut de första fem raderna och sparar den i outputs katalogen.

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

Azure Storage URI-indata kan anges, som monterar eller laddar ned data till det lokala filsystemet. Du kan ange en enskild fil:

$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

Och kör:

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

Eller ange en hel mapp:

$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

Och kör:

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

Privata data

För privata data i Azure Blob Storage eller Azure Data Lake Storage som är anslutna till Azure Machine Learning via ett datalager kan du använda Azure Machine Learning-URI:er i formatet för azureml://datastores/<DATASTORE_NAME>/paths/<PATH_TO_DATA> indata. Om du till exempel överför Iris CSV till en katalog med namnet i blobcontainern som motsvarar datalagringen med namnet kan du ändra ett tidigare jobb så att det använder filen i /example-data/ workspaceblobstore datalagringen:

$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

Eller hela katalogen:

$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

Standardutdata

Katalogerna ./outputs och behandlas särskilt av ./logs Azure Machine Learning. Om du skriver filer till dessa kataloger under jobbet laddas filerna upp till jobbet så att du fortfarande kan komma åt dem när det är klart. Mappen ./outputs laddas upp i slutet av jobbet, medan filerna som skrivs till laddas upp i ./logs realtid. Använd det senare om du vill strömma loggar under jobbet, till exempel TensorBoard-loggar.

Du kan ändra jobbet "hello world" för att mata ut till en fil i standardutdatakatalogen i stället för att skriva ut till 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

Du kan köra det här jobbet:

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

Och ladda ned loggarna, helloworld.txt där kommer att finnas i <RUN_ID>/outputs/ katalogen:

az ml job download -n $run_id

Datautdata

Du kan ange namngivna datautdata. Detta skapar en katalog i standarddatalagringen som ska läsas/skrivas monterad som standard.

Du kan ändra det tidigare "hello world"-jobbet för att skriva till namngivna datautdata:

$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

Hello-pipelines

Pipelinejobb kan köra flera jobb parallellt eller i följd. Om det finns indata-/utdataberoenden mellan steg i en pipeline körs det beroende steget när det andra har slutförts.

Du kan dela upp ett "hello world"-jobb i två jobb:

$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

Och kör den:

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

Jobben "hello" respektive "world" körs parallellt om beräkningsmålet har de tillgängliga resurserna att göra det.

Om du vill skicka data mellan steg i en pipeline definierar du en datautdata i "hello"-jobbet och motsvarande indata i "world"-jobbet, som refererar till föregående utdata:

$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}}

Och kör den:

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

Den här gången körs "world"-jobbet när jobbet "hello" har slutförts.

För att undvika att duplicera vanliga inställningar mellan jobb i en pipeline kan du ange dem utanför jobben:

$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"

Du kan köra följande:

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

Motsvarande inställning för ett enskilt jobb åsidosätter de vanliga inställningarna för ett pipelinejobb. Begreppen hittills kan kombineras till ett pipelinejobb i tre steg med jobben "A", "B" och "C". C-jobbet har ett databeroende på B-jobbet, medan "A"-jobbet kan köras oberoende av varandra. "A"-jobbet använder också en individuellt inställd miljö och binder en av dess indata till en pipeline-jobbindata på toppnivå:

$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}}

Du kan köra följande:

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

Träna en modell

I det här läget har en modell fortfarande inte tränats. Nu ska vi lägga till sklearn kod i ett Python-skript med MLflow-spårning för att träna en modell på Iris CSV:

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

Ramverket scikit-learn stöds av MLflow för autologgning, så ett enda anrop i skriptet loggar alla modellparametrar, träningsmått, modellartefakter och några extra artefakter (i det här fallet en mlflow.autolog() förvirringsmatrisbild).

Om du vill köra detta i molnet anger du som ett jobb:

$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.

Och kör den:

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

Om du vill registrera en modell kan du ladda ned utdata och skapa en modell från den lokala katalogen:

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

Rensa hyperparametrar

Du kan ändra det tidigare jobbet så att det rensar över hyperparametrar:

$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.

Och kör den:

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

Fler alternativ för sökning finns i YAML-syntaxreferensen för det avsökningsjobbet.

Distribuerad träning

Azure Machine Learning stöder PyTorch, TensorFlow och MPI-baserad distribuerad träning. Mer information finns i avsnittet distribuerad i kommandojobbet YAML-syntaxreferens.

Du kan till exempel träna ett cnn-nätverk (Convolutional Neural Network) på CIFAR-10-datauppsättningen med hjälp av distribuerad PyTorch. Det fullständiga skriptet finns i exempeldatabasen.

CIFAR-10-datauppsättningen torchvision i förväntar sig som indata för en katalog som innehåller cifar-10-batches-py katalogen. Du kan ladda ned den komprimerade källan och extrahera den till en lokal katalog:

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

Skapa sedan en Azure Machine Learning datauppsättning från den lokala katalogen, som laddas upp till standarddatalagringen:

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

Du kan också ta bort den lokala filen och katalogen:

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

Datauppsättningar (endast fil) kan refereras till i ett jobb med hjälp av dataset nyckeln för en datainmatning. Formatet är azureml:<DATASET_NAME>:<DATASET_VERSION> , så för den CIFAR-10-datauppsättning som precis har skapats är det azureml:cifar-10-example:1 .

När datauppsättningen är på plats kan du skapa ett distribuerat PyTorch-jobb för att träna vår modell:

$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.

Och kör den:

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

Skapa en träningspipeline

CIFAR-10-exemplet ovan översätts väl till ett pipeline-jobb. Det tidigare jobbet kan delas upp i tre jobb för orkestrering i en pipeline:

• "get-data" för att köra ett Bash-skript för att ladda ned och extrahera cifar-10-batches-py
• "train-model" för att ta data och träna en modell med distribuerad PyTorch
• "eval-model" för att ta data och den tränade modellen och utvärdera noggrannhet

Både "train-model" och "eval-model" är beroende av "get-data"-jobbets utdata. Dessutom har "eval-model" ett beroende på "train-model"-jobbets utdata. De tre jobben körs därför sekventiellt.

Du kan orkestrera dessa tre jobb i ett pipelinejobb:

$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}}

Och kör:

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

Pipelines kan också skrivas med återanvändbara komponenter. Mer information finns i Skapa och köra komponentbaserade pipelines för maskininlärning med hjälp Azure Machine Learning CLI (förhandsversion).

Nästa steg

• Distribuera och poängsätta en maskininlärningsmodell med en hanterad onlineslutpunkt (förhandsversion)