Entrenamiento de modelos en proceso sin servidor

Artículo
11/16/2023

SE APLICA A:Extensión ML de la CLI de Azure v2 (actual)SDK de Python azure-ai-ml v2 (actual)

Ya no es necesario crear y administrar procesos para entrenar el modelo de forma escalable. En su lugar, su trabajo puede enviarse a un nuevo tipo de destino de proceso, denominado proceso sin servidor. El proceso sin servidor es la manera más fácil de ejecutar trabajos de entrenamiento en Azure Machine Learning. El proceso sin servidor es un proceso totalmente administrado a petición. Azure Machine Learning crea, escala y administra el proceso automáticamente. Mediante el entrenamiento de modelos con proceso sin servidor, los profesionales del aprendizaje automático pueden centrarse en su experiencia en la creación de modelos de Machine Learning y no tienen que aprender sobre la infraestructura de proceso ni su configuración.

Los profesionales del aprendizaje automático pueden especificar los recursos que necesita el trabajo. Azure Machine Learning administra la infraestructura de proceso y proporciona aislamiento de red gestionada para reducir su sobrecarga de administración.

Las empresas también pueden reducir los costos especificando recursos óptimos para cada trabajo. Los administradores de TI todavía pueden aplicar el control especificando la cuota de núcleos en el nivel de suscripción y área de trabajo y aplicando directivas de Azure.

El proceso sin servidor se puede usar para ajustar modelos en el catálogo de modelos, como LLAMA 2. El proceso sin servidor se puede usar para ejecutar todos los tipos de trabajos desde Estudio de Azure Machine Learning, el SDK y la CLI. El proceso sin servidor también se puede usar para crear imágenes de entorno y para escenarios de panel de IA responsable. Los trabajos sin servidor consumen la misma cuota que la cuota de proceso de Azure Machine Learning. Puede elegir máquinas virtuales estándar (dedicadas) o de acceso puntual (prioridad baja). La identidad administrada y la identidad de usuario son compatibles con trabajos sin servidor. El modelo de facturación es el mismo que el proceso de Azure Machine Learning.

Ventajas del proceso sin servidor

Azure Machine Learning administra la creación, configuración, escalado, eliminación, aplicación de revisiones, infraestructura de proceso que reduce la sobrecarga de administración.
No es necesario aprender sobre procesos, varios tipos de proceso y propiedades relacionadas.
No es necesario crear repetidamente clústeres para cada tamaño de máquina virtual necesario, usar la misma configuración ni replicar para cada área de trabajo.
Puede optimizar los costos especificando los recursos exactos que necesita cada trabajo en tiempo de ejecución en términos de tipo de instancia (tamaño de máquina virtual) y número de instancias. Puede supervisar las métricas de uso del trabajo para optimizar los recursos que puede necesitar un trabajo.
Reducción de los pasos implicados para ejecutar un trabajo
Para simplificar aún más el envío de trabajos, puede omitir por completo los recursos. Azure Machine Learning tiene como valor predeterminado el número de instancias y elige un tipo de instancia (tamaño de máquina virtual) en función de factores como la cuota, el costo, el rendimiento y el tamaño del disco.
Menores tiempos de espera antes de que los trabajos comiencen a ejecutarse en algunos casos.
Se admiten la identidad del usuario y la identidad administrada asignada por el usuario del área de trabajo para el envío de trabajos.
Con el aislamiento de red gestionada, puede simplificar y automatizar la configuración de aislamiento de red. También se admite la red virtual del cliente
Control de administración mediante directivas de cuota y Azure

Uso del proceso sin servidor

Puede ajustar modelos de base como LLAMA 2 mediante cuadernos, como se muestra a continuación:
- Ajuste de LLAMA 2
- Ajuste de LLAMA 2 con varios nodos
Al crear su propio clúster de proceso, use su nombre en el trabajo de comandos, por ejemplo, compute="cpu-cluster". Con el proceso sin servidor, puede omitir la creación de un clúster de proceso y omitir el parámetro compute para usar el proceso sin servidor en su lugar. Cuando no se especifica el elemento compute para un trabajo, el trabajo se ejecuta en proceso sin servidor. Omita el nombre del proceso en los trabajos de la CLI o del SDK para usar el proceso sin servidor en los siguientes tipos de trabajo y, opcionalmente, proporcionar los recursos que necesitaría un trabajo en términos de número de instancias y tipo de instancia:
- Trabajos de comandos, incluidos trabajos interactivos y de entrenamiento distribuido
- Trabajos de AutoML
- Trabajos de barrido
- Trabajos paralelos
Para los trabajos de canalización mediante la CLI, use default_compute: azureml:serverless para el proceso predeterminado de nivel de canalización. Para los trabajos de canalizaciones mediante el SDK, use default_compute="serverless". Consulte Trabajo de canalización para ver un ejemplo.
Al enviar un trabajo de entrenamiento en Estudio (versión preliminar), seleccione Sin servidor como tipo de proceso.
Al usar el diseñador de Azure Machine Learning, seleccione Sin servidor como proceso predeterminado.
Puede usar el proceso sin servidor para el panel de inteligencia artificial responsable
- Escenario de clasificación de imágenes de AutoML con el panel RAI

Consideraciones de rendimiento

El proceso sin servidor puede ayudar a acelerar el entrenamiento de las siguientes maneras:

Cuota insuficiente: al crear su propio clúster de proceso, es responsable de averiguar el tamaño de máquina virtual y el número de nodos que se deben crear. Cuando se ejecuta el trabajo, si no tiene suficiente cuota para el clúster, se produce un error en el trabajo. El proceso sin servidor usa la información sobre la cuota para seleccionar de manera predeterminada un tamaño de máquina virtual adecuado.

Optimización de la reducción vertical: cuando se reduce verticalmente un clúster de proceso, un nuevo trabajo tiene que esperar a que se produzca la reducción vertical y, a continuación, escalar verticalmente antes de que se pueda ejecutar el trabajo. Con el proceso sin servidor, no es necesario esperar a la reducción vertical y el trabajo puede empezar a ejecutarse en otro clúster o nodo (suponiendo que tenga cuota).

Optimización del grado de ocupación del clúster: cuando se ejecuta un trabajo en un clúster de proceso y se envía otro trabajo, el trabajo se pone en cola detrás del trabajo que se está ejecutando actualmente. Con el proceso sin servidor, obtendrá otro nodo u otro clúster para empezar a ejecutar el trabajo (suponiendo que tenga cuota).

Quota

Al enviar el trabajo, todavía necesita suficiente cuota de proceso de Azure Machine Learning para continuar (cuota de nivel de área de trabajo y de suscripción). El tamaño de máquina virtual predeterminado para los trabajos sin servidor se selecciona en función de esta cuota. Si especifica su propio tamaño o familia de máquina virtual:

Si tiene algo de cuota para el tamaño o la familia de máquina virtual, pero no la cuota suficiente para el número de instancias, recibirá un error. El error recomienda reducir el número de instancias hasta un número válido en función del límite de cuota o solicitar un aumento de cuota para esta familia de máquinas virtuales o cambiar el tamaño de máquina virtual.
Si no tiene cuota para el tamaño de máquina virtual especificado, recibirá un error. El error recomienda seleccionar otro tamaño de máquina virtual para el que tenga cuota o solicitar cuota para esta familia de máquinas virtuales.
Si dispone de cuota suficiente para que la familia de máquinas virtuales ejecute el trabajo sin servidor, pero otros trabajos están usando la cuota, recibirá un mensaje indicándole que su trabajo debe esperar en una cola hasta que la cuota esté disponible.

Al ver el uso y la cuota en Azure Portal, aparecerá el nombre "Sin servidor" para ver toda la cuota consumida por los trabajos sin servidor.

Compatibilidad con identidades y tránsito de credenciales

Tránsito de credenciales de usuario: el proceso sin servidor admite totalmente el paso de credenciales de usuario. El token de usuario del usuario que envía el trabajo se usa para el acceso al almacenamiento. Estas credenciales proceden de Microsoft Entra ID.

SDK de Python
CLI de Azure

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)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: user_identity

Identidad administrada asignada por el usuario: cuando tiene un área de trabajo configurada con identidad administrada asignada por el usuario, puede usar esa identidad con el trabajo sin servidor para el acceso al almacenamiento.

SDK de Python
CLI de Azure

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)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@latest
identity:
  type: managed

Para obtener información sobre cómo adjuntar identidad administrada asignada por el usuario, consulte Adjuntar identidad administrada asignada por el usuario.

Configuración de propiedades para trabajos de comandos

Si no se especifica ningún destino de proceso para los trabajos de comandos, barrido y AutoML, el proceso tiene como valor predeterminado proceso sin servidor. Por ejemplo, para este trabajo de comandos:

SDK de Python
CLI de Azure

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)

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

El valor predeterminado de proceso es proceso sin servidor con:

Un solo nodo para este trabajo. El número predeterminado de nodos se basa en el tipo de trabajo. Consulte las secciones siguientes para otros tipos de trabajo.
Máquina virtual de CPU, determinada en función de la cuota, el rendimiento, el costo y el tamaño del disco.
Máquinas virtuales dedicadas
Ubicación del área de trabajo

Puede invalidar estos valores predeterminados. Si desea especificar el tipo de máquina virtual o el número de nodos para el proceso sin servidor, agregue resources al trabajo:

instance_type para elegir una máquina virtual específica. Use este parámetro si desea un tamaño específico de máquina virtual de CPU/GPU.

instance_count para especificar el número de nodos.

SDK de Python
CLI de Azure

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)

$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

Para cambiar el nivel del trabajo, use queue_settings para elegir entre máquinas virtuales dedicadas (job_tier: Standard) y de prioridad baja(jobtier: Spot).

SDK de Python
CLI de Azure

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)

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

Ejemplo de todos los campos con trabajos de comandos

Este es un ejemplo de todos los campos especificados, incluida la identidad que debe usar el trabajo. No es necesario especificar la configuración de red virtual, ya que se usará automáticamente aislamiento de red gestionada de nivel de área de trabajo.

SDK de Python
CLI de Azure

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)

$schema: https://azuremlschemas.azureedge.net/latest/commandJob.schema.json
command: echo "hello world"
environment:
  image: azureml:AzureML-sklearn-1.0-ubuntu20.04-py38-cpu@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

Puede ver más ejemplos de entrenamiento con proceso sin servidor en:

Inicio rápido
Train Model (entrenar modelo)

Trabajo de AutoML

No es necesario especificar el proceso para los trabajos de AutoML. Opcionalmente, se pueden especificar recursos. Si no se especifica el número de instancias, el valor predeterminado se basa en los parámetros max_concurrent_trials y max_nodes. Si envía una clasificación de imágenes de AutoML o una tarea de NLP sin tipo de instancia, se selecciona automáticamente el tamaño de máquina virtual de la GPU. Es posible enviar el trabajo de AutoML mediante la CLI, el SDK o Estudio. Para enviar trabajos de AutoML con proceso sin servidor en Studio, habilite primero la característica de envío de un trabajo de entrenamiento en Studio (versión preliminar) en el panel de vista previa.

SDK de Python
CLI de Azure

Si desea especificar el tipo o el número de instancias, use la clase 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)

Si desea especificar el tipo o el número de instancias, agregue una sección resources.

$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

Para un trabajo de canalización, especifique "serverless" como el tipo de proceso predeterminado para usar proceso sin servidor.

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

Para un trabajo de canalización, especifique azureml:serverless como el tipo de proceso predeterminado para usar proceso sin servidor.

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

También puede establecer el proceso sin servidor como proceso predeterminado en el Diseñador.

Pasos siguientes