Modeltraining op serverloze compute

Artikel
10/02/2024

VAN TOEPASSING OP:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

U hoeft geen rekenkracht meer te maken en te beheren om uw model op een schaalbare manier te trainen. Uw taak kan in plaats daarvan worden verzonden naar een nieuw type rekendoel, serverloze rekenkracht genoemd. Serverloze berekening is de eenvoudigste manier om trainingstaken uit te voeren op Azure Machine Learning. Serverloze computing is een volledig beheerde, on-demand compute. Azure Machine Learning maakt, schaalt en beheert de rekenkracht voor u. Door modeltraining met serverloze berekeningen kunnen machine learning-professionals zich richten op hun expertise op het bouwen van machine learning-modellen en hoeven ze niet meer te weten te komen over de rekeninfrastructuur of het instellen ervan.

Machine learning-professionals kunnen de resources opgeven die nodig zijn voor de taak. Azure Machine Learning beheert de rekeninfrastructuur en biedt beheerd netwerkisolatie de belasting voor u te verminderen.

Ondernemingen kunnen ook kosten verlagen door optimale resources voor elke taak op te geven. IT-beheerders kunnen nog steeds controle toepassen door het quotum voor kernen op abonnements- en werkruimteniveau op te geven en Azure-beleid toe te passen.

Serverloze rekenkracht kan worden gebruikt om modellen in de modelcatalogus af te stemmen, zoals LLAMA 2. Serverloze berekeningen kunnen worden gebruikt om alle typen taken uit te voeren vanuit Azure Machine Learning-studio, SDK en CLI. Serverloze berekeningen kunnen ook worden gebruikt voor het bouwen van omgevingsinstallatiekopieën en voor verantwoorde AI-dashboardscenario's. Serverloze taken verbruiken hetzelfde quotum als het rekenquotum van Azure Machine Learning. U kunt standaard (toegewezen) laag- of spot-VM's (met lage prioriteit) kiezen. Beheerde identiteit en gebruikersidentiteit worden ondersteund voor serverloze taken. Het factureringsmodel is hetzelfde als Azure Machine Learning Compute.

Voordelen van serverloze rekenkracht

Azure Machine Learning beheert het maken, instellen, schalen, verwijderen, patchen, rekeninfrastructuur verminderen de beheeroverhead
U hoeft niet meer te weten te komen over berekeningen, verschillende rekentypen en gerelateerde eigenschappen.
Het is niet nodig om herhaaldelijk clusters te maken voor elke benodigde VM-grootte, met dezelfde instellingen en repliceren voor elke werkruimte.
U kunt de kosten optimaliseren door de exacte resources op te geven die elke taak tijdens runtime nodig heeft in termen van instantietype (VM-grootte) en het aantal exemplaren. U kunt de metrische gegevens over het gebruik van de taak controleren om de resources te optimaliseren die een taak nodig zou hebben.
Vermindering van de stappen die nodig zijn om een taak uit te voeren
Als u het indienen van taken verder wilt vereenvoudigen, kunt u de resources helemaal overslaan. In Azure Machine Learning wordt het aantal exemplaren standaard ingesteld en wordt een exemplaartype (VM-grootte) gekozen op basis van factoren zoals quotum, kosten, prestaties en schijfgrootte.
Minder wachttijden voordat taken in sommige gevallen worden uitgevoerd.
Door de gebruiker toegewezen beheerde identiteit van de gebruiker en werkruimte wordt ondersteund voor het verzenden van taken.
Met beheerd netwerkisolatie kunt u uw netwerkisolatieconfiguratie stroomlijnen en automatiseren. Virtueel netwerk van de klant wordt ook ondersteund
Beheer via quotum- en Azure-beleid

Serverloze berekeningen gebruiken

U kunt basismodellen zoals LLAMA 2 verfijnen met behulp van notebooks, zoals hieronder wordt weergegeven:
- LLAMA 2 verfijnen
- LLAMA 2 verfijnen met meerdere knooppunten
Wanneer u uw eigen rekencluster maakt, gebruikt u de naam ervan in de opdrachttaak, zoals compute="cpu-cluster". Met serverloos kunt u het maken van een rekencluster overslaan en de compute parameter weglaten om in plaats daarvan serverloze berekeningen te gebruiken. Wanneer compute niet is opgegeven voor een taak, wordt de taak uitgevoerd op serverloze berekeningen. Laat de rekennaam in uw CLI- of SDK-taken weg om serverloze berekening te gebruiken in de volgende taaktypen en geef eventueel resources op die een taak nodig zou hebben in termen van het aantal exemplaren en het exemplaartype:
- Opdrachttaken, inclusief interactieve taken en gedistribueerde training
- AutoML-taken
- Taken opruimen
- Parallelle taken
Gebruik voor pijplijntaken via CLI default_compute: azureml:serverless voor standaard berekenen op pijplijnniveau. Gebruik voor pijplijntaken via SDK default_compute="serverless". Zie de pijplijntaak voor een voorbeeld.
Wanneer u een trainingstaak indient in Studio (preview), selecteert u Serverloos als het rekentype.
Wanneer u Azure Machine Learning Designer gebruikt, selecteert u Serverloos als standaard berekenen.
U kunt serverloze berekeningen gebruiken voor een verantwoord AI-dashboard
- Scenario voor autoML-afbeeldingsclassificatie met RAI-dashboard

Prestatieoverwegingen

Serverloze berekeningen kunnen u helpen uw training op de volgende manieren te versnellen:

Onvoldoende quotum: Wanneer u uw eigen rekencluster maakt, bent u verantwoordelijk voor het bepalen welke VM-grootte en het aantal knooppunten u wilt maken. Wanneer uw taak wordt uitgevoerd, mislukt de taak als u onvoldoende quotum hebt voor het cluster. Serverloze compute gebruikt informatie over uw quotum om standaard een geschikte VM-grootte te selecteren.

Optimalisatie van omlaag schalen: wanneer een rekencluster omlaag wordt geschaald, moet een nieuwe taak wachten totdat de schaal omlaag gaat en vervolgens omhoog schalen voordat de taak kan worden uitgevoerd. Met serverloze berekening hoeft u niet te wachten op omlaag schalen en kan uw taak worden uitgevoerd op een ander cluster/knooppunt (ervan uitgaande dat u een quotum hebt).

Optimalisatie van cluster bezet: wanneer een taak wordt uitgevoerd op een rekencluster en er een andere taak wordt verzonden, wordt uw taak in de wachtrij geplaatst achter de momenteel actieve taak. Met serverloze berekening krijgt u een ander knooppunt/een ander cluster om de taak uit te voeren (ervan uitgaande dat u een quotum hebt).

Quotum

Wanneer u de taak indient, hebt u nog steeds voldoende Azure Machine Learning-rekenquotum nodig om door te gaan (quotum op werkruimte- en abonnementsniveau). De standaard VM-grootte voor serverloze taken wordt geselecteerd op basis van dit quotum. Als u uw eigen VM-grootte/-familie opgeeft:

Als u een quotum hebt voor uw VM-grootte/-familie, maar niet voldoende quotum voor het aantal exemplaren, ziet u een fout. De fout raadt aan om het aantal exemplaren te verlagen naar een geldig getal op basis van uw quotumlimiet of om een quotumverhoging aan te vragen voor deze VM-serie of om de VM-grootte te wijzigen
Als u geen quotum hebt voor de opgegeven VM-grootte, ziet u een fout. De fout raadt u aan een andere VM-grootte te selecteren waarvoor u wel een quotum of aanvraagquotum hebt voor deze VM-serie
Als u wel voldoende quotum hebt voor de VM-serie om de serverloze taak uit te voeren, maar andere taken het quotum gebruiken, krijgt u een bericht dat uw taak in een wachtrij moet wachten totdat het quotum beschikbaar is

Wanneer u uw gebruik en quotum in Azure Portal bekijkt, ziet u de naam Serverloos om alle quota te zien die worden verbruikt door serverloze taken.

Identiteitsondersteuning en referentiepassthrough

Passthrough van gebruikersreferenties: serverloze compute biedt volledige ondersteuning voor passthrough van gebruikersreferenties. Het gebruikerstoken van de gebruiker die de taak verzendt, wordt gebruikt voor opslagtoegang. Deze referenties zijn afkomstig van uw Microsoft Entra-id.

Python SDK
Azure-CLI

from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

Maak een bestand met de naam hello.yaml met de volgende inhoud:

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
identity:
  type: user_identity

Verzend de taak met de volgende opdracht:

az ml job create --file hello.yaml --resource-group my-resource-group --workspace-name my-workspace

In de rest van de CLI-voorbeelden ziet u variaties van het bestand hello.yaml. Voer ze allemaal op dezelfde manier uit.

Door de gebruiker toegewezen beheerde identiteit : wanneer u een werkruimte hebt geconfigureerd met door de gebruiker toegewezen beheerde identiteit, kunt u die identiteit gebruiken met de serverloze taak voor opslagtoegang. Zie Verificatiereferentiegeheimen gebruiken in Azure Machine Learning-taken voor toegang tot geheimen.

Python SDK
Azure-CLI

from azure.ai.ml import command
from azure.ai.ml import MLClient     # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import ManagedIdentityConfiguration

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
        identity= ManagedIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
identity:
  type: managed

Zie De door de gebruiker toegewezen beheerde identiteit koppelen voor meer informatie over het koppelen van een door de gebruiker toegewezen beheerde identiteit.

Eigenschappen voor opdrachttaken configureren

Als er geen rekendoel is opgegeven voor opdrachten, opruimen en AutoML-taken, wordt de berekening standaard ingesteld op serverloze berekeningen. Bijvoorbeeld voor deze opdrachttaak:

Python SDK
Azure-CLI

from azure.ai.ml import command
from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest

De berekening wordt standaard ingesteld op serverloze berekeningen met:

Eén knooppunt voor deze taak. Het standaardaantal knooppunten is gebaseerd op het type taak. Zie de volgende secties voor andere taaktypen.
Virtuele CPU-machine, die wordt bepaald op basis van quotum, prestaties, kosten en schijfgrootte.
Toegewezen virtuele machines
Locatie van werkruimte

U kunt deze standaardinstellingen overschrijven. Als u het VM-type of het aantal knooppunten voor serverloze berekeningen wilt opgeven, voegt u deze toe resources aan uw taak:

instance_type om een specifieke VIRTUELE machine te kiezen. Gebruik deze parameter als u een specifieke CPU/GPU-VM-grootte wilt

instance_count om het aantal knooppunten op te geven.

Python SDK
Azure-CLI

from azure.ai.ml import command 
from azure.ai.ml import MLClient # Handle to the workspace
from azure.identity import DefaultAzureCredential # Authentication package
from azure.ai.ml.entities import JobResourceConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    resources = JobResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
resources:
  instance_count: 4
  instance_type: Standard_NC24

Als u de taaklaag wilt wijzigen, kiest queue_settings u tussen toegewezen VM's (job_tier: Standard) en Lage prioriteit(jobtier: Spot).

Python SDK
Azure-CLI

from azure.ai.ml import command
from azure.ai.ml import MLClient    # Handle to the workspace
from azure.identity import DefaultAzureCredential    # Authentication package
credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
    queue_settings={
      "job_tier": "spot"  
    }
)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
component: ./train.yml 
queue_settings:
   job_tier: Standard #Possible Values are Standard (dedicated), Spot (low priority). Default is Standard.

Voorbeeld voor alle velden met opdrachttaken

Hier volgt een voorbeeld van alle velden die zijn opgegeven, inclusief identiteit die de taak moet gebruiken. U hoeft geen instellingen voor virtuele netwerken op te geven als beheerd netwerkisolatie op werkruimteniveau automatisch wordt gebruikt.

Python SDK
Azure-CLI

from azure.ai.ml import command
from azure.ai.ml import MLClient      # Handle to the workspace
from azure.identity import DefaultAzureCredential     # Authentication package
from azure.ai.ml.entities import ResourceConfiguration
from azure.ai.ml.entities import UserIdentityConfiguration 

credential = DefaultAzureCredential()
# Get a handle to the workspace. You can find the info on the workspace tab on ml.azure.com
ml_client = MLClient(
    credential=credential,
    subscription_id="<Azure subscription id>", 
    resource_group_name="<Azure resource group>",
    workspace_name="<Azure Machine Learning Workspace>",
)
job = command(
    command="echo 'hello world'",
    environment="azureml://registries/azureml/environments/sklearn-1.5/labels/latest",
         identity=UserIdentityConfiguration(),
    queue_settings={
      "job_tier": "Standard"  
    }
)
job.resources = ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=1)
# submit the command job
ml_client.create_or_update(job)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: library/python:latest
queue_settings:
   job_tier: Standard #Possible Values are Standard, Spot. Default is Standard.
identity:
  type: user_identity #Possible values are Managed, user_identity
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3

Bekijk meer voorbeelden van training met serverloze compute op:-

AutoML-taak

U hoeft geen berekening op te geven voor AutoML-taken. Resources kunnen eventueel worden opgegeven. Als het aantal exemplaren niet is opgegeven, wordt deze standaard ingesteld op basis van max_concurrent_trials en max_nodes parameters. Als u een AutoML-installatiekopieclassificatie of NLP-taak zonder exemplaartype verzendt, wordt de GROOTTE van de GPU-VM automatisch geselecteerd. Het is mogelijk om een AutoML-taak te verzenden via CLIs, SDK of Studio. Als u AutoML-taken wilt verzenden met serverloze berekeningen in Studio, moet u eerst de functie Voor het verzenden van een trainingstaak in studio (preview) in het preview-deelvenster inschakelen.

Python SDK
Azure-CLI

Als u het aantal exemplaren of het type wilt opgeven, gebruikt u de ResourceConfiguration klasse.

# Create the AutoML classification job with the related factory-function.
from azure.ai.ml.entities import ResourceConfiguration 

classification_job = automl.classification(
    experiment_name=exp_name,
    training_data=my_training_data_input,
    target_column_name="y",
    primary_metric="accuracy",
    n_cross_validations=5,
    enable_model_explainability=True,
    tags={"my_custom_tag": "My custom value"},
)

# Limits are all optional
classification_job.set_limits(
    timeout_minutes=600,
    trial_timeout_minutes=20,
    max_trials=max_trials,
    # max_concurrent_trials = 4,
    # max_cores_per_trial: -1,
    enable_early_termination=True,
)

# Training properties are optional
classification_job.set_training(
    blocked_training_algorithms=[ClassificationModels.LOGISTIC_REGRESSION],
    enable_onnx_compatible_models=True,
)

# Serverless compute resources used to run the job
classification_job.resources = 
ResourceConfiguration(instance_type="Standard_E4s_v3", instance_count=6)

Als u het type of het aantal exemplaren wilt opgeven, voegt u een resources sectie toe.

$schema: https://azuremlsdk2.blob.core.windows.net/preview/0.0.1/autoMLJob.schema.json
type: automl
experiment_name: dpv2-cli-automl-classifier-experiment
description: A Classification job using bank marketing
# Serverless compute is used to run this AutoML job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.

task: classification
log_verbosity: debug
primary_metric: accuracy

target_column_name: "y"

#validation_data_size: 0.20
#n_cross_validations: 5
#test_data_size: 0.1

training_data:
  path: "./training-mltable-folder"
  type: mltable
validation_data:
  path: "./validation-mltable-folder"
  type: mltable
test_data:
  path: "./test-mltable-folder"
  type: mltable

limits:
  timeout_minutes: 180
  max_trials: 40
  max_concurrent_trials: 5
  trial_timeout_minutes: 20
  enable_early_termination: true
  exit_score: 0.92

featurization:
  mode: custom
  transformer_params:
    imputer:
      - fields: ["job"]
        parameters:
          strategy: most_frequent
  blocked_transformers:
    - WordEmbedding
training:
  enable_model_explainability: true
  allowed_training_algorithms:
    - gradient_boosting
    - logistic_regression
# Resources to run this serverless job
resources:
  instance_type="Standard_E4s_v3"
  instance_count=5

Geef "serverless" voor een pijplijntaak op als uw standaardrekentype voor het gebruik van serverloze berekeningen.

# Construct pipeline
@pipeline()
def pipeline_with_components_from_yaml(
    training_input,
    test_input,
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
):
    """E2E dummy train-score-eval pipeline with components defined via yaml."""
    # Call component obj as function: apply given inputs & parameters to create a node in pipeline
    train_with_sample_data = train_model(
        training_data=training_input,
        max_epochs=training_max_epochs,
        learning_rate=training_learning_rate,
        learning_rate_schedule=learning_rate_schedule,
    )

    score_with_sample_data = score_data(
        model_input=train_with_sample_data.outputs.model_output, test_data=test_input
    )
    score_with_sample_data.outputs.score_output.mode = "upload"

    eval_with_sample_data = eval_model(
        scoring_result=score_with_sample_data.outputs.score_output
    )

    # Return: pipeline outputs
    return {
        "trained_model": train_with_sample_data.outputs.model_output,
        "scored_data": score_with_sample_data.outputs.score_output,
        "evaluation_report": eval_with_sample_data.outputs.eval_output,
    }


pipeline_job = pipeline_with_components_from_yaml(
    training_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    test_input=Input(type="uri_folder", path=parent_dir + "/data/"),
    training_max_epochs=20,
    training_learning_rate=1.8,
    learning_rate_schedule="time-based",
)

# set pipeline to use serverless compute
pipeline_job.settings.default_compute = "serverless"

Geef azureml:serverless voor een pijplijntaak op als uw standaardrekentype voor het gebruik van serverloze berekeningen.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
display_name: 1b_e2e_registered_components
description: E2E dummy train-score-eval pipeline with registered components
# Serverless compute is used to run this pipeline job. 
# Through serverless compute, Azure Machine Learning takes care of creating, scaling, deleting, patching and managing compute, along with providing managed network isolation, reducing the burden on you.
inputs:
  pipeline_job_training_max_epocs: 20
  pipeline_job_training_learning_rate: 1.8
  pipeline_job_learning_rate_schedule: 'time-based'

outputs: 
  pipeline_job_trained_model:
    mode: upload
  pipeline_job_scored_data:
    mode: upload
  pipeline_job_evaluation_report:
    mode: upload

settings:
 default_compute: azureml:serverless

jobs:
  train_job:
    type: command
    component: azureml:my_train@latest
    inputs:
      training_data: 
        type: uri_folder 
        path: ./data      
      max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
      learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
      learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
    outputs:
      model_output: ${{parent.outputs.pipeline_job_trained_model}}
    services:
      my_vscode:
        type: vs_code
      my_jupyter_lab:
        type: jupyter_lab
      my_tensorboard:
        type: tensor_board
        log_dir: "outputs/tblogs"
    #  my_ssh:
    #    type: tensor_board
    #    ssh_public_keys: <paste the entire pub key content>
    #    nodes: all # Use the `nodes` property to pick which node you want to enable interactive services on. If `nodes` are not selected, by default, interactive applications are only enabled on the head node.

  score_job:
    type: command
    component: azureml:my_score@latest
    inputs:
      model_input: ${{parent.jobs.train_job.outputs.model_output}}
      test_data: 
        type: uri_folder 
        path: ./data
    outputs:
      score_output: ${{parent.outputs.pipeline_job_scored_data}}

  evaluate_job:
    type: command
    component: azureml:my_eval@latest
    inputs:
      scoring_result: ${{parent.jobs.score_job.outputs.score_output}}
    outputs:
      eval_output: ${{parent.outputs.pipeline_job_evaluation_report}}

U kunt serverloze berekeningen ook instellen als de standaard rekenkracht in Designer.

Volgende stappen