Formation de modèle sur le calcul serverless

  • Article

S’APPLIQUE À :Extension Azure CLI v2 (actuelle)Kit de développement logiciel (SDK) Python azure-ai-ml v2 (version actuelle)

Vous n’avez plus besoin de créer, puis de gérer un calcul pour former votre modèle de manière évolutive. À la place, votre travail peut être envoyé à un nouveau type de cible de calcul, appelé calcul serverless. 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 demande et entièrement managé. Azure Machine Learning crée, met à l’échelle et gère le calcul pour vous. Grâce à l’entraînement de modèle avec le calcul serverless, les professionnels du machine learning peuvent s’en remettre à leur expertise en matière de création de modèles Machine Learning et n’ont pas besoin d’en savoir plus sur l’infrastructure de calcul ou sa configuration.

Les professionnels du machine learning peuvent spécifier les ressources dont le travail a besoin. Azure Machine Learning gère l’infrastructure de calcul et fournit un isolement réseau managé pour alléger vos tâches.

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 de cœurs au niveau de l’abonnement et de l’espace de travail, puis appliquer des stratégies Azure.

Le calcul serverless peut être utilisé pour affiner les modèles dans le catalogue de modèles, tels que LLAMA 2. Le calcul serverless peut être utilisé pour exécuter tous les types de travaux à partir d’Azure Machine Learning studio, du Kit de développement logiciel (SDK) et de l’interface CLI. Le calcul serverless peut également être utilisé 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 calcul Azure Machine Learning.

Avantages du calcul serverless

  • Azure Machine Learning gère la création, la configuration, la mise à l’échelle, la suppression, la mise à jour corrective et l’infrastructure de calcul, ce qui réduit ainsi les charges de gestion
  • Vous n’avez pas besoin d’avoir plus d’informations sur la calcul, les différents types de calcul et les propriétés associées.
  • Vous n’avez pas besoin de créer plusieurs clusters pour chaque taille VM nécessaire, en utilisant les mêmes paramètres et la réplication 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 en termes de type d’instance (taille VM) et de nombre d’instances. Vous pouvez monitorer les métriques d’utilisation du travail pour optimiser les ressources dont il a besoin.
  • Réduction des étapes à suivre pour exécuter un travail
  • Pour simplifier davantage l’envoi des travaux, vous pouvez ignorer les ressources. Azure Machine Learning utilise un nombre d’instances par défaut et choisit un type d’instance (taille VM) en fonction de facteurs comme le quota, le coût, les performances et la taille de disque.
  • Les temps d’attente sont réduits avant le début de l’exécution des travaux dans certains cas.
  • L’identité utilisateur et l’identité managée affectée par l’utilisateur de l’espace de travail sont prises en charge pour l’envoi de travaux.
  • Avec l’isolation de réseau gérée, vous pouvez simplifier, puis automatiser votre configuration d’isolement réseau. Le réseau virtuel client est également pris en charge
  • Contrôle administrateur via des quotas et des stratégies Azure

Comment utiliser le calcul serverless

  • Vous pouvez affiner les modèles de base tels que LLAMA 2 à l’aide de notebooks, comme indiqué ci-dessous :

  • Quand vous créez votre propre cluster de calcul, vous utilisez son nom dans le travail de commande, par exemple compute="cpu-cluster". Avec serverless, vous pouvez ignorer la création d’un cluster de calcul et omettre le paramètre compute pour utiliser le calcul serverless à la place. Quand compute n’est pas spécifié pour un travail, le travail s’exécute sur le calcul serverless. Omettez le nom du calcul dans vos travaux CLI ou SDK pour utiliser le calcul serverless dans les types de travail suivants, et fournissez éventuellement les ressources dont le travail a besoin en termes de nombre d’instances et de 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 l’interface CLI, utilisez default_compute: azureml:serverless pour le calcul par défaut au niveau du pipeline. Pour les travaux de pipelines via le SDK, utilisez default_compute="serverless". Pour obtenir un exemple, consultez Travail de pipeline.

  • Quand vous envoyez un travail d’entraînement dans Studio (préversion), sélectionnez Serverless comme type de calcul.

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

  • Vous pouvez utiliser le calcul serverless pour un tableau de bord IA responsable

Considérations relatives aux performances

Le calcul serverless peut vous aider à accélérer l’entraînement de la façon suivante :

Quota insuffisant : quand vous créez votre propre cluster de calcul, c’est à vous de déterminer la taille VM et le nombre de nœuds à créer. Quand votre travail s’exécute, si votre quota n’est pas suffisant 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 : quand un cluster de calcul effectue un scale-down, un nouveau travail doit attendre la fin du scale-down, puis le scale-up pour pouvoir s’exécuter. Avec le calcul serverless, vous n’avez pas besoin d’attendre la fin du scale-down, votre travail peut commencer à s’exécuter sur un autre cluster/nœud (si votre quota est suffisant).

Optimisation de l’activité du cluster : quand 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, vous obtenez un autre nœud/cluster pour commencer à exécuter le travail (si votre quota est suffisant).

Quota

Pour l’envoi du travail, vous avez toujours besoin d’un quota de calcul Azure Machine Learning suffisant (à la fois au niveau de l’espace de travail et 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 votre quota est suffisant pour la taille/famille VM, mais insuffisant pour le nombre d’instances, vous voyez une erreur. L’erreur recommande de réduire le nombre d’instances à un nombre valide en fonction de votre limite de quota ou de demander une augmentation de quota pour cette famille VM ou de modifier la taille VM
  • Si votre quota est insuffisant pour la taille VM spécifiée, vous voyez une erreur. L’erreur recommande de sélectionner une autre taille VM qui entre dans votre quota ou de demander du quota pour cette famille VM
  • Si vous avez un quota suffisant pour la famille VM, qui vous permet d’exécuter le travail serverless, mais qu’il est actuellement utilisé par d’autres travaux, vous recevez un message indiquant que votre travail doit attendre dans une file d’attente jusqu’à ce que le quota soit disponible

Quand vous consultez votre utilisation et votre quota dans le portail Azure, vous voyez le nom « Serverless » en face de tous les quotas consommés par des travaux serverless.

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

  • Transmission des informations d’identification de l’utilisateur : le calcul serverless prend entièrement en charge le passage des informations d’identification de l’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 votre Microsoft Entra ID.

    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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity=UserIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

  • Identité managée affectée par l’utilisateur : quand vous avez un espace de travail configuré avec une identité managée affectée par l’utilisateur, vous pouvez utiliser cette identité avec le travail serverless pour accéder au stockage.

    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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
        identity= ManagedIdentityConfiguration(),
)
# submit the command job
ml_client.create_or_update(job)

Pour plus d’informations sur l’attachement d’une identité managée affectée par l’utilisateur, consultez Attacher une identité managée affectée par l’utilisateur.

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 AutoML, le calcul est serverless par défaut. Par exemple, pour ce travail de commande :

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
)
# submit the command job
ml_client.create_or_update(job)

Le calcul est serverless par défaut avec :

  • Un seul nœud 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.
  • Machine virtuelle de processeur, déterminée en fonction du quota, des performances, du coût et de la taille de 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 :

  • instance_type pour choisir une machine virtuelle spécifique. Utilisez ce paramètre si vous voulez une taille VM de processeur/processeur graphique spécifique

  • instance_count pour 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 ResourceConfiguration 

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-sklearn-1.0-ubuntu20.04-py38-cpu@latest",
    resources = ResourceConfiguration(instance_type="Standard_NC24", instance_count=4)
)
# submit the command job
ml_client.create_or_update(job)

  • Pour changer le niveau de travail, utilisez queue_settings pour choisir des machines virtuelles dédiées (job_tier: Standard) ou basse priorité (jobtier: 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-sklearn-1.0-ubuntu20.04-py38-cpu@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 de 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 de réseau géré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-sklearn-1.0-ubuntu20.04-py38-cpu@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)

Consultez d’autres exemples d’entraînement avec le calcul serverless sur :-

Travail AutoML

Vous n’avez pas besoin de spécifier le calcul pour les travaux AutoML. Des ressources peuvent éventuellement être spécifiées. Si le nombre d’instances n’est pas spécifié, il est défini par défaut en fonction des paramètres max_concurrent_trials et max_nodes. Si vous envoyez une classification d’images AutoML ou une tâche NLP sans type d’instance, la taille de machine virtuelle GPU est automatiquement sélectionnée. Vous pouvez envoyer un travail AutoML à partir d’interfaces CLI, de SDK ou de Studio. Pour envoyer des travaux AutoML avec le calcul serverless dans studio, activez d’abord la fonctionnalité Envoyer un travail de formation dans studio (préversion) dans le volet d’aperçu.

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.

Étapes suivantes

Consultez d’autres exemples d’entraînement avec le calcul serverless sur :-