Este explorador xa non é compatible.
Actualice a Microsoft Edge para dispoñer das funcionalidades máis recentes, as actualizacións de seguranza e a asistencia técnica.
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).
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.
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.
Importante
Si su área de trabajo de Azure Machine Learning está configurada con una red virtual administrada, es posible que deba agregar reglas de salida para permitir el acceso a los repositorios públicos de paquetes de Python. Para más información, consulte Escenario: Acceso a paquetes de aprendizaje automático públicos.
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:
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.
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.
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.
Si ves un banner que dice que debes autenticarte, selecciona Autenticar.
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.
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.
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:
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.
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:
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)
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}"
)
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.
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.
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:
@latest para indicar la versión más reciente del entorno cuando se ejecuta el comando.python main.py en este caso. Puede acceder a las entradas y salidas en el comando con 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://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",
)
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)
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.
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:
Si tiene previsto continuar con otros tutoriales, vaya a Contenido relacionado.
Si no va a utilizar ahora la instancia de proceso, deténgala:
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, en el cuadro de búsqueda, escriba Grupos de recursos y selecciónelo en los resultados.
En la lista, seleccione el grupo de recursos que creó.
En la página Información general, seleccione Eliminar grupo de recursos.
Escriba el nombre del grupo de recursos. A continuación, seleccione Eliminar.
Más información sobre la 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.
Formación
Módulo
Ejecución de un trabajo de comando con el SDK de Python de Azure Machine Learning v2.
Certificación
Microsoft Certified: Azure Data Scientist Associate - Certifications
Administre la ingesta y preparación de datos, el entrenamiento y la implementación de modelos, y la supervisión de soluciones de aprendizaje automático con Python, Azure Machine Learning y MLflow.