Tutorial: entrenamiento de un modelo en Azure Machine Learning

Artículo
10/20/2023

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

Aprenda cómo un científico de datos usa Azure Machine Learning para entrenar un modelo. En este ejemplo, usamos el conjunto de datos de tarjetas de crédito asociadas para mostrar cómo puede usar Azure Machine Learning para un problema de clasificación. El objetivo es predecir si un cliente tiene una alta probabilidad de impago de una tarjeta de crédito.

El script de entrenamiento controla la preparación de datos y, a continuación, entrena y registra un modelo. Este tutorial te lleva a través de los pasos para enviar un trabajo de entrenamiento basado en la nube (trabajo de comando). Si desea obtener más información sobre cómo cargar sus datos en Azure, consulte Tutorial: Cargar, acceder y explorar sus datos en Azure Machine Learning. Los pasos son:

Controle su área de trabajo de Azure Machine Learning
Creación del recurso de proceso y el entorno de trabajo
Crear su script de aprendizaje
Cree y ejecute su trabajo de comandos para ejecutar el script de entrenamiento en el recurso informático, configurado con el entorno de trabajo adecuado y la fuente de datos
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 Machine Learning para la inferencia

En este vídeo se muestra cómo empezar a trabajar en el estudio de Azure Machine Learning para que pueda seguir los pasos del tutorial. El vídeo muestra cómo crear un cuaderno, crear una instancia de proceso y clonar el cuaderno. Estos pasos también se describen en las secciones siguientes.

Requisitos previos

Para usar Azure Machine Learning, primero necesitará un área de trabajo. Si no tiene una, complete Crear recursos necesarios para empezar para crear un área de trabajo y obtener más información sobre su uso.
Inicie sesión en Studio y seleccione el área de trabajo si aún no está abierta.
Abra o cree una libreta en el área de trabajo:
- Cree un nuevo cuaderno, si desea copiar/pegar código en las celdas.
- O, abra tutorials/get-started-notebooks/train-model.ipynb desde la sección Ejemplos de Studio. A continuación, seleccione Clonar para agregar el cuaderno a sus Archivos. (Consulte dónde encontrar Muestras).

Configure el kernel

En la barra superior del cuaderno abierto, cree una instancia de proceso si aún no tiene una.
Si la instancia de proceso se detiene, seleccione Iniciar proceso y espere hasta que se ejecute.
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.
Si ves un banner que dice que debes autenticarte, selecciona Autenticar.

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.

Usar un comando de trabajo para entrenar un modelo en Azure Machine Learning

Para entrenar un modelo, necesita enviar un trabajo. El tipo de trabajo que enviará en este tutorial es un trabajo de comando. Azure Machine Learning ofrece diferentes tipos de tareas para entrenar modelos. Los usuarios pueden seleccionar su método de entrenamiento en función de la complejidad del modelo, el tamaño de los datos y los requisitos de velocidad de entrenamiento. En este tutorial, aprenderá a enviar un trabajo de comando para ejecutar un script de entrenamiento.

Un trabajo de comando es una función que le permite enviar un script de entrenamiento personalizado para entrenar su modelo. También se puede definir como un trabajo de entrenamiento personalizado. Un trabajo de comando en Azure Machine Learning es un tipo de trabajo que ejecuta un script o comando en un entorno específico. Puede usar trabajos de comandos para entrenar modelos, procesar datos o cualquier otro código personalizado que desee ejecutar en la nube.

En este tutorial, nos centraremos en el uso de una tarea de comandos para crear una tarea de entrenamiento personalizada que usaremos para entrenar un modelo. Para cualquier trabajo de entrenamiento personalizado, se requieren los siguientes elementos:

Environment
datos
trabajo de comando
Script de entrenamiento

En este tutorial vamos a proporcionar todos estos elementos para nuestro ejemplo: la creación de un clasificador para predecir los clientes que tienen una alta probabilidad de no pagar con tarjeta de crédito.

Creación de un manipulador para el área de trabajo

Antes de profundizar en el código, necesita una manera de hacer referencia a su área de trabajo. Creará ml_client para un manipulador para el área de trabajo. A continuación, use ml_client para administrar los recursos y puestos de trabajo.

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:

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

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

# authenticate
credential = DefaultAzureCredential()

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

Nota

La creación de MLClient no se conectará al área de trabajo. La inicialización del cliente es lenta, esperará a la primera vez que necesite hacer una llamada (esto ocurrirá en la siguiente celda de código).

# Verify that the handle works correctly.  
# If you ge an error here, modify your SUBSCRIPTION, RESOURCE_GROUP, and WS_NAME in the previous cell.
ws = ml_client.workspaces.get(WS_NAME)
print(ws.location,":", ws.resource_group)

Creación de un entorno de trabajo

Para ejecutar el trabajo de Azure Machine Learning en su recurso de proceso, necesita un entorno. Un entorno enumera el runtime y las bibliotecas del software que desea que se instalen en el proceso en el que se va a entrenar. Es similar al entorno de Python en la máquina local.

Azure Machine Learning proporciona muchos entornos seleccionados o listos, que son útiles para escenarios comunes de entrenamiento e inferencia.

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)

La celda de abajo usa la magia de IPython para escribir el archivo conda en el directorio que acabas de crear.

%%writefile {dependencies_dir}/conda.yaml
name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.8
  - numpy=1.21.2
  - pip=21.2.4
  - scikit-learn=1.0.2
  - scipy=1.7.1
  - pandas>=1.1,<1.2
  - pip:
    - inference-schema[numpy-support]==1.3.0
    - mlflow==2.8.0
    - mlflow-skinny==2.8.0
    - azureml-mlflow==1.51.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"

custom_job_env = Environment(
    name=custom_env_name,
    description="Custom environment for Credit Card Defaults job",
    tags={"scikit-learn": "1.0.2"},
    conda_file=os.path.join(dependencies_dir, "conda.yaml"),
    image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest",
)
custom_job_env = ml_client.environments.create_or_update(custom_job_env)

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

Configurar un trabajo de entrenamiento mediante la función de comando

Se crea un trabajo de comando de Azure Machine Learning para entrenar un modelo de predicción de incumplimiento crediticio. El trabajo de comando ejecuta un script de entrenamiento en un entorno especificado en un recurso de proceso especificado. Ya ha creado el entorno y el clúster de proceso. A continuación, creará el script de entrenamiento. En nuestro caso específico, estamos entrenando nuestro conjunto de datos para producir un clasificador mediante el modelo GradientBoostingClassifier.

El script de entrenamiento controla la preparación de datos, el entrenamiento y el registro del modelo entrenado. El método train_test_split se encarga de dividir el conjunto de datos en datos de prueba y datos de entrenamiento. 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 Machine Learning v2 para crear y ejecutar el trabajo de comando.

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 usa para registrar los parámetros y métricas durante nuestro trabajo. El paquete MLFlow le permite realizar un seguimiento de las métricas y los resultados para cada modelo que Azure entrena. Usaremos MLFlow para obtener primero el mejor modelo para nuestros datos, luego veremos las métricas del modelo en Azure Studio.

%%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_csv(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)

    #Split train and test datasets
    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()

En este script, una vez que el modelo es entrenado, el archivo del modelo se guarda y se registra en el área de trabajo. El registro del modelo le permite almacenar y versionar sus modelos en la nube de Azure, en el área de trabajo. Una vez que registras un modelo, puedes encontrar todos los demás modelos registrados en un lugar de Azure Studio llamado registro de modelos. El registro de modelos le permite organizar los modelos entrenados y llevar un seguimiento de los mismos.

Configuración del comando

Ahora que tiene un script que puede realizar la tarea de clasificación, use el comando de propósito general comando 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í, se crean variables de entrada para especificar los datos de entrada, la proporción de división, la tasa de aprendizaje y el nombre del modelo registrado. El script de comando hará lo siguiente:

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 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 ${{ ... }}.
Como no se ha especificado un recurso de proceso, el script se ejecutará en un clúster de proceso sin servidor que se crea automáticamente.

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://azuremlexamples.blob.core.windows.net/datasets/credit_card/default_of_credit_card_clients.csv",
        ),
        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",
    display_name="credit_default_prediction",
)

Enviar el archivo

Ahora es el momento de enviar el trabajo para que se ejecute en Estudio de Azure Machine Learning. Esta vez usará create_or_update en ml_client. ml_client es una clase cliente que permite conectarse a tu suscripción Azure mediante Python e interactuar con los servicios de Azure Machine Learning. ml_client permite enviar trabajos con Python.

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 Estudio de Azure Machine Learning, seleccione el vínculo en la salida de la celda anterior. La salida de este trabajo tendrá este aspecto en Estudio de Azure Machine Learning. 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.

Screenshot shows the overview page for the job.

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.

Al ejecutar la celda, la salida del bloc de notas muestra un enlace a la página de detalles del trabajo en Azure Studio. También puede seleccionar Trabajos en el menú de navegación de la izquierda. Un trabajo es una agrupación de varias ejecuciones de un script determinado o un fragmento de código. La información de la ejecución se almacena en ese trabajo. La página de detalles ofrece información general sobre el trabajo, el tiempo que tardó en ejecutarse, cuándo se creó, etc. La página también tiene pestañas con otra información sobre el trabajo, como métricas, salidas + registros y código. A continuación se enumeran las pestañas disponibles en la página de información del trabajo:

Información general: la sección de descripción general proporciona información básica sobre el trabajo, incluido su estado, las horas de inicio y finalización y el tipo de trabajo que se ha ejecutado.
Entradas: la sección de entradas enumera los datos y el código que se usaron como entradas para el trabajo. Esta sección puede incluir conjuntos de datos, scripts, configuraciones de entorno y otros recursos usados durante el entrenamiento.
Salidas y registros: la pestaña Salidas + registros contiene los registros generados durante la ejecución del trabajo. Esta pestaña ayuda a solucionar problemas si algo va mal con el script de entrenamiento o la creación del modelo.
Métricas: la pestaña de métricas muestra las métricas de rendimiento clave de su modelo, como la puntuación de entrenamiento, la puntuación f1 y la puntuación de precisión.

Limpieza de recursos

Si quiere continuar con otros tutoriales, ve a Pasos siguientes.

Detención de una instancia de proceso

Si no va a utilizar ahora la instancia de proceso, deténgala:

En el estudio, en el área de navegación de la izquierda, seleccione Proceso.
En las pestañas superiores, seleccione Instancia de proceso.
Seleccione la instancia de proceso en la lista.
En la barra de herramientas superior, seleccione Detener.

Eliminación de todos los recursos

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:

En Azure Portal, seleccione Grupos de recursos a la izquierda del todo.
En la lista, seleccione el grupo de recursos que creó.
Seleccione Eliminar grupo de recursos.
Escriba el nombre del grupo de recursos. A continuación, seleccione Eliminar.

Pasos siguientes

Más información sobre la implementación de un modelo

Implementación de un modelo.

En este tutorial se usa un archivo de datos en línea. Para más información sobre otras formas de acceder a los datos, consulte Tutorial: cargar, acceder y explorar sus datos en Azure Machine Learning.

Si desea más información sobre las distintas formas de entrenar modelos en Azure Machine Learning, consulte ¿Qué es el aprendizaje automático automatizado (AutoML). El ML automatizado es una herramienta complementaria para reducir la cantidad de tiempo que un científico de datos dedica a encontrar un modelo que funcione mejor con sus datos.

Si desea ver más ejemplos similares a este tutorial, consulte la sección Ejemplos del estudio. Estos mismos ejemplos están disponibles en nuestra página de ejemplos GitHub. Los ejemplos incluyen Cuadernos Python completos en los que puedes ejecutar código y aprender a entrenar un modelo. Puede modificar y ejecutar scripts existentes a partir de los ejemplos, que contienen escenarios que incluyen la clasificación, el procesamiento del lenguaje natural y la detección de anomalías.

Tutorial: entrenamiento de un modelo en Azure Machine Learning

Requisitos previos

Configure el kernel

Usar un comando de trabajo para entrenar un modelo en Azure Machine Learning

Creación de un manipulador para el área de trabajo

Creación de un entorno de trabajo

Configurar un trabajo de entrenamiento mediante la función de comando

Creación del script de entrenamiento

Configuración del comando

Enviar el archivo

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

Limpieza de recursos

Detención de una instancia de proceso

Eliminación de todos los recursos

Pasos siguientes

Recursos adicionales