Träna modeller med Azure ML Python SDK v2 (förhandsversion)

GÄLLER FÖR: Python SDK azure-ai-ml v2 (förhandsversion)

Viktigt

SDK v2 är för närvarande i offentlig förhandsversion. Förhandsversionen tillhandahålls utan serviceavtal och rekommenderas inte för produktionsarbetsbelastningar. Vissa funktioner kanske inte stöds eller kan vara begränsade. Mer information finns i Kompletterande villkor för användning av Microsoft Azure-förhandsversioner.

I den här artikeln får du lära dig hur du konfigurerar och skickar Azure Machine Learning jobb för att träna dina modeller. Kodfragment förklarar de viktigaste delarna i konfigurationen och sändningen av ett träningsjobb. Använd sedan en av exempelanteckningsböckerna för att hitta de fullständiga arbetsexemplen från slutpunkt till slutpunkt.

Förutsättningar

Lagringsplats för klonexempel

Om du vill köra träningsexemplen klonar du först exempellagringsplatsen och ändrar till sdk katalogen:

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

Tips

Använd --depth 1 för att endast klona den senaste incheckningen till lagringsplatsen, vilket minskar tiden för att slutföra åtgärden.

Starta på din lokala dator

Börja med att köra ett skript som tränar en modell med hjälp av lightgbm. Skriptfilen finns här. Skriptet behöver tre indata

  • indata: Du använder data från en webbplats för din körning – webbplats. I det här exemplet använder vi en fil på en fjärrplats för korthet, men du kan också använda en lokal fil.
  • inlärningsfrekvens: Du använder en inlärningstakt på 0,9
  • boost: Du använder gradient boost gdbt

Kör den här skriptfilen på följande sätt

cd jobs/single-step/lightgbm/iris

python src/main.py --iris-csv https://azuremlexamples.blob.core.windows.net/datasets/iris.csv  --learning-rate 0.9 --boosting gbdt

Förväntade utdata är följande:

2022/04/21 15:02:44 INFO mlflow.tracking.fluent: Autologging successfully enabled for lightgbm.
2022/04/21 15:02:44 INFO mlflow.tracking.fluent: Autologging successfully enabled for sklearn.
2022/04/21 15:02:45 INFO mlflow.utils.autologging_utils: Created MLflow autologging run with ID 'a1d5f652796e4d88961176166de52253', which will track hyperparameters, performance metrics, model artifacts, and lineage information for the current lightgbm workflow
lightgbm\engine.py:177: UserWarning: Found `num_iterations` in params. Will use it instead of argument
[LightGBM] [Warning] Auto-choosing col-wise multi-threading, the overhead of testing was 0.000164 seconds.
You can set `force_col_wise=true` to remove the overhead.
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf
[LightGBM] [Warning] No further splits with positive gain, best gain: -inf

Flytta till molnet

Nu när den lokala körningen fungerar flyttar du den här körningen till en Azure Machine Learning arbetsyta. Om du vill köra detta på Azure ML behöver du:

  • En arbetsyta att köra
  • En beräkning som den ska köras på
  • En miljö på beräkningen för att säkerställa att du har de paket som krävs för att köra skriptet

Låt oss ta itu med dessa steg nedan

1. Anslut till arbetsytan

För att ansluta till arbetsytan behöver du identifierarparametrar – en prenumeration, en resursgrupp och ett arbetsytenamn. Du använder den här informationen i MLClient från azure.ai.ml för att få ett handtag till den nödvändiga Azure Machine Learning arbetsytan. Om du vill autentisera använder du azure-standardautentiseringen. I det här exemplet finns mer information om hur du konfigurerar autentiseringsuppgifter och ansluter till en arbetsyta.

#import required libraries
from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

#Enter details of your AzureML workspace
subscription_id = '<SUBSCRIPTION_ID>'
resource_group = '<RESOURCE_GROUP>'
workspace = '<AZUREML_WORKSPACE_NAME>'

#connect to the workspace
ml_client = MLClient(DefaultAzureCredential(), subscription_id, resource_group, workspace)

2. Skapa beräkning

Du skapar en beräkning med namnet cpu-cluster för jobbet med den här koden:

from azure.ai.ml.entities import AmlCompute

# specify aml compute name.
cpu_compute_target = "cpu-cluster"

try:
    ml_client.compute.get(cpu_compute_target)
except Exception:
    print("Creating a new cpu compute target...")
    compute = AmlCompute(
        name=cpu_compute_target, size="STANDARD_D2_V2", min_instances=0, max_instances=4
    )
    ml_client.compute.begin_create_or_update(compute)

3. Miljö för att köra skriptet

Om du vill köra skriptet på cpu-clusterbehöver du en miljö som har de paket och beroenden som krävs för att köra skriptet. Det finns några tillgängliga alternativ för miljöer:

  • Använd en kuraterad miljö på din arbetsyta – Azure ML erbjuder flera utvalda miljöer som tillgodoser olika behov.

  • Använd en anpassad miljö – Med Azure ML kan du skapa en egen miljö med hjälp av

    • En docker-avbildning
    • En base docker-avbildning med en conda YAML för att anpassa ytterligare
    • En Docker-byggkontext

    Kontrollera det här exemplet om hur du skapar anpassade miljöer.

Du använder en kuraterad miljö som tillhandahålls av Azure ML för lightgm anropadAzureML-lightgbm-3.2-ubuntu18.04-py37-cpu

4. Skicka ett jobb för att köra skriptet

Om du vill köra det här skriptet använder du en command. Kommandot körs genom att skicka det som en job till Azure ML.

from azure.ai.ml import command, Input

# define the command
command_job = command(
    code="./src",
    command="python main.py --iris-csv ${{inputs.iris_csv}} --learning-rate ${{inputs.learning_rate}} --boosting ${{inputs.boosting}}",
    environment="AzureML-lightgbm-3.2-ubuntu18.04-py37-cpu@latest",
    inputs={
        "iris_csv": Input(
            type="uri_file",
            path="https://azuremlexamples.blob.core.windows.net/datasets/iris.csv",
        ),
        "learning_rate": 0.9,
        "boosting": "gbdt",
    },
    compute="cpu-cluster",
)
# submit the command
returned_job = ml_client.jobs.create_or_update(command_job)
# get a URL for the status of the job
returned_job.services["Studio"].endpoint

I ovanstående konfigurerade du:

  • code – sökväg där koden som ska köra kommandot finns
  • command - kommando som måste köras
  • inputs – ordlista över indata med namnvärdepar till kommandot. Nyckeln är ett namn på indata i jobbets kontext och värdet är indatavärdet. Indata refereras i command med uttrycket ${{inputs.<input_name>}} . Om du vill använda filer eller mappar som indata kan du använda Input klassen .

Mer information finns i referensdokumentationen.

Förbättra modellen med hjälp av hyperparametersrensning

Nu när du har kört ett jobb i Azure kan vi göra det bättre med hjälp av hyperparameterjustering. Detta kallas även för optimering av hyperparametrar. Det här är processen för att hitta konfigurationen av hyperparametrar som ger bästa prestanda. Azure Machine Learning ger en sweep funktion på command för att göra hyperparameterjustering.

För att utföra en svepning måste det finnas indata mot vilka svepet måste utföras. Dessa indata kan ha ett diskret eller kontinuerligt värde. Funktionen sweep kör flera command gånger med en annan kombination av angivna indatavärden. Varje indata är en ordlista med namnvärdepar. Nyckeln är namnet på hyperparametern och värdet är parameteruttrycket.

Låt oss förbättra vår modell genom att sopa in learning_rate och boosting indata till skriptet. I föregående steg använde du ett specifikt värde för dessa parametrar, men nu ska du använda ett intervall eller val av värden.

# we will reuse the command_job created before. we call it as a function so that we can apply inputs
# we do not apply the 'iris_csv' input again -- we will just use what was already defined earlier
command_job_for_sweep = command_job(
    learning_rate=Uniform(min_value=0.01, max_value=0.9),
    boosting=Choice(values=["gbdt", "dart"]),
)

Nu när du har definierat parametrarna kör du svepet

# apply the sweep parameter to obtain the sweep_job
sweep_job = command_job_for_sweep.sweep(
    compute="cpu-cluster",
    sampling_algorithm="random",
    primary_metric="test-multi_logloss",
    goal="Minimize",
)

# define the limits for this sweep
sweep_job.set_limits(max_total_trials=20, max_concurrent_trials=10, timeout=7200)
# submit the sweep
returned_sweep_job = ml_client.create_or_update(sweep_job)
# get a URL for the status of the job
returned_sweep_job.services["Studio"].endpoint

Som vi ser ovan sweep gör funktionen att användaren kan konfigurera följande viktiga aspekter:

  • sampling_algorithm– Algoritmen för hyperparametersampling som ska användas över search_space. Tillåtna värden är random, grid och bayesian.
  • objective - Målet med svepningen
    • primary_metric – Namnet på det primära mått som rapporteras av varje utvärderingsjobb. Måttet måste loggas i användarens träningsskript med mlflow.log_metric() samma motsvarande måttnamn.
    • goal – Optimeringsmålet för objective.primary_metric. De tillåtna värdena är maximize och minimize.
  • compute – Namnet på beräkningsmålet som jobbet ska köras på.
  • limits - Gränser för svepjobbet

När jobbet är klart kan du titta på måtten och jobbinformationen i Azure ML Portal. På sidan med jobbinformation identifieras den underordnade körning som fungerar bäst.

Best run of the sweep

Distribuerad träning

Azure Machine Learning stöder PyTorch, TensorFlow och MPI-baserad distribuerad träning. Låt oss titta på hur du konfigurerar ett kommando för distribution för den command_job du skapade tidigare

# Distribute using PyTorch
from azure.ai.ml import PyTorchDistribution
command_job.distribution = PyTorchDistribution(process_count_per_instance=4)

# Distribute using TensorFlow
from azure.ai.ml import TensorFlowDistribution
command_job.distribution = TensorFlowDistribution(parameter_server_count=1, worker_count=2)

# Distribute using MPI
from azure.ai.ml import MpiDistribution
job.distribution = MpiDistribution(process_count_per_instance=3)

Nästa steg

Prova följande steg för att lära dig hur du använder Azure Machine Learning SDK (v2) för Python:

  • Använda pipelines med Azure ML Python SDK (v2)