Modellen trainen met de CLI (v2) (preview)

De Azure Machine Learning CLI (v2) is een Azure CLI-extensie waarmee u het modeltrainingsproces kunt versnellen tijdens het omhoog schalen en uitschalen op Azure Compute, waarbij de levenscyclus van het model wordt bijgespoord en gecontroleerd.

Het trainen machine learning model is doorgaans een iteratief proces. Moderne hulpprogramma's maken het gemakkelijker dan ooit om grotere modellen sneller te trainen op meer gegevens. Eerder omslachtig handmatige processen, zoals afstemming van hyperparameters en zelfs het selecteren van algoritmen, worden vaak geautomatiseerd. Met de Azure Machine Learning CLI (v2) kunt u uw taken (en modellen) bijhouden in een werkruimte met hyperparameters, omhoog schalen op Krachtige Azure-rekenkracht en uitschalen met behulp van gedistribueerde training.

Vereisten

• Als u de CLI (v2) wilt gebruiken, moet u een Azure-abonnement hebben. Als u geen Azure-abonnement hebt, maakt u een gratis account voordat u begint. Probeer vandaag nog de gratis of betaalde versie van Azure Machine Learning.
• Installeer en stel CLI (v2) in.

Opslagplaats met voorbeelden klonen

Als u de trainingsvoorbeelden wilt uitvoeren, kloont u eerst de opslagplaats met voorbeelden en gaat u naar de cli map :

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

Als u kloont, wordt alleen de meest recente door commit naar de opslagplaats gebruikt, waardoor de bewerking --depth 1 minder tijd in beslag kan nemen.

Rekenkracht maken

U kunt een Azure Machine Learning rekencluster maken vanaf de opdrachtregel. Met de volgende opdrachten maakt u bijvoorbeeld één cluster met de naam cpu-cluster en één met de naam 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

Er worden op dit moment geen kosten in rekening gebracht voor rekenkracht, omdat en op nul knooppunten blijven cpu-cluster totdat een taak wordt gpu-cluster verzonden. Meer informatie over het beheren en optimaliseren van kosten voor AmlCompute.

In de volgende voorbeeldtaken in dit artikel wordt een van of cpu-cluster gpu-cluster gebruikt. Pas deze namen in de voorbeeldtaken in dit artikel zo nodig aan de naam van uw cluster(s) aan. Gebruik az ml compute create -h voor meer informatie over opties voor het maken van rekenkracht.

Hallo wereld

Voor de Azure Machine Learning CLI (v2) worden taken in YAML-indeling geschreven. Een taak wordt geaggregeerd:

• Wat u moet uitvoeren
• Hoe u deze kunt uitvoeren
• Waar u het kunt uitvoeren

De 'Hallo wereld'-taak heeft alle drie:

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

U kunt het volgende uitvoeren:

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

Waarden overschrijven bij maken of bijwerken

Waarden voor YAML-taakspecificatie kunnen worden overschrijven met behulp van --set bij het maken of bijwerken van een taak. Bijvoorbeeld:

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

Taaknamen

Voor de meeste andere opdrachten dan en is vereist. Dit is de naam van een taak az ml job create of list --name/-n 'Run ID' in de studio. U moet de eigenschap van een taak niet rechtstreeks instellen tijdens het name maken, omdat deze uniek moet zijn per werkruimte. Azure Machine Learning genereert een willekeurige GUID voor de taaknaam als deze niet is ingesteld die kan worden verkregen uit de uitvoer van het maken van een taak in de CLI of door de eigenschap Run ID in de studio en MLflow-API's te kopiëren.

Als u taken in scripts en CI/CD-stromen wilt automatiseren, kunt u de naam van een taak vastleggen wanneer deze wordt gemaakt door de uitvoer op te vragen en te verwijderen door toe te --query name -o tsv voegen. De specifieke informatie verschilt per shell, maar voor Bash:

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

Gebruik vervolgens $run_id in volgende opdrachten, update zoals , show of stream :

az ml job show -n $run_id --web

Taken organiseren

Als u taken wilt ordenen, kunt u een weergavenaam, experimentnaam, beschrijving en tags instellen. Beschrijvingen bieden ondersteuning voor markdown-syntaxis in de studio. Deze eigenschappen zijn veranderlijk nadat een taak is gemaakt. Een volledig voorbeeld:

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

U kunt deze taak uitvoeren, waarbij deze eigenschappen direct zichtbaar zijn in de studio:

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

Met --set kunt u de veranderlijke waarden bijwerken nadat de taak is gemaakt:

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"

Omgevingsvariabelen

U kunt omgevingsvariabelen instellen voor gebruik in uw taak:

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

U kunt deze taak uitvoeren:

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

Modellen en broncode bijhouden

Productie machine learning modellen moeten controleerbaar zijn (indien niet reproduceerbaar). Het is essentieel om de broncode voor een bepaald model bij te houden. Azure Machine Learning maakt een momentopname van uw broncode en bewaart deze bij de taak. Daarnaast worden de bronopslagplaats en -commit bewaard als u taken vanuit een Git-opslagplaats wilt uitvoeren.

U kunt de sleutel code.local_path in een taak opgeven met de waarde als het pad naar een broncodemap. Er wordt een momentopname van de map gemaakt en geüpload met de taak. De inhoud van de map is rechtstreeks beschikbaar vanuit de werkmap van de taak.

Laten we eens kijken naar een taak die code specificeert:

$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

Het Python-script staat in de map met lokale broncode. De opdracht roept vervolgens aan om python het script uit te voeren. Hetzelfde patroon kan worden toegepast op andere programmeertalen.

Modeltracking met MLflow

Bij het itereren van modellen moeten gegevenswetenschappers modelparameters en metrische trainingsgegevens kunnen bijhouden. Azure Machine Learning kan worden geïntegreerd met MLflow-tracering om de logboekregistratie van modellen, artefacten, metrische gegevens en parameters voor een taak mogelijk te maken. Als u MLflow in uw Python-scripts wilt gebruiken, voegt u api's of import mlflow mlflow.log_* API's toe en roept u deze aan in mlflow.autolog() uw trainingscode.

Laten we eens kijken naar het Python-script dat in de bovenstaande taak is aangeroepen en die gebruikt om een parameter, een metrische waarde en mlflow een artefact te logboeken:

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

U kunt deze taak uitvoeren in de cloud via Azure Machine Learning, waar deze wordt bijgespoord en gecontroleerd:

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

Metrische gegevens opvragen met MLflow

Nadat taken zijn uitgevoerd, kunt u de resultaten van de taken en de vastgelegde metrische gegevens opvragen. Python is beter geschikt voor deze taak dan een CLI. U kunt query's uitvoeren en hun metrische gegevens uitvoeren via mlflow en laden in vertrouwde objecten zoals Pandas-gegevensframes voor analyse.

Haal eerst de MLflow-tracerings-URI voor uw Azure Machine Learning op:

az ml workspace show --query mlflow_tracking_uri -o tsv

Gebruik de uitvoer van deze opdracht in mlflow.set_tracking_uri(<YOUR_TRACKING_URI>) vanuit een Python-omgeving waarin MLflow is geïmporteerd. MLflow-aanroepen komen nu overeen met taken in Azure Machine Learning werkruimte.

Invoer en uitvoer

Taken hebben doorgaans invoer en uitvoer. Invoer kan modelparameters zijn, die kunnen worden overgenomen voor hyperparameteroptimalisatie, of cloudgegevensinvoer die worden bevestigd of gedownload naar het rekendoel. Uitvoer (waarbij metrische gegevens worden genegeerd) zijn artefacten die kunnen worden geschreven of gekopieerd naar de standaarduitvoer of een benoemde gegevensuitvoer.

Letterlijke invoer

Letterlijke invoer wordt rechtstreeks opgelost in de opdracht . U kunt onze 'hallo wereld'-taak wijzigen om letterlijke invoer te gebruiken:

$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

U kunt deze taak uitvoeren:

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

U kunt gebruiken --set om invoer te overschrijven:

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

Letterlijke invoer voor taken kan worden geconverteerd naar invoer in de zoekruimte voor hyperparameterops bij modeltraining.

Invoer van zoekruimte

Voor een opsruimingsfunctie kunt u een zoekruimte opgeven voor letterlijke invoer waar uit moet worden gekozen. Zie de yaml-syntaxisverwijzingvoor de zoekruimte voor het volledige scala aan opties voor invoer in de zoekruimte.

Laten we het concept demonstreren met een eenvoudig Python-script waarin argumenten worden gebruikt en een willekeurige metrische gegevens worden bijgeboekt:

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

En maak een bijbehorende opsruimings job:

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

En voer deze uit:

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

Gegevensinvoer

Gegevensinvoer wordt opgelost naar een pad op het lokale bestandssysteem van de taakreken. Laten we eens demonstreren met de klassieke Iris-gegevensset, die openbaar wordt gehost in een blobcontainer op https://azuremlexamples.blob.core.windows.net/datasets/iris.csv .

U kunt een Python-script maken dat het pad naar het CsV-bestand Iris als argument gebruikt, het in een dataframe leest, de eerste vijf regels afdrukt en opgeslagen in de outputs map .

# 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-invoer kan worden opgegeven. Hiermee worden gegevens aan het lokale bestandssysteem toegevoegd of gedownload. U kunt één bestand opgeven:

$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

En voer het volgende uit:

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

Of geef een volledige map op:

$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

En voer het volgende uit:

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

Persoonlijke gegevens

Voor privégegevens in Azure Blob Storage of Azure Data Lake Storage die via een gegevensopslag zijn verbonden met Azure Machine Learning, kunt u Azure Machine Learning URI's van de indeling gebruiken voor azureml://datastores/<DATASTORE_NAME>/paths/<PATH_TO_DATA> invoergegevens. Als u bijvoorbeeld de Iris CSV uploadt naar een map met de naam in de Blob-container die overeenkomt met het gegevensopslag met de naam, kunt u een vorige taak wijzigen om het bestand in het /example-data/ workspaceblobstore gegevensopslag te gebruiken:

$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

Of de volledige map:

$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

Standaarduitvoer

De ./outputs ./logs directories en krijgen een speciale behandeling door Azure Machine Learning. Als u bestanden naar deze mappen schrijft tijdens uw taak, worden deze bestanden geüpload naar de taak, zodat u ze nog steeds kunt openen zodra deze is voltooid. De map wordt geüpload aan het einde van de taak, terwijl de bestanden die naar worden ./outputs ./logs geschreven, in realtime worden geüpload. Gebruik het laatste als u logboeken wilt streamen tijdens de taak, zoals TensorBoard-logboeken.

U kunt de taak 'hello world' wijzigen in uitvoer naar een bestand in de standaardmap outputs in plaats van af te drukken naar 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

U kunt deze taak uitvoeren:

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

En download de logboeken, helloworld.txt waar aanwezig is in de <RUN_ID>/outputs/ map:

az ml job download -n $run_id

Gegevensuitvoer

U kunt benoemde gegevensuitvoer opgeven. Hiermee maakt u een map in de standaardgegevensstore die standaard wordt gelezen/geschreven.

U kunt de eerdere 'hallo wereld'-taak wijzigen om naar een benoemde gegevensuitvoer te schrijven:

$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

Hallo pijplijnen

Pijplijntaken kunnen meerdere taken parallel of opeenvolgend uitvoeren. Als er invoer-/uitvoerafhankelijkheden zijn tussen stappen in een pijplijn, wordt de afhankelijke stap uitgevoerd nadat de andere is voltooid.

U kunt een 'hallo wereld'-taak splitsen in twee taken:

$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

En voer deze uit:

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

De 'hallo' en 'wereld'-taken worden parallel uitgevoerd als het rekendoel de beschikbare resources heeft om dit te doen.

Als u gegevens wilt doorgeven tussen stappen in een pijplijn, definieert u een gegevensuitvoer in de 'hallo'-taak en een bijbehorende invoer in de 'wereld'-taak, die verwijst naar de uitvoer van de vorige:

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

En voer deze uit:

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

Deze keer wordt de 'wereld'-taak uitgevoerd nadat de 'hallo'-taak is voltooid.

Om te voorkomen dat veelvoorkomende instellingen voor taken in een pijplijn worden gedupliceerd, kunt u deze buiten de taken instellen:

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

U kunt dit uitvoeren:

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

De bijbehorende instelling voor een afzonderlijke taak overschrijven de algemene instellingen voor een pijplijn-taak. De concepten tot nu toe kunnen worden gecombineerd tot een pijplijn met drie stappen met de taken A, B en C. De C-taak heeft een gegevensafhankelijkheid van de B-taak, terwijl de A-taak onafhankelijk kan worden uitgevoerd. De 'A'-taak gebruikt ook een afzonderlijk in te stellen omgeving en verbindt een van de invoer aan een pijplijn taakinvoer op het hoogste niveau:

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

U kunt dit uitvoeren:

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

Een model trainen

Op dit moment is een model nog steeds niet getraind. Laten we wat code toevoegen sklearn aan een Python-script met MLflow-tracering om een model te trainen op de 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)

Het scikit-learn-framework wordt ondersteund door MLflow voor automatisch aanmelden, dus met één aanroep in het script worden alle modelparameters, metrische trainingsgegevens, modelartefacten en enkele extra artefacten (in dit geval een verwarringsmatrixafbeelding) in een logboek mlflow.autolog() geplaatst.

Als u dit wilt uitvoeren in de cloud, geeft u op als een taak:

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

En voer deze uit:

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

Als u een model wilt registreren, kunt u de uitvoer downloaden en een model maken vanuit de lokale map:

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

Hyperparameters opruimen

U kunt de vorige taak wijzigen om over hyperparameters te vegen:

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

En voer deze uit:

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

Zie de yaml-syntaxisverwijzing voor de opsp-taak voor meer opszoekopties.

Gedistribueerde training

Azure Machine Learning ondersteunt gedistribueerde training op basis van PyTorch, TensorFlow en MPI. Zie de gedistribueerde sectie van de yaml-syntaxisverwijzing van de opdracht job voor meer informatie.

U kunt bijvoorbeeld een convolutioneel neuraal netwerk (CNN) trainen op de CIFAR-10-gegevensset met behulp van gedistribueerde PyTorch. Het volledige script is beschikbaar in de opslagplaats met voorbeelden.

De CIFAR-10-gegevensset in torchvision verwacht dat deze een map invoert die de map cifar-10-batches-py bevat. U kunt de ingepakte bron downloaden en uitpakken in een lokale map:

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

Maak vervolgens een Azure Machine Learning gegevensset uit de lokale map, die wordt geüpload naar de standaardgegevensstore:

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

Verwijder desgewenst het lokale bestand en de lokale map:

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

Naar gegevenssets (alleen bestand) kan in een taak worden verwezen met behulp van de dataset sleutel van een gegevensinvoer. De indeling is azureml:<DATASET_NAME>:<DATASET_VERSION> , dus voor de CIFAR-10-gegevensset die zojuist is gemaakt, is dit azureml:cifar-10-example:1 .

Als de gegevensset is gemaakt, kunt u een gedistribueerde PyTorch-taak maken om ons model te trainen:

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

En voer deze uit:

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

Een trainingspijplijn bouwen

Het bovenstaande CIFAR-10-voorbeeld vertaalt zich goed naar een pijplijn-taak. De vorige taak kan worden gesplitst in drie taken voor orchestration in een pijplijn:

• 'get-data' om een Bash-script uit te voeren om te downloaden en uit te voeren cifar-10-batches-py
• 'train-model' om de gegevens te nemen en een model te trainen met gedistribueerde PyTorch
• 'eval-model' om de gegevens en het getrainde model te nemen en de nauwkeurigheid te evalueren

Zowel 'train-model' als 'eval-model' is afhankelijk van de uitvoer van de 'get-data'-taak. Daarnaast is 'eval-model' afhankelijk van de uitvoer van de 'train-model'-taak. De drie taken worden dus opeenvolgend uitgevoerd.

U kunt deze drie taken in een pijplijntaken ins hand doen:

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

En voer het volgende uit:

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

Pijplijnen kunnen ook worden geschreven met herbruikbare onderdelen. Zie Create and run components-based machine learning pipelines with the Azure Machine Learning CLI (Preview) (Oponderdelen gebaseerde pijplijnen maken en uitvoeren met de cli (preview) voor meer informatie.

Volgende stappen

• Een model met een machine learning implementeren en scoren met een beheerd online-eindpunt (preview)