Tutorial: Azure Machine Learning en un día

SE APLICA A: SDK de Python azure-ai-ml v2 (actual)

Obtenga información sobre cómo un científico de datos usa Azure Machine Learning (Azure ML) para entrenar un modelo y, a continuación, usa el modelo para la predicción. Este tutorial le ayudará a familiarizarse con los conceptos básicos de Azure ML y su uso más común.

Aprenderá a enviar un trabajo de comando para ejecutar el script de entrenamiento en un recurso de proceso especificado, configurado con el entorno de trabajo necesario para ejecutar el script.

El script de entrenamiento controla la preparación de datos y, a continuación, entrena y registra un modelo. Una vez que tenga el modelo, lo implementará como un punto de conexión y, a continuación, llamará al punto de conexión para la inferencia.

Los pasos que realizará son:

  • Conectarse al área de trabajo de Azure ML
  • Creación del recurso de proceso y el entorno de trabajo
  • Crear su script de aprendizaje
  • Cree y ejecute el trabajo de comando para ejecutar el script de entrenamiento en el recurso de proceso, configurado con el entorno de trabajo adecuado.
  • Visualización de la salida del script de entrenamiento
  • Implementar el modelo recién entrenado como un punto de conexión
  • Llamar al punto de conexión de Azure ML para la inferencia

Requisitos previos

Ejecución del cuaderno

  1. En la barra superior, seleccione la instancia de proceso que creó durante el Inicio rápido: Introducción a Azure Machine Learning para ejecutar el cuaderno.

  2. Asegúrese de que el kernel, que se encuentra en la parte superior derecha, es Python 3.10 - SDK v2. Si no es así, use la lista desplegable para seleccionar este kernel.

Captura de pantalla: Establecimiento del kernel.

Importante

El resto de este tutorial contiene celdas del cuaderno del tutorial. Cópielas o péguelas en el nuevo cuaderno o cambie al cuaderno ahora si lo ha clonado.

Para ejecutar una sola celda de código en un cuaderno, haga clic en la celda y presione Mayús + Entrar. O bien, ejecute el cuaderno completo, para lo que debe elegir Ejecutar todo en la barra de herramientas superior.

Conexión a un área de trabajo

Antes de profundizar en el código, deberá conectarse al área de trabajo de Azure ML. El área de trabajo es el recurso de nivel superior para Azure Machine Learning, que proporciona un lugar centralizado para trabajar con todos los artefactos que crea al usar Azure Machine Learning.

Usaremos DefaultAzureCredential para obtener acceso al área de trabajo. DefaultAzureCredential se usa para controlar la mayoría de los escenarios de autenticación del SDK de Azure.

# Handle to the workspace
from azure.ai.ml import MLClient

# Authentication package
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

En la celda siguiente, escriba el identificador de suscripción, el nombre del grupo de recursos y el nombre del área de trabajo. Para establecer estos valores:

  1. En la barra de herramientas de Estudio de Azure Machine Learning superior derecha, seleccione el nombre del área de trabajo.
  2. Copie el valor del área de trabajo, el grupo de recursos y el identificador de suscripción en el código.
  3. Tendrá que copiar un valor, cerrar el área y pegar y, a continuación, volver para el siguiente.

Captura de pantalla: busque las credenciales del código en la esquina superior derecha de la barra de herramientas.

# Get a handle to the workspace
ml_client = MLClient(
    credential=credential,
    subscription_id="<SUBSCRIPTION_ID>",
    resource_group_name="<RESOURCE_GROUP>",
    workspace_name="<AML_WORKSPACE_NAME>",
)

El resultado es un controlador para el área de trabajo que usará para administrar otros recursos y trabajos.

Importante

La creación de MLClient no se conectará al área de trabajo. La inicialización del cliente es diferida, esperará hasta la primera vez que necesite realizar una llamada (en el cuaderno siguiente, que se producirá durante la creación del proceso).

Creación de un recurso de proceso para ejecutar el trabajo

Necesitará un recurso de proceso para ejecutar un trabajo. Se puede tratar de máquinas de un solo nodo o de varios nodos con sistema operativo Linux o Windows, o un tejido de proceso específico, como Spark.

Aprovisionará un clúster de proceso de Linux. Consulte la lista completa sobre los tamaños y precios de las VM.

Para este ejemplo solo necesita un clúster básico, por lo que usará un modelo Standard_DS3_v2 con 2 núcleos de vCPU, 7 GB de RAM y crearemos una instancia de Proceso de Azure ML.

from azure.ai.ml.entities import AmlCompute

# Name assigned to the compute cluster
cpu_compute_target = "cpu-cluster"

try:
    # let's see if the compute target already exists
    cpu_cluster = ml_client.compute.get(cpu_compute_target)
    print(
        f"You already have a cluster named {cpu_compute_target}, we'll reuse it as is."
    )

except Exception:
    print("Creating a new cpu compute target...")

    # Let's create the Azure ML compute object with the intended parameters
    cpu_cluster = AmlCompute(
        name=cpu_compute_target,
        # Azure ML Compute is the on-demand VM service
        type="amlcompute",
        # VM Family
        size="STANDARD_DS3_V2",
        # Minimum running nodes when there is no job running
        min_instances=0,
        # Nodes in cluster
        max_instances=4,
        # How many seconds will the node running after the job termination
        idle_time_before_scale_down=180,
        # Dedicated or LowPriority. The latter is cheaper but there is a chance of job termination
        tier="Dedicated",
    )
    print(
         f"AMLCompute with name {cpu_cluster.name} will be created, with compute size {cpu_cluster.size}"
          )
    # Now, we pass the object to MLClient's create_or_update method
    cpu_cluster = ml_client.compute.begin_create_or_update(cpu_cluster)

Creación de un entorno de trabajo

Para ejecutar el trabajo de AzureML en el recurso de proceso, necesitará un entorno. Un entorno enumera el Common Language Runtime de software y las bibliotecas que desea instalar en el proceso en el que va a entrenar. Es similar al entorno de Python en la máquina local.

AzureML proporciona muchos entornos seleccionados o listos, que son útiles para escenarios comunes de entrenamiento e inferencia. También puede crear sus propios entornos personalizados mediante una imagen de Docker o una configuración de Conda.

En este ejemplo, creará un entorno de Conda personalizado para los trabajos mediante un archivo yaml de Conda.

En primer lugar, cree un directorio en el que almacenar el archivo.

import os

dependencies_dir = "./dependencies"
os.makedirs(dependencies_dir, exist_ok=True)

Ahora, cree el archivo en el directorio de dependencias. En la celda siguiente se usa IPython Magic para escribir el archivo en el directorio que acaba de crear.

%%writefile {dependencies_dir}/conda.yml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=0.24.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - xlrd==2.0.1
    - mlflow== 1.26.1
    - azureml-mlflow==1.42.0
    - psutil>=5.8,<5.9
    - tqdm>=4.59,<4.60
    - ipykernel~=6.0
    - matplotlib

La especificación contiene algunos paquetes habituales que usará en el trabajo (numpy, pip).

Haga referencia a este archivo yaml para crear y registrar este entorno personalizado en el área de trabajo:

from azure.ai.ml.entities import Environment

custom_env_name = "aml-scikit-learn"

pipeline_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults pipeline",
    tags={"scikit-learn": "0.24.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yml"),
    image="mcr.microsoft.com/azureml/openmpi3.1.2-ubuntu18.04:latest",
)
pipeline_job_env = ml_client.environments.create_or_update(pipeline_job_env)

print(
    f"Environment with name {pipeline_job_env.name} is registered to workspace, the environment version is {pipeline_job_env.version}"
)

¿Qué es un trabajo de comando?

Creará un comando de trabajo de Azure ML para entrenar un modelo para la predicción predeterminada del crédito. El trabajo de comando se usa para ejecutar un script de entrenamiento en un entorno especificado en un recurso de proceso determinado. Ya ha creado el entorno y el recurso de proceso. A continuación, creará el script de entrenamiento.

El script de entrenamiento controla la preparación de datos, el entrenamiento y el registro del modelo entrenado. En este tutorial, creará un script de entrenamiento de Python.

Los trabajos de comando se pueden ejecutar desde la CLI, el SDK de Python o la interfaz de Studio. En este tutorial, usará el SDK de Python de Azure ML v2 para crear y ejecutar el trabajo de comando.

Después de ejecutar el trabajo de entrenamiento, implementará el modelo y, a continuación, lo usará para generar una predicción.

Creación del script de entrenamiento

Empecemos por crear el script de entrenamiento: el archivo de Python main.py.

En primer lugar, cree una carpeta de origen para el script:

import os

train_src_dir = "./src"
os.makedirs(train_src_dir, exist_ok=True)

Este script controla el preprocesamiento de los datos, dividiéndolo en datos de prueba y de entrenamiento. A continuación, consume estos datos para entrenar un modelo basado en árbol y devolver el modelo de salida.

MLFlow se usará para registrar los parámetros y las métricas durante la ejecución de la canalización.

En la celda siguiente se usa IPython Magic para escribir el script de entrenamiento en el directorio que acaba de crear.

%%writefile {train_src_dir}/main.py
import os
import argparse
import pandas as pd
import mlflow
import mlflow.sklearn
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

def main():
    """Main function of the script."""

    # input and output arguments
    parser = argparse.ArgumentParser()
    parser.add_argument("--data", type=str, help="path to input data")
    parser.add_argument("--test_train_ratio", type=float, required=False, default=0.25)
    parser.add_argument("--n_estimators", required=False, default=100, type=int)
    parser.add_argument("--learning_rate", required=False, default=0.1, type=float)
    parser.add_argument("--registered_model_name", type=str, help="model name")
    args = parser.parse_args()
   
    # Start Logging
    mlflow.start_run()

    # enable autologging
    mlflow.sklearn.autolog()

    ###################
    #<prepare the data>
    ###################
    print(" ".join(f"{k}={v}" for k, v in vars(args).items()))

    print("input data:", args.data)
    
    credit_df = pd.read_excel(args.data, header=1, index_col=0)

    mlflow.log_metric("num_samples", credit_df.shape[0])
    mlflow.log_metric("num_features", credit_df.shape[1] - 1)

    train_df, test_df = train_test_split(
        credit_df,
        test_size=args.test_train_ratio,
    )
    ####################
    #</prepare the data>
    ####################

    ##################
    #<train the model>
    ##################
    # Extracting the label column
    y_train = train_df.pop("default payment next month")

    # convert the dataframe values to array
    X_train = train_df.values

    # Extracting the label column
    y_test = test_df.pop("default payment next month")

    # convert the dataframe values to array
    X_test = test_df.values

    print(f"Training with data of shape {X_train.shape}")

    clf = GradientBoostingClassifier(
        n_estimators=args.n_estimators, learning_rate=args.learning_rate
    )
    clf.fit(X_train, y_train)

    y_pred = clf.predict(X_test)

    print(classification_report(y_test, y_pred))
    ###################
    #</train the model>
    ###################

    ##########################
    #<save and register model>
    ##########################
    # Registering the model to the workspace
    print("Registering the model via MLFlow")
    mlflow.sklearn.log_model(
        sk_model=clf,
        registered_model_name=args.registered_model_name,
        artifact_path=args.registered_model_name,
    )

    # Saving the model to a file
    mlflow.sklearn.save_model(
        sk_model=clf,
        path=os.path.join(args.registered_model_name, "trained_model"),
    )
    ###########################
    #</save and register model>
    ###########################
    
    # Stop Logging
    mlflow.end_run()

if __name__ == "__main__":
    main()

Como puede ver en este script, una vez entrenado el modelo, el archivo del modelo se guarda y registra en el área de trabajo. Ahora puede usar el modelo registrado en puntos de conexión de inferencia.

Configuración del comando

Ahora que tiene un script que puede realizar las tareas deseadas, usará el comando de uso general que puede ejecutar acciones de línea de comandos. Esta acción de línea de comandos puede llamar directamente a comandos del sistema o ejecutar un script.

Aquí, creará variables de entrada para especificar los datos de entrada, la relación de división, la velocidad de aprendizaje y el nombre del modelo registrado. El script de comando hará lo siguiente:

  • Usará el proceso creado anteriormente para ejecutar este comando.
  • Usará el entorno creado anteriormente (puede usar la notación @latest para indicar la versión más reciente del entorno cuando se ejecuta el comando).
  • Configure algunos metadatos como el nombre para mostrar, el nombre del experimento, etc. Un experimento es un contenedor para todas las iteraciones que se realizan en un proyecto determinado. Todos los trabajos enviados en el mismo nombre de experimento se enumerarían junto al otro en Estudio de Azure ML.
  • Configure la propia acción de la línea de comandos, python main.py en este caso. Se puede acceder a las entradas y salidas del comando a través de la notación ${{ ... }}.
from azure.ai.ml import command
from azure.ai.ml import Input

registered_model_name = "credit_defaults_model"

job = command(
    inputs=dict(
        data=Input(
            type="uri_file",
            path="https://archive.ics.uci.edu/ml/machine-learning-databases/00350/default%20of%20credit%20card%20clients.xls",
        ),
        test_train_ratio=0.2,
        learning_rate=0.25,
        registered_model_name=registered_model_name,
    ),
    code="./src/",  # location of source code
    command="python main.py --data ${{inputs.data}} --test_train_ratio ${{inputs.test_train_ratio}} --learning_rate ${{inputs.learning_rate}} --registered_model_name ${{inputs.registered_model_name}}",
    environment="aml-scikit-learn@latest",
    compute="cpu-cluster",
    experiment_name="train_model_credit_default_prediction",
    display_name="credit_default_prediction",
)

Enviar el archivo

Ahora es el momento de enviar el trabajo para que se ejecute en AzureML. Esta vez usará create_or_update en ml_client.jobs.

ml_client.create_or_update(job)

Visualización de la salida del trabajo y espera para que finalice el trabajo

Para ver el trabajo en AzureML Studio, seleccione el vínculo en la salida de la celda anterior.

La salida de este trabajo tendrá este aspecto en AzureML Studio. Explore las pestañas para obtener varios detalles, como métricas, salidas, etc. Una vez completado, el trabajo registrará un modelo en el área de trabajo como resultado del entrenamiento.

Captura de pantalla que muestra la introducción

Importante

Espere hasta que se complete el estado del trabajo antes de volver a este cuaderno para continuar. El trabajo tardará entre 2 y 3 minutos en ejecutarse. Puede tardar más (hasta 10 minutos) si el clúster de proceso se ha reducido verticalmente a cero nodos y el entorno personalizado sigue creando.

Implementación del modelo como un punto de conexión en línea

Ahora, implemente el modelo de Machine Learning como un servicio web en la nube de Azure, un online endpoint.

Para implementar un servicio de aprendizaje automático, normalmente necesitará lo siguiente:

  • Los recursos del modelo (archivo, metadatos) que desea implementar. Ya ha registrado estos recursos en el trabajo de entrenamiento.
  • Algún código que se ejecutará como servicio. El código ejecuta el modelo en una solicitud de entrada determinada. Este script de entrada recibe los datos enviados a un servicio web implementado y los pasa al modelo y, a continuación, devuelve la respuesta del modelo al cliente. El script es específico para su modelo. El script de entrada debe entender los datos que el modelo espera y devuelve. Con un modelo de MLFlow, como en este tutorial, este script se crea automáticamente. Aquí se pueden encontrar ejemplos de scripts de puntuación.

Creación de un punto de conexión en línea

Ahora que tiene un modelo registrado y un script de inferencia, es el momento de crear el punto de conexión en línea. El nombre del punto de conexión debe ser único en toda la región de Azure. En este tutorial, creará un nombre único mediante UUID.

import uuid

# Creating a unique name for the endpoint
online_endpoint_name = "credit-endpoint-" + str(uuid.uuid4())[:8]

Nota

La creación del punto de conexión tardará entre 6 y 8 minutos aproximadamente.

from azure.ai.ml.entities import (
    ManagedOnlineEndpoint,
    ManagedOnlineDeployment,
    Model,
    Environment,
)

# create an online endpoint
endpoint = ManagedOnlineEndpoint(
    name=online_endpoint_name,
    description="this is an online endpoint",
    auth_mode="key",
    tags={
        "training_dataset": "credit_defaults",
        "model_type": "sklearn.GradientBoostingClassifier",
    },
)

endpoint = ml_client.online_endpoints.begin_create_or_update(endpoint).result()

print(f"Endpoint {endpoint.name} provisioning state: {endpoint.provisioning_state}")

Una vez que haya creado un punto de conexión, puede recuperarlo como se indica a continuación:

endpoint = ml_client.online_endpoints.get(name=online_endpoint_name)

print(
    f'Endpoint "{endpoint.name}" with provisioning state "{endpoint.provisioning_state}" is retrieved'
)

Implementación del modelo en el punto de conexión

Una vez creado el punto de conexión, implemente el modelo con el script de entrada. Cada punto de conexión puede tener varias implementaciones. El tráfico directo a estas implementaciones se puede especificar mediante reglas. Aquí creará una única implementación que controla el 100 % del tráfico entrante. Hemos elegido un nombre de color para la implementación, por ejemplo, implementaciones azules, verdes y rojas, que es arbitrario.

Puede comprobar la página Modelos de Estudio de Azure ML para identificar la última versión del modelo registrado. Como alternativa, el código siguiente recuperará el número de la última versión para que lo use.

# Let's pick the latest version of the model
latest_model_version = max(
    [int(m.version) for m in ml_client.models.list(name=registered_model_name)]
)

Implemente la última versión del modelo.

Nota

Esta implementación tardará entre 6 y 8 minutos aproximadamente.

# picking the model to deploy. Here we use the latest version of our registered model
model = ml_client.models.get(name=registered_model_name, version=latest_model_version)


# create an online deployment.
blue_deployment = ManagedOnlineDeployment(
    name="blue",
    endpoint_name=online_endpoint_name,
    model=model,
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

blue_deployment = ml_client.begin_create_or_update(blue_deployment).result()

Prueba con una consulta de ejemplo

Ahora que el modelo está implementado en el punto de conexión, puede ejecutar la inferencia con él.

Cree un archivo de solicitud de ejemplo después del diseño esperado en el método de ejecución en el script de puntuación.

deploy_dir = "./deploy"
os.makedirs(deploy_dir, exist_ok=True)
%%writefile {deploy_dir}/sample-request.json
{
  "input_data": {
    "columns": [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],
    "index": [0, 1],
    "data": [
            [20000,2,2,1,24,2,2,-1,-1,-2,-2,3913,3102,689,0,0,0,0,689,0,0,0,0],
            [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 10, 9, 8]
        ]
  }
}
# test the blue deployment with some sample data
ml_client.online_endpoints.invoke(
    endpoint_name=online_endpoint_name,
    request_file="./deploy/sample-request.json",
    deployment_name="blue",
)

Limpieza de recursos

Si no va a usar el punto de conexión, elimínelo para dejar de usar el recurso. Asegúrese de que ninguna otra implementación use un punto de conexión antes de eliminarlo.

Nota

Este paso tardará entre 6 y 8 minutos aproximadamente.

ml_client.online_endpoints.begin_delete(name=online_endpoint_name)

Eliminar todo el contenido

Siga estos pasos para eliminar el área de trabajo de Azure Machine Learning y todos los recursos de proceso.

Importante

Los recursos que creó pueden usarse como requisitos previos para otros tutoriales y artículos de procedimientos de Azure Machine Learning.

Si no va a usar ninguno de los recursos que ha creado, elimínelos para no incurrir en cargos:

  1. En Azure Portal, seleccione Grupos de recursos a la izquierda del todo.

  2. En la lista, seleccione el grupo de recursos que creó.

  3. Seleccione Eliminar grupo de recursos.

    Captura de pantalla de las selecciones para eliminar un grupo de recursos en Azure Portal.

  4. Escriba el nombre del grupo de recursos. A continuación, seleccione Eliminar.

Pasos siguientes