Compartir a través de

Creación de paquetes de modelos (versión preliminar)

  • Artículo

El paquete de modelos es una función de Azure Machine Learning que permite recopilar todas las dependencias necesarias para implementar un modelo de aprendizaje automático en una plataforma de servicio. La creación de paquetes antes de implementar los modelos proporciona una implementación sólida y fiable y un flujo de trabajo de MLOps más eficaz. Los paquetes pueden moverse entre áreas de trabajo e incluso fuera de Azure Machine Learning.

Importante

Esta característica actualmente está en su versión preliminar pública. Esta versión preliminar se ofrece sin un Acuerdo de Nivel de Servicio y no se recomienda para cargas de trabajo de producción. Es posible que algunas características no sean compatibles o que tengan sus funcionalidades limitadas.

Para más información, consulte Términos de uso complementarios de las Versiones Preliminares de Microsoft Azure.

En este artículo, aprenderá a empaquetar un modelo para la implementación.

Requisitos previos

Antes de seguir los pasos de este artículo, asegúrese de que tiene los siguientes requisitos previos:

Acerca de este ejemplo

En este ejemplo, aprenderá a empaquetar modelos en Azure Machine Learning.

Clonación del repositorio

El ejemplo de este artículo se basa en ejemplos de código incluidos en el repositorio azureml-examples. Para ejecutar los comandos de forma local sin tener que copiar/pegar YAML y otros archivos, primero clona el repositorio y luego cambia los directorios a la carpeta:

git clone https://github.com/Azure/azureml-examples --depth 1
cd azureml-examples/cli

Esta sección utiliza el ejemplo de la carpeta endpoints/online/deploy-packages/custom-model.

Conexión con su área de trabajo

Conéctese al área de trabajo de Azure Machine Learning donde realizará su trabajo.

az account set --subscription <subscription>
az configure --defaults workspace=<workspace> group=<resource-group> location=<location>

Empaquetado de un modelo

Puede crear paquetes de modelos explícitamente para poder controlar cómo se realiza la operación de empaquetado. Use este flujo de trabajo cuando:

  • Quiera personalizar cómo se crea el paquete de modelos.
  • Quiera implementar el paquete de modelos fuera de Azure Machine Learning.
  • Quiera usar paquetes de modelos en un flujo de trabajo de MLOps.

Puede crear paquetes de modelos especificando lo siguiente:

  • Modelo para empaquetar: cada paquete de modelo solo puede contener un único modelo. Azure Machine Learning no permite empaquetar varios modelos en el mismo paquete de modelos.
  • Entorno base: los entornos son utilizan para indicar la imagen de base, y en los paquetes de Python dependencias que el modelo necesita. Para los modelos MLflow, Azure Machine Learning genera automáticamente el entorno base. Para los modelos personalizados, es necesario especificarlo.
  • Tecnología de servicio: la pila de inferencia utilizada para ejecutar el modelo.

Registro del modelo

Los paquetes de modelos requieren que el modelo esté registrado en su área de trabajo o en un registro de Azure Machine Learning. En este ejemplo, ya tiene una copia local del modelo en el repositorio, por lo que solo necesita publicar el modelo en el registro del área de trabajo. Puede omitir esta sección si el modelo que intenta implementar ya está registrado.

MODEL_NAME='sklearn-regression'
MODEL_PATH='model'
az ml model create --name $MODEL_NAME --path $MODEL_PATH --type custom_model

Creación del entorno base

Los entornos base son utilizan para indicar la imagen de base y las dependencias del paquete Python modelo. Nuestro modelo requiere que se usen los siguientes paquetes como se indica en el archivo de Conda:

conda.yaml

name: model-env
channels:
  - conda-forge
dependencies:
  - python=3.9
  - numpy=1.23.5
  - pip=23.0.1
  - scikit-learn=1.2.2
  - scipy=1.10.1
  - xgboost==1.3.3

Nota:

¿Cuál es el entorno base diferente del entorno que se usa para la implementación de modelos en puntos de conexión en línea y por lotes? Al implementar modelos en puntos de conexión, el entorno debe incluir las dependencias del modelo y los paquetes de Python necesarios para que los puntos de conexión en línea administrados funcionen. Esto conlleva un proceso manual en la implementación, donde tiene que combinar los requisitos del modelo con los requisitos de la plataforma de servicio. Por otro lado, el uso de paquetes de modelo elimina esta fricción, ya que los paquetes necesarios para el servidor de inferencia se insertarán automáticamente en el paquete del modelo en el momento del empaquetado.

Crear el entorno de la siguiente manera:

Creación de una definición de entorno:

sklearn-regression-env.yml

$schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: sklearn-regression-env
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu22.04
conda_file: conda.yaml
description: An environment for models built with XGBoost and Scikit-learn.

Luego cree el entorno:

az ml environment create -f environment/sklearn-regression-env.yml

Creación de una especificación del paquete

Puede crear paquetes de modelo en Azure Machine Learning mediante la CLI de Azure o el SDK de Azure Machine Learning para Python. La especificación del paquete personalizado admite los siguientes atributos:

Atributo Tipo Descripción Obligatorio
target_environment str El nombre del paquete que se va a crear. El resultado de la operación de empaquetado es un entorno en Azure Machine Learning. Sí
base_environment_source object La imagen base que se va a usar para crear el paquete donde se especifican las dependencias del modelo. Sí, a menos que el modelo sea MLflow.
base_environment_source.type str El tipo de la imagen base. Solo se admite el uso de otro entorno como imagen base (type: environment_asset).
base_environment_source.resource_id str El identificador de recurso del entorno base que se va a usar. Use el formato azureml:<name>:<version> o un identificador de recurso largo.
inferencing_server object El servidor de inferencia que se va a usar. Sí
inferencing_server.type azureml_online
custom		 Use azureml_online para el servidor de inferencia de Azure Machine Learning o custom para un servidor en línea personalizado, como TensorFlow Serving o Torch Serve. Sí
inferencing_server.code_configuration object La configuración de código con la rutina de inferencia. Debe contener al menos un archivo de Python con métodos init y run. Sí, a menos que el modelo sea MLflow.
model_configuration object La configuración del modelo. Use este atributo para controlar cómo se empaqueta el modelo en la imagen resultante. No
model_configuration.mode download
copy		 Indique cómo se colocaría el modelo en el paquete. Los valores posibles son: download (predeterminado) y copy. Use download cuando quiera que el modelo se descargue del registro de modelos en el momento de la implementación. Esta opción crea imágenes de Docker más pequeñas, ya que el modelo no está incluido en ella. Use copy cuando quiera desconectar la imagen de Azure Machine Learning. El modelo se copiará dentro de la imagen de Docker en el momento de creación del paquete. copy no se admite en áreas de trabajo habilitadas para vínculo privado. No

  1. Cree una especificación del paquete del modo siguiente:

    package-moe.yml

    $schema: http://azureml/sdk-2-0/ModelVersionPackage.json
base_environment_source:
    type: environment_asset
    resource_id: azureml:sklearn-regression-env:1
target_environment: sklearn-regression-online-pkg
inferencing_server: 
    type: azureml_online
    code_configuration:
      code: src
      scoring_script: score.py

  2. Inicie la operación del paquete de modelos:

    az ml model package -n $MODEL_NAME -v $MODEL_VERSION --file package-moe.yml

  3. El resultado de la operación de empaquetado es un entorno.

Empaquetado de un modelo que tiene dependencias en fuentes privadas de Python

Los paquetes de modelos pueden resolver las dependencias de Python que están disponibles en fuentes privadas. Para usar esta funcionalidad, debe crear una conexión desde el área de trabajo a la fuente y especificar la configuración del token PAT. En el código de Python siguiente se muestra cómo configurar el área de trabajo donde se ejecuta la operación de paquete.

from azure.ai.ml.entities import WorkspaceConnection
from azure.ai.ml.entities import PatTokenConfiguration

# fetching secrets from env var to secure access, these secrets can be set outside or source code
git_pat = os.environ["GIT_PAT"]

credentials = PatTokenConfiguration(pat=git_pat)

ws_connection = WorkspaceConnection(
    name="<workspace_connection_name>",
    target="<git_url>",
    type="git",
    credentials=credentials,
)

ml_client.connections.create_or_update(ws_connection)

Una vez creada la conexión, compile el paquete de modelo como se describe en la sección Empaquetado de un modelo. En el ejemplo siguiente, el entorno base del paquete usa una fuente privada para la dependencia de Python bar, tal como se especifica en el siguiente archivo de Conda:

conda.yml

name: foo
channels:
  - defaults
dependencies:
  - python
  - pip
  - pip:
    - --extra-index-url <python_feed_url>
    - bar

Si usa un modelo de MLflow, las dependencias del modelo se indican dentro del propio modelo y, por tanto, no se necesita un entorno base. En su lugar, especifique las dependencias de fuente privada al registrar el modelo, como se explica en Registro de modelos con una firma personalizada, un entorno o ejemplos.

Empaquetado de un modelo hospedado en un registro

Los paquetes de modelos proporcionan una manera cómoda de recopilar dependencias antes de la implementación. Sin embargo, cuando los modelos se hospedan en registros, el destino de implementación suele ser otra área de trabajo. Al crear paquetes en esta configuración, use la propiedad target_environment para especificar la ubicación completa donde desea que se cree el paquete de modelo, en lugar de solo su nombre.

El código siguiente crea un paquete del modelo t5-base a partir de un registro:

  1. Conéctese al registro donde se encuentra el modelo y al área de trabajo en la que necesita que se cree el paquete de modelo:

    az login

  2. Obtenga una referencia al modelo que desea empaquetar. En este caso, estamos empaquetando el modelo t5-base desde el registro azureml.

    MODEL_NAME="t5-base"
MODEL_VERSION=$(az ml model show --name $MODEL_NAME --label latest --registry-name azureml | jq .version -r)

  3. Configure una especificación de paquete. Dado que el modelo que queremos empaquetar es MLflow, el entorno base y el script de puntuación son opcionales.

    package.yml

    $schema: http://azureml/sdk-2-0/ModelVersionPackage.json
target_environment: pkg-t5-base-online
inferencing_server: 
    type: azureml_online

  4. Inicie la operación para crear el paquete de modelo:

    az ml model package --name $MODEL_NAME \
                    --version $MODEL_VERSION \
                    --registry-name azureml \
                    --file package.yml

  5. El paquete ahora se crea en el área de trabajo de destino y está listo para implementarse.

Empaquetado de modelos para implementar fuera de Azure Machine Learning

Los paquetes de modelo se pueden implementar fuera de Azure Machine Learning si es necesario. Para garantizar la portabilidad, solo debe asegurarse de que la configuración del modelo del paquete tenga el modo establecido en copy para que el propio modelo se copie dentro de la imagen de Docker generada en lugar de hacer referencia al registro de modelos en Azure Machine Learning.

En el código siguiente se muestra cómo configurar copy en un paquete de modelos:

package-external.yml

$schema: http://azureml/sdk-2-0/ModelVersionPackage.json
base_environment_source:
    type: environment_asset
    resource_id: azureml:sklearn-regression-env:1
target_environment: sklearn-regression-docker-pkg
inferencing_server: 
    type: azureml_online
    code_configuration:
      code: src
      scoring_script: score.py
model_configuration:
  mode: copy

Paso siguiente