Compartir a través de

Tutorial: entrenamiento de un modelo en Azure Machine Learning

  • Artículo

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, usará un conjunto de datos de tarjetas de crédito para comprender cómo 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 se encarga de la preparación de los datos. A continuación, el script 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).

  • 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 el trabajo de comando para ejecutar el script de entrenamiento en el recurso de proceso.
  • 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

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.

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, necesita 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:

    • Si desea copiar y pegar código en celdas, cree un cuaderno nuevo.
    • 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. Para encontrar cuadernos de ejemplo, consulte Aprender con cuadernos de ejemplo.

Establecer el kernel y abrirlo en Visual Studio Code (VS Code)

  1. En la barra superior del cuaderno abierto, cree una instancia de proceso si aún no tiene una.

    Captura de pantalla muestra cómo crear una instancia de proceso.

  2. Si la instancia de proceso se detiene, seleccione Iniciar proceso y espere hasta que se ejecute.

    Captura de pantalla que muestra cómo iniciar una instancia de proceso detenida.

  3. Espere hasta que la instancia de cálculo esté en ejecución. A continuación, 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 muestra cómo configurar el kernel.

    Si no ve este kernel, compruebe que la instancia de proceso se está ejecutando. Si es así, seleccione el botón Actualizar situado en la parte superior derecha del cuaderno.

  4. Si ves un banner que dice que debes autenticarte, selecciona Autenticar.

  5. Puede ejecutar el cuaderno aquí o abrirlo en VS Code para un entorno de desarrollo integrado (IDE) completo con la eficacia de los recursos de Azure Machine Learning. Seleccione Abrir en VS Codey, a continuación, seleccione la opción web o de escritorio. Cuando se inicia de esta manera, VS Code se adjunta a la instancia de proceso, el kernel y el sistema de archivos del área de trabajo.

    Captura de pantalla que muestra cómo abrir el cuaderno en VS Code.

Importante

El resto de este tutorial contiene celdas del cuaderno del tutorial. Cópielos y péguelos en su nuevo cuaderno, o cambie al cuaderno actual 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. 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.

Este tutorial se centra en el uso de una tarea de comandos para crear una tarea de entrenamiento personalizada que usará para entrenar un modelo. Cualquier trabajo de entrenamiento personalizado requiere los siguientes elementos:

  • de origen
  • datos
  • trabajo de comando
  • Script de entrenamiento

Este tutorial proporciona todos estos elementos para el 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 al área de trabajo. Cree ml_client para un manejo del á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:

  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. Debe 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 conecta al área de trabajo. La inicialización del cliente es diferida. Espera por primera vez que necesita realizar una llamada, lo que sucede 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 del software y las bibliotecas que desea instalar en el proceso en el que realiza el entrenamiento. Es similar al entorno de Python en la máquina local. Para más información, consulte ¿Qué son los entornos de Azure Machine Learning?

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 siguiente celda usa la magia de IPython para escribir el archivo Conda en el directorio que creó.

%%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 se usan en el trabajo, como numpy y 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, cree el script de entrenamiento. En este caso, va a entrenar el conjunto de datos para generar 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 divide 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

Empiece 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 procesa previamente los datos, lo divide en datos de prueba y entrenamiento. A continuación, consume los 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 este trabajo. El paquete MLFlow permite realizar un seguimiento de las métricas y los resultados de cada modelo que entrena Azure. Use MLFlow para obtener el mejor modelo para los datos. A continuación, vea las métricas del modelo en Azure Studio. Para más información, consulte MLflow y Azure Machine Learning.

%%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, después de entrenar el modelo, 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. Después de registrar un modelo, puede 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.

Cree 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 comandos:

  • Usa el entorno creado anteriormente. Use la notación @latest para indicar la versión más reciente del entorno cuando se ejecuta el comando.
  • Configura la propia acción de la línea de comandos, python main.py en este caso. Puede acceder a las entradas y salidas en el comando con la notación ${{ ... }}.
  • Como no se ha especificado un recurso de proceso, el script se ejecuta 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

Envíe el trabajo para que se ejecute en Estudio de Azure Machine Learning. Esta vez, use 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 finalizado el trabajo, registra un modelo en el área de trabajo como resultado del entrenamiento.

Captura de pantalla muestra la página de información general del trabajo.

Importante

Espere hasta que se complete el estado del trabajo antes de volver a este cuaderno para continuar. El trabajo tarda 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 cuaderno muestra un vínculo a la página de detalles del trabajo en Estudio de Machine Learning. 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 proporciona información general sobre el trabajo, el tiempo necesario para ejecutarse, cuándo se creó y otra información. La página también tiene pestañas a otra información sobre el trabajo, como métricas, salidas y registros y código. Estas son las pestañas disponibles en la página de detalles del trabajo:

  • Información general: información básica sobre el trabajo, incluido su estado, las horas de inicio y finalización, y el tipo de trabajo que se ejecutó
  • Entradas: 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: registros generados mientras se estaba ejecutando el 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: métricas clave de rendimiento del modelo, como la puntuación de entrenamiento, la puntuación F1 y la puntuación de precisión.

Limpieza de recursos

Si tiene previsto continuar con otros tutoriales, vaya a Contenido relacionado.

Detención de una instancia de proceso

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

  1. En el estudio, en el área de navegación de la izquierda, seleccione Proceso.
  2. En las pestañas superiores, seleccione Instancia de proceso.
  3. Seleccione la instancia de proceso en la lista.
  4. 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:

  1. En Azure Portal, en el cuadro de búsqueda, escriba Grupos de recursos y selecciónelo en los resultados.

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

  3. En la página Información general, 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.

Contenido relacionado

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.

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. Para más información, vea ¿Qué es el aprendizaje automático automatizado?

Si desea obtener más ejemplos similares a este tutorial, consulte Información sobre cuadernos de ejemplo. Estos ejemplos están disponibles en la página de ejemplos de 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.