Compartir a través de

Ejecución de modelos de Azure OpenAI en puntos de conexión por lotes para calcular incrustaciones

SE APLICA A:Extensión ML de la CLI de Azure v2 (actual)SDK de Python azure-ai-ml v2 (actual)

Para ejecutar la inferencia en grandes cantidades de datos, puede usar puntos de conexión por lotes para implementar modelos, incluidos los modelos de Azure OpenAI. En este artículo, verá cómo crear un punto de conexión por lotes para implementar el modelo de text-embedding-ada-002 desde Azure OpenAI para calcular incrustaciones a escala. Puede usar el mismo enfoque para las finalizaciones y los modelos de finalizaciones de chat.

En el ejemplo de este artículo se usa la autenticación de Microsoft Entra para conceder acceso a un recurso azure OpenAI en Azure AI Foundry Models, pero también puede usar una clave de acceso. El modelo se registra en formato MLflow. Usa el sabor de Azure OpenAI, que proporciona compatibilidad para llamar a Azure OpenAI a escala.

Para seguir los pasos de ejemplo, consulte el cuaderno de Jupyter Notebook Puntuar modelos de OpenAI por lotes mediante puntos de conexión de Batch.

Requisitos previos

  • Suscripción a Azure. Si no tiene una suscripción a Azure, cree una cuenta gratuita antes de empezar.

  • Un área de trabajo de Azure Machine Learning. Para crear un área de trabajo, vea Administración de áreas de trabajo de Azure Machine Learning.

  • Los siguientes permisos en el área de trabajo de Azure Machine Learning:

    • Para crear o administrar puntos de conexión e implementaciones: utilice un rol de Propietario, Colaborador o personalizado al que se le hayan asignado los permisos Microsoft.MachineLearningServices/workspaces/batchEndpoints/*.
    • Para crear implementaciones de Azure Resource Manager en el grupo de recursos del área de trabajo: use un rol de Propietario, Colaborador o personalizado que tenga asignado el permiso Microsoft.Resources/deployments/write en el grupo de recursos donde se implementa el área de trabajo.

  • La CLI de Azure Machine Learning o el SDK de Azure Machine Learning para Python:

    Ejecute el siguiente comando para instalar la CLI de Azure y la extensión ml para Azure Machine Learning:

    az extension add -n ml

    Las implementaciones de componentes de canalización para puntos de conexión por lotes se introdujeron en la versión 2.7 de la extensión ml para la CLI de Azure. Use el comando az extension update --name ml para obtener la versión más reciente.

Conexión con su área de trabajo

El área de trabajo es el recurso de nivel superior de Azure Machine Learning. Proporciona un lugar centralizado para trabajar con todos los artefactos que cree al usar Azure Machine Learning. En esta sección, se conectará al área de trabajo donde realizará las tareas de implementación.

En el siguiente comando, escriba el id. de suscripción, el nombre del área de trabajo, el nombre de grupo de recursos y la ubicación:

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

Clone el repositorio de ejemplos

El ejemplo de este artículo se basa en ejemplos de código incluidos en el repositorio azureml-examples. Para ejecutar los comandos localmente sin tener que copiar o pegar YAML y otros archivos, use los siguientes comandos para clonar el repositorio e ir a la carpeta del lenguaje de codificación:

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

Use el siguiente comando para ir a la carpeta para este ejemplo:

cd endpoints/batch/deploy-models/openai-embeddings

Creación de un recurso de Azure OpenAI

En este artículo se muestra cómo ejecutar modelos de OpenAI hospedados en Azure OpenAI. Para empezar, necesita un recurso de Azure OpenAI que se implemente en Azure. Para obtener información sobre cómo crear un recurso de Azure OpenAI, consulte Creación de un recurso.

El nombre del recurso de Azure OpenAI forma parte de la dirección URL del recurso. Use el siguiente comando para guardar esa dirección URL para usarla en pasos posteriores.

OPENAI_API_BASE="https://<your-azure-openai-resource-name>.openai.azure.com"

En este artículo, verá cómo crear una implementación para un modelo de Azure OpenAI. En la imagen siguiente se muestra un modelo de Azure OpenAI implementado y se resalta el recurso de Azure OpenAI en el que está implementado:

Captura de pantalla de la página Azure OpenAI en Azure AI Foundry. Se puede ver una implementación de modelos disponible en un recurso de Azure OpenAI determinado.

Para obtener información sobre cómo administrar modelos de Azure OpenAI en Azure OpenAI, consulte Enfoque en Azure OpenAI.

Creación de un clúster de proceso

Los puntos de conexión de Batch usan un clúster de proceso para ejecutar modelos. Use el código siguiente para crear un clúster de proceso denominado batch-cluster-lp. Si ya tiene un clúster de proceso, puede omitir este paso.

COMPUTE_NAME="batch-cluster-lp"
az ml compute create -n batch-cluster-lp --type amlcompute --min-instances 0 --max-instances 5

Elección de un modo de autenticación

Puede acceder al recurso de Azure OpenAI de dos maneras:

  • Autenticación de Microsoft Entra (recomendado)
  • Una clave de acceso

Se recomienda usar Microsoft Entra porque ayuda a evitar la administración de secretos en implementaciones.

Puede configurar la identidad del clúster de proceso para que tenga acceso a la implementación de Azure OpenAI para obtener predicciones. De este modo, no es necesario administrar permisos para cada usuario del punto de conexión. Para proporcionar a la identidad del clúster de proceso acceso al recurso de Azure OpenAI, siga estos pasos:

  1. Asigne una identidad al clúster de proceso que usa la implementación. En este ejemplo se usa un clúster de proceso denominado batch-cluster-lp y una identidad administrada asignada por el sistema, pero puede usar otras opciones. Si el clúster de proceso ya tiene una identidad asignada, puede omitir este paso.

    COMPUTE_NAME="batch-cluster-lp"
az ml compute update --name $COMPUTE_NAME --identity-type system_assigned

  2. Obtenga el identificador de entidad de seguridad de identidad administrada asignado al clúster de proceso que planea usar.

    PRINCIPAL_ID=$(az ml compute show -n $COMPUTE_NAME --query identity.principal_id)

  3. Obtenga el identificador único del grupo de recursos donde se implementa el recurso de Azure OpenAI:

    RG="<openai-resource-group-name>"
RESOURCE_ID=$(az group show -g $RG --query "id" -o tsv)

  4. Asigne el rol de usuario de Cognitive Services a la identidad administrada:

    az role assignment create --role "Cognitive Services User" --assignee $PRINCIPAL_ID --scope $RESOURCE_ID

Registro del modelo de Azure OpenAI

Las implementaciones de modelos en puntos de conexión por lotes solo pueden implementar modelos registrados. Puede usar modelos de MLflow con el tipo de Azure OpenAI para crear un modelo en el área de trabajo que haga referencia a una implementación en Azure OpenAI.

En el repositorio clonado, la carpeta del modelo contiene un modelo de MLflow que genera incrustaciones basadas en el modelo de text-embedding-ada-002.

Registre el modelo en el área de trabajo:

MODEL_NAME='text-embedding-ada-002'
az ml model create --name $MODEL_NAME --path "model"

Creación de una implementación para un modelo de Azure OpenAI

Para implementar el modelo de Azure OpenAI, debe crear un punto de conexión, un entorno, un script de puntuación y una implementación por lotes. En las secciones siguientes se muestra cómo configurar estos componentes.

Crear un punto de conexión

Se necesita un punto de conexión para hospedar el modelo. Para crear un punto de conexión, siga estos pasos:

  1. Configure una variable para almacenar el nombre del punto de conexión. Reemplace el nombre en el código siguiente por uno único dentro de la región del grupo de recursos.

    ENDPOINT_NAME="text-davinci-002"

  2. Configuración del punto de conexión:

    Cree un archivo YAML denominado endpoint.yml que contenga las siguientes líneas. Reemplace el valor name por el nombre del punto de conexión.

    $schema: https://azuremlschemas.azureedge.net/latest/batchEndpoint.schema.json
name: text-embedding-ada-qwerty
description: An endpoint to generate embeddings in batch for the ADA-002 model from OpenAI
auth_mode: aad_token

  3. Cree el recurso de punto de conexión:

    az ml batch-endpoint create -n $ENDPOINT_NAME -f endpoint.yml

Configuración de un entorno

El script de puntuación de este ejemplo usa algunas bibliotecas que no forman parte del SDK de OpenAI estándar. Cree un entorno que contenga una imagen base y también un archivo YAML de conda para capturar esas dependencias:

La definición de entorno consta de las siguientes líneas, que se incluyen en la definición de implementación.

$schema: https://azuremlschemas.azureedge.net/latest/environment.schema.json
name: batch-openai-mlflow
image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
conda_file: conda.yaml

El archivo YAML de conda, conda.yml, contiene las siguientes líneas:

channels:
- conda-forge
dependencies:
- python=3.8.5
- pip<=23.2.1
- pip:
  - openai==0.27.8
  - requests==2.31.0
  - tenacity==8.2.2
  - tiktoken==0.4.0
  - azureml-core
  - azure-identity
  - datasets
  - mlflow

Crear un script de puntuación

En este ejemplo se usa un script de puntuación que realiza la ejecución. En los puntos de conexión por lotes, los modelos de MLflow no necesitan un script de puntuación. Sin embargo, en este ejemplo se amplían las funcionalidades de los puntos de conexión por lotes:

  • Permitir que el punto de conexión lea varios tipos de datos, incluidos CSV, TSV, Parquet, JSON, líneas JSON, flecha y formatos de texto.
  • Agregar algunas validaciones para asegurarse de que el modelo de MLflow tiene un tipo de Azure OpenAI.
  • Aplicar formato a la salida en formato de líneas JSON.
  • Opcionalmente, agregue la variable de entorno AZUREML_BI_TEXT_COLUMN para controlar el campo de entrada para el que desea generar inserciones.

Sugerencia

De manera predeterminada, MLflow genera incrustaciones a partir de la primera columna de texto que está disponible en los datos de entrada. Si desea usar otra columna, establezca la variable de entorno AZUREML_BI_TEXT_COLUMN en el nombre de la columna preferida. Deje esa variable en blanco si el comportamiento predeterminado funciona para usted.

El script de puntuación, código o batch_driver.py, contiene las siguientes líneas:

import os
import glob
import mlflow
import pandas as pd
import numpy as np
from pathlib import Path
from typing import List
from datasets import load_dataset

DATA_READERS = {
    ".csv": "csv",
    ".tsv": "tsv",
    ".parquet": "parquet",
    ".json": "json",
    ".jsonl": "json",
    ".arrow": "arrow",
    ".txt": "text",
}


def init():
    global model
    global output_file
    global task_name
    global text_column

    # AZUREML_MODEL_DIR is the path where the model is located.
    # If the model is MLFlow, you don't need to indicate further.
    model_path = glob.glob(os.environ["AZUREML_MODEL_DIR"] + "/*/")[0]
    # AZUREML_BI_TEXT_COLUMN is an environment variable you can use
    # to indicate over which column you want to run the model on. It can
    # used only if the model has one single input.
    text_column = os.environ.get("AZUREML_BI_TEXT_COLUMN", None)

    model = mlflow.pyfunc.load_model(model_path)
    model_info = mlflow.models.get_model_info(model_path)

    if not mlflow.openai.FLAVOR_NAME in model_info.flavors:
        raise ValueError(
            "The indicated model doesn't have an OpenAI flavor on it. Use "
            "``mlflow.openai.log_model`` to log OpenAI models."
        )

    if text_column:
        if (
            model.metadata
            and model.metadata.signature
            and len(model.metadata.signature.inputs) > 1
        ):
            raise ValueError(
                "The model requires more than 1 input column to run. You can't use "
                "AZUREML_BI_TEXT_COLUMN to indicate which column to send to the model. Format your "
                f"data with columns {model.metadata.signature.inputs.input_names()} instead."
            )

    task_name = model._model_impl.model["task"]
    output_path = os.environ["AZUREML_BI_OUTPUT_PATH"]
    output_file = os.path.join(output_path, f"{task_name}.jsonl")


def run(mini_batch: List[str]):
    if mini_batch:
        filtered_files = filter(lambda x: Path(x).suffix in DATA_READERS, mini_batch)
        results = []

        for file in filtered_files:
            data_format = Path(file).suffix
            data = load_dataset(DATA_READERS[data_format], data_files={"data": file})[
                "data"
            ].data.to_pandas()
            if text_column:
                data = data.loc[[text_column]]
            scores = model.predict(data)
            results.append(
                pd.DataFrame(
                    {
                        "file": np.repeat(Path(file).name, len(scores)),
                        "row": range(0, len(scores)),
                        task_name: scores,
                    }
                )
            )

        pd.concat(results, axis="rows").to_json(
            output_file, orient="records", mode="a", lines=True
        )

    return mini_batch

Creación de una implementación por lotes

Para configurar la implementación de Azure OpenAI, use variables de entorno. En concreto, se usan las siguientes claves:

  • OPENAI_API_TYPE es el tipo de API y autenticación que desea usar.
  • OPENAI_API_BASE es la dirección URL del recurso de Azure OpenAI.
  • OPENAI_API_VERSION es la versión de la API que planea usar.

Si usa la variable de entorno OPENAI_API_TYPE con un valor de azure_ad, Azure OpenAI usa la autenticación de Microsoft Entra. No se requiere ninguna clave para invocar la implementación de Azure OpenAI. En su lugar, se usa la identidad del clúster.

  1. Actualice los valores de las variables de autenticación y entorno en la configuración de implementación. En el ejemplo siguiente se usa la autenticación de Microsoft Entra:

    El archivo deployment.yml configura la implementación:

    $schema: https://azuremlschemas.azureedge.net/latest/modelBatchDeployment.schema.json
endpoint_name: text-embedding-ada-qwerty
name: default
description: The default deployment for generating embeddings
type: model
model: azureml:text-embedding-ada-002@latest
environment:
  name: batch-openai-mlflow
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest
  conda_file: environment/conda.yaml
code_configuration:
  code: code
  scoring_script: batch_driver.py
compute: azureml:batch-cluster-lp
resources:
  instance_count: 1
settings:
  max_concurrency_per_instance: 1
  mini_batch_size: 1
  output_action: summary_only
  retry_settings:
    max_retries: 1
    timeout: 9999
  logging_level: info
  environment_variables:
    OPENAI_API_TYPE: azure_ad
    OPENAI_API_BASE: $OPENAI_API_BASE
    OPENAI_API_VERSION: 2023-03-15-preview

    Sugerencia

    La sección environment_variables proporciona la configuración de la implementación de Azure OpenAI. El valor OPENAI_API_BASE se establece cuando se crea la implementación, por lo que no es necesario editar ese valor en el archivo de configuración de YAML.

  2. Cree la implementación.

    az ml batch-deployment create --file deployment.yml \
                              --endpoint-name $ENDPOINT_NAME \
                              --set-default \
                              --set settings.environment_variables.OPENAI_API_BASE=$OPENAI_API_BASE

    El punto de conexión por lotes está listo para su uso.

Prueba de la implementación

Para probar el punto de conexión, use un ejemplo del conjunto de datos BillSum: Un corpus para el resumen automático de la legislación estadounidense. Este ejemplo se incluye en la carpeta de datos del repositorio clonado.

  1. Configure los datos de entrada:

    En los comandos de esta sección, use datos como nombre de la carpeta que contiene los datos de entrada.

  2. Invocación del punto de conexión:

    JOB_NAME=$(az ml batch-endpoint invoke --name $ENDPOINT_NAME --input data --query name -o tsv)

  3. Realice el seguimiento del progreso:

    az ml job show -n $JOB_NAME --web

  4. Una vez finalizada la implementación, descargue las predicciones:

    az ml job download --name $JOB_NAME --output-name score --download-path ./

  5. Use el código siguiente para ver las predicciones de salida:

    import pandas as pd
from io import StringIO

# Read the output data into an object.
with open('embeddings.jsonl', 'r') as f:
    json_lines = f.readlines()
string_io = StringIO()
for line in json_lines:
    string_io.write(line)
string_io.seek(0)

# Read the data into a data frame.
embeddings = pd.read_json(string_io, lines=True)

# Print the data frame.
print(embeddings)

    También puede abrir el archivo de salida, embeddings.jsonl, para ver las predicciones:

    {"file": "billsum-0.csv", "row": 0, "embeddings": [[0, 0, 0, 0, 0, 0, 0]]}
{"file": "billsum-0.csv", "row": 1, "embeddings": [[0, 0, 0, 0, 0, 0, 0]]}

Contenido relacionado