Modeltraining op serverloze compute

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

U hoeft geen rekenkracht te maken en te beheren om uw model op een schaalbare manier te trainen. U kunt uw taak in plaats daarvan verzenden naar een rekendoeltype met de naam serverloze berekening. 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. Wanneer u serverloze berekeningen gebruikt om modellen te trainen, kunt u zich richten op het bouwen van machine learning-modellen en hoeft u niet meer te weten te komen over de rekeninfrastructuur of het instellen ervan.

U kunt de resources opgeven die nodig zijn voor de taak. Azure Machine Learning beheert de rekeninfrastructuur en biedt beheerde netwerkisolatie, waardoor u minder last krijgt.

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

U kunt serverloze berekeningen gebruiken om modellen in de modelcatalogus af te stemmen. U kunt deze gebruiken om alle soorten taken uit te voeren met behulp van Azure Machine Learning Studio, de Python SDK en Azure CLI. U kunt ook serverloze computing gebruiken om omgeving-images te bouwen en AI-dashboardscenario's voor verantwoord gebruik. 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 het model voor Azure Machine Learning Compute.

Voordelen van serverloze rekenkracht

• Azure Machine Learning beheert het maken, instellen, schalen, verwijderen en patchen van rekeninfrastructuur om de beheeroverhead te verminderen.
• U hoeft niet meer te weten te komen over berekeningen, verschillende rekentypen of gerelateerde eigenschappen.
• U hoeft niet herhaaldelijk clusters te maken voor elke VM-grootte die u nodig hebt, met dezelfde instellingen en repliceren voor elke werkruimte.
• U kunt kosten optimaliseren door de exacte resources op te geven die elke taak tijdens runtime nodig heeft voor het exemplaartype (VM-grootte) en het aantal exemplaren. U kunt ook de metrische gebruiksgegevens van de taak bewaken om de resources te optimaliseren die een taak nodig heeft.
• Er zijn minder stappen vereist om een taak uit te voeren.
• Als u het indienen van taken verder wilt vereenvoudigen, kunt u de resources helemaal overslaan. Azure Machine Learning is standaard ingesteld op het aantal exemplaren en kiest een exemplaartype door rekening te houden met factoren zoals quotum, kosten, prestaties en schijfgrootte.
• In sommige scenario's worden wachttijden voordat taken worden uitgevoerd verminderd.
• Gebruikersidentiteit en door de gebruiker toegewezen beheerde identiteit voor werkruimten worden ondersteund voor het indienen van jobs.
• Met beheerd netwerkisolatie kunt u uw netwerkisolatieconfiguratie stroomlijnen en automatiseren. Virtuele netwerken van klanten worden ook ondersteund.
• Beheerbeheer is beschikbaar via quota en Azure-beleid.

Serverloze berekeningen gebruiken

• Wanneer u uw eigen rekencluster maakt, gebruikt u de naam ervan in de opdrachttaak. Bijvoorbeeld: 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 computenaam in uw Azure CLI- of Python SDK-taken weg om serverloze computaties te gebruiken in de volgende typen taken, en geef optioneel de benodigde resources voor de instantieaantallen en het instantietype op.

  • Opdrachttaken, inclusief interactieve taken en gedistribueerde training
  • AutoML-taken
  • Taken opruimen
  • Parallelle taken

• Gebruik voor pijplijntaken via de Azure CLI default_compute: azureml:serverless voor standaard compute op pijplijnniveau. Gebruik default_compute="serverless"voor pijplijntaken via de Python SDK. Zie de pijplijntaak voor een voorbeeld.

• Wanneer u een trainingstaak in studio indient, selecteert u Serverloos als het rekentype.

• Wanneer u Azure Machine Learning Designer gebruikt, selecteert u Serverloos als de standaard rekenkracht.

Prestatieoverwegingen

Serverloze berekeningen kunnen de snelheid van uw training op de volgende manieren verhogen:

Vermijd onvoldoende quotumfouten. Wanneer u uw eigen rekencluster maakt, bent u verantwoordelijk voor het bepalen van de VM-grootte en het aantal knooppunten. Wanneer uw taak wordt uitgevoerd, mislukt de taak als u onvoldoende quotum voor het cluster hebt. 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 het cluster omlaag wordt geschaald en vervolgens omhoog schalen voordat de taak kan worden uitgevoerd. Met serverloze berekening hoeft u niet te wachten op omlaag schalen. Uw taak kan 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 huidige actieve taak. Met serverloze berekeningen kan uw taak worden uitgevoerd op een ander knooppunt/cluster (ervan uitgaande dat u een quotum hebt).

Quotum

Wanneer u een taak verzendt, hebt u nog steeds voldoende Azure Machine Learning-rekenquotum nodig om door te gaan (quotum op werkruimteniveau en op 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 de VM-grootte/-familie, maar niet voldoende quotum voor het aantal exemplaren, wordt er een fout weergegeven. De fout raadt u aan het aantal exemplaren te verlagen tot een geldig getal op basis van uw quotumlimiet, een quotumverhoging aan te vragen voor de VM-familie of 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 de VM-serie.
• Als u voldoende quotum hebt voor een VM-familie om de serverloze taak uit te voeren, maar andere taken het quotum gebruiken, krijgt u een bericht waarin wordt aangegeven dat uw taak in een wachtrij moet wachten totdat het quotum beschikbaar is.

Wanneer u uw gebruik en quota in Azure Portal bekijkt, ziet u de naam Serverloos voor alle quota die worden gebruikt door serverloze taken.

Identiteitsondersteuning en inloggegevensdoorgifte

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

  Serverloze compute biedt geen ondersteuning voor door het systeem toegewezen identiteit.

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

• 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 meer informatie over het openen van geheimen.

1. Controleer de configuratie van uw werkruimte-id.

   • Python SDK
   • Azure-CLI

   from azure.ai.ml import MLClient
   from azure.identity import DefaultAzureCredential
   
   subscription_id = "<your-subscription-id>"
   resource_group = "<your-resource-group>"
   workspace = "<your-workspace-name>"
   
   ml_client = MLClient(
       DefaultAzureCredential(),
       subscription_id,
       resource_group,
       workspace
   )
   
   # Get workspace details.
   ws = ml_client.workspaces.get(name=workspace)
   print(ws)
   
   

   Zoek in de uitvoer naar de door de gebruiker toegewezen identiteit. Als deze ontbreekt, maakt u een nieuwe werkruimte met een door de gebruiker toegewezen beheerde identiteit door de instructies in Verificatie tussen Azure Machine Learning en andere services in te stellen.

2. Gebruik uw door de gebruiker toegewezen beheerde identiteit in uw taak.

   • 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(client_id="<workspace-UAMI-client-ID>"),
   )
   # Submit the command job.
   ml_client.create_or_update(job)
   

Eigenschappen voor opdrachttaken configureren

Als er geen rekendoel is opgegeven voor command-, sweep- en AutoML-taken, dan wordt standaard serverloze rekencapaciteit gebruikt. Hier is een voorbeeld:

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.
• Een virtuele CPU-machine. De VIRTUELE machine 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:

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

• Gebruik instance_count dit 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)
  

• Als u de taaklaag wilt wijzigen, kiest queue_settings u tussen toegewezen VM's (job_tier: Standard) en VM's met lage prioriteit (job_tier: 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)
  

Voorbeeld voor alle velden met opdrachttaken

Hier volgt een voorbeeld waarin alle velden worden weergegeven die zijn opgegeven, inclusief de identiteit die de taak moet gebruiken. U hoeft geen instellingen voor het virtuele netwerk op te geven omdat beheerde netwerkisolatie op werkruimteniveau automatisch wordt gebruikt.

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 and Spot. The default is Standard.
identity:
  type: user_identity # Possible values are Managed and user_identity.
resources:
  instance_count: 1
  instance_type: Standard_E4s_v3 

Hier volgen nog twee voorbeelden van het gebruik van serverloze berekeningen voor training:

• Kijk eerst naar Azure Machine Learning
• Een model trainen

AutoML-taak

U hoeft geen berekening op te geven voor AutoML-taken. Bronnen kunnen optioneel worden gespecificeerd. Als het aantal exemplaren niet is gespecificeerd, wordt het standaard ingesteld op basis van de max_concurrent_trials- en max_nodes-parameters. Als u een AutoML beeldclassificatie- of NLP-taak indient zonder een exemplaartype op te geven, wordt de grootte van de GPU-VM automatisch geselecteerd. U kunt AutoML-taken verzenden met behulp van CLIs, de Python SDK of studio.

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

$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

Pijplijntaak

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

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

Serverloze pijplijntaken configureren met door de gebruiker toegewezen beheerde identiteit

Wanneer u serverloze berekeningen in pijplijntaken gebruikt, wordt u aangeraden de gebruikersidentiteit in te stellen op het niveau van de afzonderlijke stap die wordt uitgevoerd op een berekening, in plaats van op het niveau van de hoofdpijplijn. (Hoewel de identiteitsinstelling wordt ondersteund op zowel hoofdpijplijn- als stapniveaus, heeft de instelling op stapniveau voorrang als beide zijn ingesteld. Voor pijplijnen met pijplijnonderdelen moet de identiteit echter worden ingesteld op afzonderlijke stappen die worden uitgevoerd. Identiteit die is ingesteld op het niveau van de hoofdpijplijn of pijplijnonderdeel, werkt niet. Daarom raden we u aan identiteit in te stellen op het niveau van de afzonderlijke stap, omwille van de eenvoud.)

def my_pipeline():
    train_job = train_component(
        training_data=Input(type="uri_folder", path="./data")
    )
    # Set managed identity for the job
    train_job.identity = {"type": "managed"}
    return {"train_output": train_job.outputs}

pipeline_job = my_pipeline()
# Configure the pipeline to use serverless compute.
pipeline_job.settings.default_compute = "serverless"

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline
description: E2E dummy train-score-eval pipeline with registered components
settings:
    default_compute: azureml:serverless
jobs:
 train_job:
   type: command
   component: azureml:my_train@latest
inputs:
   training_data: 
     type: uri_folder 
      path: ./data   
 identity:
   type: managed

Verwante inhoud

Bekijk meer voorbeelden van training met serverloze compute:

• Kijk eerst naar Azure Machine Learning
• Een model trainen