Compartir a través de

Creación y ejecución de canalizaciones de aprendizaje automático mediante componentes con la CLI de Azure Machine Learning

SE APLICA A:Extensión de ML de la CLI de Azure v2 (actual)

En este artículo, aprenderá a crear y ejecutar canalizaciones de aprendizaje automático mediante la CLI de Azure y los componentes. Puede crear canalizaciones sin usar componentes, pero los componentes proporcionan flexibilidad y habilitan la reutilización. Las canalizaciones de Azure Machine Learning se pueden definir en YAML y ejecutarse desde la CLI, creadas en Python o compuestas en el Diseñador de Azure Machine Learning Studio mediante una interfaz de usuario de arrastrar y colocar. Este artículo se centra en la CLI.

Prerrequisitos

Lecturas previas sugeridas

Crea tu primera canalización con componentes

En primer lugar, creará una canalización con componentes utilizando un ejemplo. Al hacerlo, obtienes una impresión inicial de cómo son una tubería y un componente en Azure Machine Learning.

En el directorio cli/jobs/pipelines-with-components/basics del repositorio azureml-examples, vaya al subdirectorio 3b_pipeline_with_data. Hay tres tipos de archivos en este directorio. Estos son los archivos que debe crear al construir su propia canalización.

  • pipeline.yml. Este archivo YAML define la canalización de aprendizaje automático. Describe cómo dividir una tarea de aprendizaje automático completa en un flujo de trabajo de varios pasos. Por ejemplo, considere la tarea de aprendizaje automático simple de usar datos históricos para entrenar un modelo de previsión de ventas. Es posible que quiera crear un flujo de trabajo secuencial que contenga los pasos de procesamiento de datos, entrenamiento del modelo y evaluación del modelo. Cada paso es un componente que tiene una interfaz bien definida y se puede desarrollar, probar y optimizar de forma independiente. La canalización YAML también define cómo se conectan los pasos secundarios a otros pasos de la canalización. Por ejemplo, el paso de entrenamiento del modelo genera un archivo de modelo y el archivo de modelo se pasa a un paso de evaluación del modelo.

  • component.yml. Estos archivos YAML definen los componentes. Contienen la siguiente información:

    • Metadatos: nombre, nombre para mostrar, versión, descripción, tipo, etc. Los metadatos ayudan a describir y administrar el componente.
    • Interfaz: entradas y salidas. Por ejemplo, un componente de entrenamiento del modelo toma los datos de entrenamiento y el número de épocas como entrada y genera un archivo de modelo entrenado como salida. Una vez definida la interfaz, diferentes equipos pueden desarrollar y probar el componente de forma independiente.
    • Comando, código y entorno: comando, código y entorno para ejecutar el componente. El comando es el comando shell para ejecutar el componente. El código normalmente hace referencia a un directorio de código fuente. El entorno puede ser un entorno de Azure Machine Learning (mantenido o creado por el cliente), una imagen de Docker o un entorno de Conda.

  • component_src. Estos son los directorios de código fuente para componentes específicos. Contienen el código fuente que se ejecuta en el componente. Puede usar su lenguaje preferido, incluido Python, R y otros. El código debe ejecutarse mediante un comando de shell. El código fuente puede tomar algunas entradas de la línea de comandos del shell para controlar cómo se ejecuta este paso. Por ejemplo, un paso de entrenamiento podría realizar datos de entrenamiento, velocidad de aprendizaje y el número de épocas para controlar el proceso de entrenamiento. El argumento de un comando de shell se usa para pasar entradas y salidas al código.

Ahora creará una canalización utilizando el ejemplo 3b_pipeline_with_data. Cada archivo se explica más en las secciones siguientes.

En primer lugar, enumere los recursos de proceso disponibles mediante el comando siguiente:

az ml compute list

Si no lo tiene, cree un clúster llamado cpu-cluster mediante la ejecución de este comando:

Nota:

Omite este paso para usar el proceso sin servidor.

az ml compute create -n cpu-cluster --type amlcompute --min-instances 0 --max-instances 10

Ahora cree un trabajo de canalización definido en el archivo pipeline.yml mediante la ejecución del comando siguiente. Se hace referencia al destino de proceso en el archivo pipeline.yml como azureml:cpu-cluster. Si el destino de proceso usa un nombre diferente, recuerde actualizarlo en el archivo pipeline.yml.

az ml job create --file pipeline.yml

Debe recibir un diccionario JSON con información sobre el trabajo de canalización, entre los que se incluyen:

Clave Descripción
name Nombre basado en GUID del trabajo.
experiment_name Nombre con el que se organizarán los trabajos en el estudio.
services.Studio.endpoint Dirección URL para supervisar y revisar el trabajo de canalización.
status El estado del trabajo. Probablemente estará Preparing en este momento.

Vaya a la services.Studio.endpoint dirección URL para ver una visualización de la canalización:

Captura de pantalla de una visualización de la canalización.

Descripción de la definición de canalización YAML

Ahora verá la definición de canalización en el archivo 3b_pipeline_with_data/pipeline.yml .

Nota:

Para usar el proceso sin servidor, reemplace default_compute: azureml:cpu-cluster por default_compute: azureml:serverless en este archivo.

$schema: https://azuremlschemas.azureedge.net/latest/pipelineJob.schema.json
type: pipeline

display_name: 3b_pipeline_with_data
description: Pipeline with 3 component jobs with data dependencies

settings:
  default_compute: azureml:cpu-cluster

outputs:
  final_pipeline_output:
    mode: rw_mount

jobs:
  component_a:
    type: command
    component: ./componentA.yml
    inputs:
      component_a_input: 
        type: uri_folder
        path: ./data

    outputs:
      component_a_output: 
        mode: rw_mount
  component_b:
    type: command
    component: ./componentB.yml
    inputs:
      component_b_input: ${{parent.jobs.component_a.outputs.component_a_output}}
    outputs:
      component_b_output: 
        mode: rw_mount
  component_c:
    type: command
    component: ./componentC.yml
    inputs:
      component_c_input: ${{parent.jobs.component_b.outputs.component_b_output}}
    outputs:
      component_c_output: ${{parent.outputs.final_pipeline_output}}
      #  mode: upload

En la tabla siguiente se describen los campos más usados del esquema YAML de canalización. Para más información, consulte el esquema YAML de canalización completa.

Clave Descripción
type Necesario. Tipo de trabajo. Debe ser pipeline para los trabajos de canalización.
display_name Nombre para mostrar del trabajo de canalización en la interfaz de usuario de estudio. Se puede editar en la interfaz de usuario del Studio. No es necesario que sea único en todos los trabajos del área de trabajo.
jobs Necesario. Diccionario del conjunto de trabajos individuales que se ejecutarán como pasos dentro de la canalización. Estos trabajos se consideran trabajos secundarios del trabajo de canalización primario. En la versión actual, los tipos de trabajo admitidos en el pipeline son command y sweep.
inputs Diccionario de entradas para el trabajo de canalización. La clave es un nombre para la entrada dentro del contexto del trabajo y el valor es el valor de entrada. Puede hacer referencia a estas entradas de canalización mediante las entradas de un trabajo de paso individual de la canalización mediante la expresión ${{ parent.inputs.<input_name> }}.
outputs Diccionario de configuraciones de salida del trabajo de canalización. La clave es un nombre para la salida en el contexto del trabajo y el valor es la configuración de salida. Puede hacer referencia a estas salidas de canalización mediante las salidas de un trabajo de paso individual de la canalización mediante la expresión ${{ parents.outputs.<output_name> }}.

El ejemplo de 3b_pipeline_with_data contiene una canalización de tres pasos.

  • Los tres pasos se definen en jobs. Los tres pasos son de tipo command. La definición de cada paso está en un archivo correspondiente component*.yml . Puede ver los archivos YAML del componente en el directorio 3b_pipeline_with_data . componentA.yml se describe en la sección siguiente.
  • Esta canalización tiene dependencia de datos, que es común en las canalizaciones del mundo real. El componente A toma la entrada de datos de una carpeta local en ./data (líneas 18-21) y pasa su salida al componente B (línea 29). Se puede hacer referencia a la salida del componente A como ${{parent.jobs.component_a.outputs.component_a_output}}.
  • default_compute define el cómputo predeterminado para la canalización. Si un componente bajo jobs define un proceso diferente, se respeta la configuración específica del componente.

Captura de pantalla de la canalización con el ejemplo de datos.

Lectura y escritura de datos en una canalización

Un escenario común es leer y escribir datos en una canalización. En Azure Machine Learning, se usa el mismo esquema para leer y escribir datos para todos los tipos de trabajos (trabajos de canalización, trabajos de comando y trabajos de barrido). A continuación se muestran ejemplos de uso de datos en canalizaciones para escenarios comunes:

Descripción de la definición de componentes YAML

Este es el archivo componentA.yml , un ejemplo de YAML que define un componente:

$schema: https://azuremlschemas.azureedge.net/latest/commandComponent.schema.json
type: command

name: component_a
display_name: componentA
version: 1

inputs:
  component_a_input:
    type: uri_folder

outputs:
  component_a_output:
    type: uri_folder

code: ./componentA_src

environment: 
  image: python

command: >-
  python hello.py --componentA_input ${{inputs.component_a_input}} --componentA_output ${{outputs.component_a_output}}

En esta tabla se definen los campos más usados del componente YAML. Para obtener más información, consulte el esquema YAML de componente completo.

Clave Descripción
name Necesario. Nombre del componente. Debe ser único en el área de trabajo de Azure Machine Learning. Debe comenzar con una letra minúscula. Se permiten letras minúsculas, números y caracteres de subrayado (_). La longitud máxima es de 255 caracteres.
display_name Nombre para mostrar del componente en la interfaz de usuario de Studio. No tiene que ser único dentro del área de trabajo.
command Necesario. Comando que debe ejecutar.
code Ruta de acceso local al directorio de código fuente que se va a cargar y usar para el componente.
environment Necesario. Entorno que se usa para ejecutar el componente.
inputs Diccionario de entradas de componentes. La clave es un nombre para la entrada dentro del contexto del componente y el valor es la definición de entrada del componente. Puede hacer referencia a entradas en el comando mediante la ${{ inputs.<input_name> }} expresión .
outputs Diccionario de salidas de componentes. La clave es un nombre para la salida dentro del contexto del componente y el valor es la definición de salida del componente. Puede hacer referencia a salidas en el comando mediante la ${{ outputs.<output_name> }} expresión .
is_deterministic Si se va a reutilizar el resultado del trabajo anterior si las entradas del componente no cambian. El valor predeterminado es true. Esta configuración también se conoce como reutilización de forma predeterminada. El escenario común cuando se establece en false es forzar la recarga de datos desde el almacenamiento en la nube o una dirección URL.

En el ejemplo de 3b_pipeline_with_data/componentA.yml, el componente A tiene una entrada de datos y una salida de datos, que se puede conectar a otros pasos de la canalización primaria. Todos los archivos de la code sección del componente YAML se cargarán en Azure Machine Learning cuando se envíe el trabajo de canalización. En este ejemplo, se cargarán los archivos en ./componentA_src . (Línea 16 en componentA.yml).) Puede ver el código fuente cargado en la interfaz de usuario de Studio: haga doble clic en el paso componentA del gráfico y vaya a la pestaña Código , como se muestra en la captura de pantalla siguiente. Puede ver que es un script hello-world que realiza una impresión sencilla y que escribe la fecha y hora actuales en la ruta de componentA_output acceso. El componente toma la entrada y proporciona la salida a través de la línea de comandos. Se controla en hello.py a través deargparse.

Captura de pantalla de la canalización con el ejemplo de datos. Muestra el componente A.

Entrada y salida

La entrada y la salida definen la interfaz de un componente. La entrada y la salida pueden ser valores literales (de tipo string, number, integero boolean) o un objeto que contiene un esquema de entrada.

La entrada de objeto (de tipo uri_file, , uri_foldermltable, mlflow_modelo custom_model) puede conectarse a otros pasos del trabajo de canalización principal para pasar datos o modelos a otros pasos. En el gráfico de canalización, la entrada de tipo de objeto se representa como un punto de conexión.

Las entradas de valor literal (string, number, integer, boolean) son los parámetros que puede pasar al componente en tiempo de ejecución. Puede agregar un valor predeterminado de entradas literales en el default campo. Para los tipos number y integer, también puede agregar valores mínimos y máximos mediante los campos min y max. Si el valor de entrada es menor que el mínimo o superior al máximo, se produce un error en la canalización en la validación. La validación se produce antes de enviar un trabajo de canalización, lo que puede ahorrar tiempo. La validación funciona para la CLI, el SDK de Python y la interfaz de usuario del diseñador. En la captura de pantalla siguiente se muestra un ejemplo de validación en la interfaz de usuario del diseñador. Del mismo modo, puede definir valores permitidos en enum campos.

Captura de pantalla de la entrada y la salida del componente del entrenamiento del modelo de regresión lineal.

Si desea agregar una entrada a un componente, debe realizar modificaciones en tres lugares:

  • Campo inputs del componente YAML.
  • Campo command del componente YAML.
  • En el código fuente del componente para controlar la entrada de la línea de comandos.

Estas ubicaciones se marcan con cuadros verdes en la captura de pantalla anterior.

Para más información sobre las entradas y salidas, consulte Administración de entradas y salidas para componentes y canalizaciones.

Entornos

El entorno es el entorno en el que se ejecuta el componente. Podría ser un entorno de Azure Machine Learning (mantenido o registrado personalizado), una imagen de Docker o un entorno de Conda. Vea los ejemplos siguientes:

Registro de un componente para reutilizar y compartir

Aunque algunos componentes son específicos de una canalización determinada, la ventaja real de los componentes procede de la reutilización y el uso compartido. Puede registrar un componente en el área de trabajo de Machine Learning para que esté disponible para su reutilización. Los componentes registrados admiten el control de versiones automático para que pueda actualizar el componente, pero asegúrese de que las canalizaciones que requieren una versión anterior seguirán funcionando.

En el repositorio azureml-examples, diríjase al directorio cli/jobs/pipelines-with-components/basics/1b_e2e_registered_components.

Para registrar un componente, use el comando az ml component create:

az ml component create --file train.yml
az ml component create --file score.yml
az ml component create --file eval.yml

Una vez que estos comandos se completen, puede ver los componentes en Studio, bajo Recursos>Componentes:

Captura de pantalla de Studio. Muestra los componentes registrados.

Seleccione un componente. Verá información detallada de cada versión del componente.

En la pestaña Detalles se muestra información básica como el nombre del componente, quién lo creó y la versión. Hay campos editables para etiquetas y descripción. Puede usar etiquetas para agregar palabras clave de búsqueda. El campo de descripción admite el formato Markdown. Debe usarlo para describir la funcionalidad del componente y el uso básico.

En la pestaña Trabajos , verá el historial de todos los trabajos que usan el componente.

Uso de componentes registrados en un archivo YAML de un trabajo de canalización

Ahora usará 1b_e2e_registered_components como ejemplo de cómo usar el componente registrado en la canalización YAML. Vaya al 1b_e2e_registered_components directorio y abra el pipeline.yml archivo. Las claves y los valores de los campos inputs y outputs son similares a los que ya se han analizado. La única diferencia significativa es el valor del campo component de las entradas jobs.<job_name>.component. El component valor está en el formato azureml:<component_name>:<component_version>. La train-job definición, por ejemplo, especifica que se debe usar la versión más reciente del componente my_train registrado:

type: command
component: azureml:my_train@latest
inputs:
  training_data: 
    type: uri_folder 
    path: ./data      
  max_epocs: ${{parent.inputs.pipeline_job_training_max_epocs}}
  learning_rate: ${{parent.inputs.pipeline_job_training_learning_rate}}
  learning_rate_schedule: ${{parent.inputs.pipeline_job_learning_rate_schedule}}
outputs:
  model_output: ${{parent.outputs.pipeline_job_trained_model}}
services:
  my_vscode:

Administración de componentes

Puede comprobar los detalles del componente y administrar los componentes mediante la CLI v2. Use az ml component -h para obtener instrucciones detalladas sobre los comandos de componente. En la siguiente tabla se enumeran todos los comandos disponibles. Consulte más ejemplos en la referencia de la CLI de Azure.

Comando Descripción
az ml component create Crear un componente.
az ml component list Enumere los componentes de un área de trabajo.
az ml component show Muestra los detalles de un componente.
az ml component update Actualización de un componente Solo algunos campos (descripción, display_name) admiten la actualización.
az ml component archive Archivar un contenedor de componentes.
az ml component restore Restaure un componente archivado.

Paso siguiente

  • Prueba el ejemplo del componente CLI v2