Partager via

Formation de modèle sur le calcul serverless

APPLIES TO :Extension Azure ML CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (préversion)

Vous n’avez pas besoin de créer et de gérer le calcul pour entraîner votre modèle de manière évolutive. Vous pouvez à la place soumettre votre travail à un type cible de calcul appelé calcul sans serveur. Le calcul serverless est le moyen le plus simple d’exécuter des travaux de formation sur Azure Machine Learning. Le calcul serverless est un calcul à la requête entièrement géré. Azure Machine Learning crée, met à l’échelle et gère le calcul pour vous. Lorsque vous utilisez le calcul serverless pour entraîner des modèles, vous pouvez vous concentrer sur la création de modèles Machine Learning et ne pas avoir à en savoir plus sur l’infrastructure de calcul ou la configuration.

Vous pouvez spécifier les ressources dont le travail a besoin. Azure Machine Learning gère l’infrastructure de calcul et fournit une isolation réseau managée, ce qui vous permet de réduire la charge.

Les entreprises peuvent également réduire les coûts en spécifiant des ressources optimales pour chaque travail. Les administrateurs informatiques peuvent toujours appliquer le contrôle en spécifiant le quota principal aux niveaux de l’abonnement et de l’espace de travail et en appliquant des stratégies Azure.

Vous pouvez utiliser le calcul serverless pour affiner les modèles dans le catalogue de modèles. Vous pouvez l’utiliser pour exécuter tous les types de travaux à l’aide d’Azure Machine Learning Studio, du Kit de développement logiciel (SDK) Python et d’Azure CLI. Vous pouvez également utiliser le calcul serverless pour créer des images d’environnement et pour des scénarios de tableau de bord IA responsables. Les travaux serverless consomment le même quota que le calcul Azure Machine Learning. Vous pouvez choisir des machines virtuelles de niveau standard (dédiées) ou spot (basse priorité). L’identité managée et l’identité utilisateur sont prises en charge pour les travaux serverless. Le modèle de facturation est identique au modèle de calcul Azure Machine Learning.

Avantages du calcul serverless

  • Azure Machine Learning gère la création, la configuration, la mise à l’échelle, la suppression et la mise à jour corrective de l’infrastructure de calcul pour réduire la surcharge de gestion.
  • Vous n’avez pas besoin d’en savoir plus sur le calcul, les différents types de calcul ou les propriétés associées.
  • Vous n’avez pas besoin de créer plusieurs fois des clusters pour chaque taille de machine virtuelle dont vous avez besoin, en utilisant les mêmes paramètres et en répliquant pour chaque espace de travail.
  • Vous pouvez optimiser les coûts en spécifiant les ressources exactes dont chaque travail a besoin au moment de l’exécution pour le type d’instance (taille de machine virtuelle) et le nombre d’instances. Vous pouvez également surveiller les métriques d’utilisation du travail pour optimiser les ressources dont un travail a besoin.
  • Moins d’étapes sont nécessaires pour exécuter un travail.
  • Pour simplifier davantage l’envoi des travaux, vous pouvez ignorer les ressources. Azure Machine Learning choisit par défaut le nombre d’instances et choisit un type d’instance en tenant compte de facteurs tels que le quota, le coût, les performances et la taille du disque.
  • Dans certains scénarios, les temps d’attente avant le début de l’exécution des travaux sont réduits.
  • L’identité utilisateur et l’identité gérée assignée par l'utilisateur de l'espace de travail sont prises en charge pour la soumission de tâches.
  • Avec l’isolation de réseau gérée, vous pouvez simplifier, puis automatiser votre configuration d’isolement réseau. Les réseaux virtuels clients sont également pris en charge.
  • Le contrôle administratif est disponible via des stratégies de quota et Azure.

Comment utiliser le calcul serverless

  • Lorsque vous créez votre propre cluster de calcul, vous utilisez son nom dans la tâche de commande. Par exemple : compute="cpu-cluster". Avec serverless, vous pouvez ignorer la création d’un cluster de calcul et omettre le compute paramètre pour utiliser plutôt le calcul serverless. Quand compute n’est pas spécifié pour un travail, le travail s’exécute sur le calcul serverless. Omettez le nom de calcul dans vos travaux du Kit de développement logiciel (SDK) Azure CLI ou Python pour utiliser le calcul serverless dans les types de travaux suivants, et fournissez éventuellement les ressources dont le travail a besoin pour le nombre d’instances et le type d’instance :

    • Travaux de commande, y compris les travaux interactifs et l’entraînement distribué
    • Travaux AutoML
    • Travaux de balayage
    • Travaux parallèles

  • Pour les travaux de pipeline via Azure CLI, utilisez-le default_compute: azureml:serverless pour le calcul par défaut au niveau du pipeline. Pour les travaux de pipeline via le Kit de développement logiciel (SDK) Python, utilisez default_compute="serverless". Pour obtenir un exemple, consultez Travail de pipeline.

  • Lorsque vous envoyez un travail de formation dans Studio, sélectionnez Serverless comme type de calcul.

  • Lorsque vous utilisez le concepteur Azure Machine Learning, sélectionnez Serverless comme calcul par défaut.

Considérations relatives aux performances

Le calcul serverless peut augmenter la vitesse de votre entraînement de la manière suivante :

Évitez les échecs de quota insuffisants. Lorsque vous créez votre propre cluster de calcul, vous êtes responsable de la détermination de la taille et du nombre de nœuds de la machine virtuelle. Lorsque votre travail s’exécute, si vous n’avez pas suffisamment de quota pour le cluster, le travail échoue. Le calcul serverless utilise des informations sur votre quota pour sélectionner une taille VM appropriée par défaut.

Optimisation du scale-down. Lorsqu’un cluster de calcul réduit sa taille, un nouveau travail doit attendre que le cluster réduise d'abord sa taille avant d'augmenter à nouveau pour permettre l'exécution du travail. Avec le calcul serverless, vous n’avez pas besoin d’attendre un scale-down. Votre travail peut commencer à s’exécuter sur un autre cluster/nœud (en supposant que vous disposez d’un quota).

Optimisation occupée par le cluster. Lorsqu’un travail s’exécute sur un cluster de calcul et qu’un autre travail est envoyé, votre travail est mis en file d’attente derrière le travail en cours d’exécution. Avec le calcul serverless, votre travail peut commencer à s’exécuter sur un autre nœud/cluster (en supposant que vous disposez d’un quota).

Quota

Lorsque vous envoyez un travail, vous avez toujours besoin d’un quota de calcul Azure Machine Learning suffisant pour continuer (quota au niveau de l’espace de travail et au niveau de l’abonnement). La taille VM par défaut des travaux serverless est sélectionnée en fonction de ce quota. Si vous spécifiez votre propre taille/famille VM :

  • Si vous disposez d’un quota pour votre taille/famille de machines virtuelles, mais que vous ne disposez pas d’un quota suffisant pour le nombre d’instances, une erreur s’affiche. L’erreur vous recommande de réduire le nombre d’instances à un nombre valide en fonction de votre limite de quota, de demander une augmentation de quota pour la famille de machines virtuelles ou de modifier la taille de la machine virtuelle.
  • Si votre quota est insuffisant pour la taille VM spécifiée, vous voyez une erreur. L’erreur vous recommande de sélectionner une taille de machine virtuelle différente pour laquelle vous disposez d’un quota ou d’un quota de demandes pour la famille de machines virtuelles.
  • Si vous disposez d’un quota suffisant pour une famille de machines virtuelles pour exécuter le travail serverless, mais que d’autres travaux utilisent le quota, vous recevez un message indiquant que votre travail doit attendre dans une file d’attente jusqu’à ce que le quota soit disponible.

Lorsque vous affichez votre utilisation et vos quotas dans le portail Azure, vous voyez le nom Serverless pour tous les quotas consommés par les travaux serverless.

Prise en charge des identités et transmission des informations d'identification

  • Transfert d'identifiants utilisateur : le calcul sans serveur prend entièrement en charge le transfert d'identifiants utilisateur. Le jeton utilisateur de l’utilisateur qui envoie le travail est utilisé pour l’accès au stockage. Ces informations d’identification proviennent de Microsoft Entra ID.

    Le calcul sans serveur ne prend pas en charge l'identité attribuée par le système.

    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)

  • Identité managée affectée par l’utilisateur : lorsque vous avez configuré un espace de travail avec une identité managée affectée par l’utilisateur, vous pouvez utiliser cette identité avec le travail serverless pour l’accès au stockage. Pour plus d’informations sur l’accès aux secrets, consultez Utiliser les secrets d’informations d’identification d’authentification dans les travaux Azure Machine Learning.

  1. Vérifiez la configuration de l’identité de votre espace de travail.

    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)

    Recherchez l'identité attribuée par l'utilisateur dans la sortie. S’il est manquant, créez un espace de travail avec une identité managée affectée par l’utilisateur en suivant les instructions de configuration de l’authentification entre Azure Machine Learning et d’autres services.

  2. Utilisez l'identité managée attribuée à l'utilisateur dans votre tâche.

    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)

Configurer les propriétés des travaux de commande

Si aucune cible de calcul n’est spécifiée pour les travaux de commande, de balayage et les travaux AutoML, le calcul est défini par défaut sur le calcul sans serveur. Voici un exemple :

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)

Le calcul est serverless par défaut avec :

  • Un nœud unique, pour ce travail. Le nombre par défaut de nœuds est basé sur le type de travail. Consultez les sections suivantes pour d’autres types de travail.
  • Une machine virtuelle d’UC. La machine virtuelle est déterminée en fonction du quota, des performances, du coût et de la taille du disque.
  • Machines virtuelles dédiées.
  • Emplacement de l’espace de travail.

Vous pouvez remplacer ces valeurs par défaut. Si vous voulez spécifier le type VM ou le nombre de nœuds pour le calcul serverless, ajoutez des resources à votre travail :

  • Permet instance_type de choisir une machine virtuelle spécifique. Utilisez ce paramètre si vous souhaitez une taille de machine virtuelle processeur ou GPU spécifique

  • Permet instance_count de spécifier le nombre de nœuds.

    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)

  • Pour modifier le niveau de travail, utilisez cette option queue_settings pour choisir entre les machines virtuelles dédiées (job_tier: Standard) et les machines virtuelles de faible priorité (job_tier: Spot).

    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)

Exemple pour tous les champs avec des travaux de commande

Voici un exemple qui montre tous les champs spécifiés, y compris l’identité que le travail doit utiliser. Vous n’avez pas besoin de spécifier les paramètres de réseau virtuel, car l’isolation réseau managée au niveau de l’espace de travail est automatiquement utilisée.

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)

Voici deux autres exemples d’utilisation du calcul serverless pour l’entraînement :

Travail AutoML

Vous n’avez pas besoin de spécifier le calcul pour les travaux AutoML. Les ressources peuvent éventuellement être spécifiées. Si aucun nombre d’instances n’est spécifié, il est défini par défaut en fonction des paramètres max_concurrent_trials et max_nodes. Si vous soumettez une classification d’images AutoML ou NLP tâche sans spécifier de type d’instance, la taille de machine virtuelle GPU est automatiquement sélectionnée. Vous pouvez envoyer des travaux AutoML à l’aide des CLIs, du Kit de développement logiciel (SDK) Python ou de Studio.

Si vous voulez spécifier le type ou le nombre d’instances, utilisez la classe ResourceConfiguration.

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

Travail de pipeline

Pour un travail de pipeline, spécifiez "serverless" comme type de calcul par défaut pour utiliser le calcul serverless.

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

Vous pouvez également définir le calcul serverless comme calcul par défaut dans le Concepteur.

Configurer des tâches de pipeline serverless avec une identité managée assignée par l'utilisateur

Lorsque vous utilisez des ressources de calcul serverless dans les travaux de pipeline, nous vous recommandons de définir l’identité de l’utilisateur au niveau de l’étape individuelle qui sera exécutée sur une ressource de calcul, plutôt qu’au niveau racine du pipeline. (Bien que le paramètre d’identité soit pris en charge à la fois au niveau du pipeline racine et de l’étape, le paramètre au niveau de l’étape est prioritaire si les deux sont définis. Toutefois, pour les pipelines contenant des composants de pipeline, l’identité doit être définie sur des étapes individuelles qui seront exécutées. L’identité définie au niveau du pipeline racine ou du composant de pipeline ne fonctionne pas. Par conséquent, nous vous suggérons de définir l’identité au niveau de l’étape individuelle pour la simplicité.)

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"

Contenu connexe

Explorez d'autres exemples de formation avec le calcul sans serveur :

  • Last updated on