Compartir a través de

Entrenamiento de modelos en proceso sin servidor

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

No es necesario crear y administrar recursos de computación para entrenar el modelo de forma escalable. En su lugar, puede enviar el trabajo a un 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 y a petición. Azure Machine Learning crea, escala y administra el proceso automáticamente. Cuando se usa el proceso sin servidor para entrenar modelos, puede centrarse en la creación de modelos de aprendizaje automático y no es necesario obtener información sobre la infraestructura de proceso ni la configuración.

Puede especificar los recursos que necesita el trabajo. Azure Machine Learning administra la infraestructura de proceso y ofrece aislamiento de red gestionado, reduciendo así la carga para ti.

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úcleo en los niveles de suscripción y área de trabajo y aplicando directivas de Azure.

Puede usar el proceso sin servidor para ajustar los modelos en el catálogo de modelos. Puede usarlo para ejecutar todos los tipos de trabajos mediante Azure Machine Learning Studio, el SDK de Python y la CLI de Azure. También puede utilizar la computación sin servidor para crear imágenes de entorno y escenarios de panel de inteligencia artificial 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 modelo para Azure Machine Learning compute.

Ventajas del proceso sin servidor

  • Azure Machine Learning administra la creación, configuración, escalado, eliminación y aplicación de revisiones de la infraestructura de proceso para reducir la sobrecarga de administración.
  • No necesitas obtener información sobre computación, los distintos tipos de computación ni las propiedades relacionadas.
  • No es necesario crear clústeres repetidamente para cada tamaño de máquina virtual que necesite, con la misma configuración y la replicación para cada área de trabajo.
  • Puede optimizar los costos especificando los recursos exactos que cada trabajo necesita en tiempo de ejecución para el tipo de instancia (tamaño de máquina virtual) y el recuento de instancias. También puede supervisar las métricas de uso del trabajo para optimizar los recursos que necesita un trabajo.
  • Se requieren menos pasos para ejecutar un trabajo.
  • Para simplificar aún más el envío de trabajos, puede omitir por completo los recursos. Azure Machine Learning toma como valor predeterminado el recuento de instancias y elige un tipo de instancia teniendo en cuenta factores como cuota, costo, rendimiento y tamaño de disco.
  • En algunos escenarios, se reducen los tiempos de espera antes de que los trabajos empiecen a ejecutarse.
  • La identidad de usuario y la identidad administrada asignada a espacio de trabajo por el usuario se admiten 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 admiten las redes virtuales del cliente.
  • El control administrativo está disponible a través de cuotas y directivas de Azure.

Uso del proceso sin servidor

  • Al crear su propio clúster de cómputo, utilice su nombre en el trabajo de comando. Por ejemplo: compute="cpu-cluster". Sin servidor, puede prescindir de la creación de un clúster de cómputo y omitir el parámetro compute para usar cómputo sin servidor. Cuando no se especifica el elemento compute para un trabajo, el trabajo se ejecuta en proceso sin servidor. Omita el nombre de proceso en los trabajos de la CLI de Azure o del SDK de Python para usar el proceso sin servidor en los siguientes tipos de trabajo y, opcionalmente, proporcione recursos que el trabajo necesita para el recuento de instancias y el 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 a través de la CLI de Azure, use default_compute: azureml:serverless para el cálculo predeterminado a nivel de canalización. Para los trabajos de canalización mediante el SDK de Python, use default_compute="serverless". Consulte Trabajo de canalización para ver un ejemplo.

  • Al enviar un trabajo de entrenamiento en Studio, seleccione Sin servidor como tipo de proceso.

  • Al usar el diseñador de Azure Machine Learning, seleccione Sin servidor como proceso predeterminado.

Consideraciones de rendimiento

La computación sin servidor puede aumentar la velocidad de tu entrenamiento de las siguientes maneras:

Evite errores de cuota insuficientes. Al crear su propio clúster de proceso, es responsable de determinar el tamaño de máquina virtual y el número de nodos. 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 reducción vertical. Cuando se reduce un clúster de proceso, un nuevo trabajo debe esperar a que el clúster se reduzca y luego escale antes de que el trabajo pueda ejecutarse. Con la computación sin servidor, no es necesario esperar a la reducción de la escala. El trabajo puede empezar a ejecutarse en otro clúster o nodo (suponiendo que tenga cuota).

Optimización ocupada por clústeres. Cuando un trabajo se está ejecutando en un clúster de computación y se envía otro trabajo, tu trabajo se coloca en cola detrás del trabajo que se está ejecutando actualmente. Con el proceso sin servidor, el trabajo puede empezar a ejecutarse en otro nodo o clúster (suponiendo que tenga cuota).

Quota

Al enviar un trabajo, todavía necesita la suficiente cuota de proceso de Azure Machine Learning para continuar (cuota a nivel de área de trabajo y a nivel 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 alguna cuota para el tamaño o la familia de la máquina virtual, pero no la cuota suficiente para el número de instancias, verá un error. El error recomienda reducir el número de instancias a un número válido en función del límite de cuota, solicitar un aumento de cuota para la familia de máquinas virtuales o cambiar el tamaño de la máquina virtual.
  • Si no tiene cuota para el tamaño de máquina virtual especificado, recibirá un error. El mensaje de error recomienda que seleccione un tamaño de VM diferente para el cual tiene cuota o que solicite cuota para la familia de VM.
  • Si tiene suficiente cuota para que una familia de VM ejecute el trabajo sin servidor, pero otros trabajos están usando la cuota, recibirá un mensaje que indica que su trabajo debe esperar en una cola hasta que la cuota esté disponible.

Al ver el uso y las cuotas en Azure Portal, verá el nombre Sin servidor para todas las cuotas consumidas por trabajos sin servidor.

Soporte de identidades y transferencia de credenciales

  • Acceso directo de credenciales de usuario: el proceso sin servidor es totalmente compatible con el acceso directo 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 del identificador de Microsoft Entra.

    El cómputo sin servidor no admite identidades asignadas por el sistema.

    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)

  • 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. Para más información sobre el acceso a secretos, consulte Uso de secretos de credenciales de autenticación en trabajos de Azure Machine Learning.

  1. Compruebe la configuración de identidad del área de trabajo.

    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)

    Busque la identidad asignada por el usuario en la salida. Si no está presente, cree un área de trabajo con una identidad administrada asignada por el usuario siguiendo las instrucciones en Configurar la autenticación entre Azure Machine Learning y otros servicios.

  2. Utiliza la identidad administrada asignada por el usuario en tu tarea.

    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)

Configuración de propiedades para trabajos de comandos

Si no se especifica ningún objetivo de cómputo para los trabajos de comando, barrido y AutoML, el cómputo predeterminado es cómputo sin servidor. Este es un ejemplo:

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)

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.
  • Una máquina virtual de CPU. La máquina virtual se determina 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:

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

  • Use instance_count para especificar el número de nodos.

    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)

  • Para cambiar el nivel de trabajo, use queue_settings para elegir entre máquinas virtuales dedicadas (job_tier: Standard) y máquinas virtuales de prioridad baja (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)

Ejemplo de todos los campos con trabajos de comandos

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

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)

Estos son dos ejemplos más de uso del proceso sin servidor para el entrenamiento:

Trabajo de AutoML

No es necesario especificar recursos de computación para los trabajos de AutoML. Opcionalmente, se pueden especificar recursos. Si no se especifica un recuento de instancias, se determina por defecto en función de los parámetros max_concurrent_trials y max_nodes. Si envía una clasificación de imágenes AutoML o una tarea NLP sin especificar un tipo de instancia, el tamaño de la máquina virtual de GPU se selecciona automáticamente. Puede enviar trabajos de AutoML mediante CLIs, el SDK de Python o Studio.

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)

Trabajo de canalización

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"

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

Configuración de tareas de canalización sin servidor con identidad administrada asignada por el usuario

Al utilizar cómputo sin servidor en los trabajos de canalización, recomendamos establecer la identidad de usuario al nivel de cada paso individual que se ejecutará en un cómputo, en lugar de hacerlo en el nivel raíz de la canalización. (Aunque la configuración de identidad se admite tanto en la canalización raíz como en los niveles de paso, la configuración de nivel de paso tiene prioridad si se establecen ambas. Sin embargo, para las canalizaciones que contienen componentes de canalización, la identidad debe establecerse en los pasos individuales que se ejecutarán. La identidad establecida en el nivel de componente de canalización raíz o canalización no funcionará. Por lo tanto, se recomienda establecer la identidad en el nivel de paso individual por motivos de simplicidad).

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"

Contenido relacionado

Vea más ejemplos de entrenamiento con proceso sin servidor:

  • Last updated on