Implementaciones rápidas para puntos de conexión de servicio de modelos

En esta página se describe cómo utilizar las implementaciones exprés en tus puntos de conexión de servicio de modelos. Los despliegues exprés reducen los tiempos de despliegue y mantienen el entorno de servicio del modelo igual al entorno de entrenamiento del modelo.

Note

Anteriormente, las implementaciones rápidas se denominaban implementaciones optimizadas sin servidor.

¿Qué son los despliegues exprés?

Las implementaciones exprés empaquetan y preparan los artefactos del modelo en entornos de cuadernos sin servidor durante el registro del modelo. Esto acelera la implementación de los puntos de conexión y mantiene la coherencia entre los entornos de entrenamiento y de servicio.

En los despliegues no Express, los artefactos del modelo y los entornos se empaquetan en contenedores en el momento del despliegue, por lo que es posible que el entorno de servicio no coincida con el utilizado durante el entrenamiento del modelo.

Despliegues estándar frente a exprés

En la tabla siguiente se compara una implementación estándar y una implementación rápida.

Aspecto Implementación estándar Implementación rápida
Cuando se compila el entorno Una imagen de contenedor se crea en el momento del despliegue. Los artefactos y el entorno se empaquetan al registrar el modelo.
Entorno de entrenamiento y servicio Es posible que el entorno de servicio no coincida con el entorno de entrenamiento. El entorno de servicio es idéntico al entorno de cuaderno desde el que se realizó el registro.
Velocidad de implementación Más despacio. La implementación espera a que se compile la imagen del contenedor. Más rapidez. En el despliegue se omite la creación de la imagen del contenedor.
Velocidad de registro Estándar. El empaquetado añade entre unos segundos y un minuto, dependiendo del tamaño del modelo y del entorno.
Registro de eventos de implementación Muestra eventos de creación de imágenes de contenedor. No muestra eventos de creación de imágenes de contenedor.

Las implementaciones Express trasladan el trabajo de empaquetado, que se realiza una sola vez, al registro del modelo, lo que añade entre unos segundos y un minuto a una llamada register_model, según el tamaño del modelo y del entorno. A cambio, la implementación es significativamente más rápida: omite completamente la compilación de la imagen de contenedor. Esa compilación también es un origen común de errores de implementación (resolución de dependencias, errores de compilación de imágenes), por lo que omitirlo elimina toda una clase de problemas. El registro de eventos de implementación de un modelo express no contiene eventos de compilación de contenedor.

Requirements

Los puntos de conexión de implementación rápida tienen los mismos requisitos que un punto de conexión de servicio de modelos. Vea Requisitos.

Además:

  • El modelo debe ser un modelo personalizado
  • El modelo debe registrarse y quedar registrado en un Serverless Notebook utilizando la versión 3 o posterior.
  • El modelo debe estar registrado y dado de alta con mlflow>=3.12 y databricks-sdk>=0.102.0
  • El modelo debe estar registrado en el catálogo de Unity. La capacidad de cálculo del servicio debe coincidir con la capacidad de cálculo desde la que se registró el modelo. Puede registrarlo desde un cuaderno sin servidor normal para servirlo en CPU, o desde recursos de GPU sin servidor para servirlo en GPU.
  • El tamaño máximo del entorno del modelo es de 200 GB

Note

Para implementar un LLM personalizado en recursos de computación con GPU mediante despliegues exprés, consulte Implementar LLM personalizados con Custom Model Serving.

Implementación de un reranker en GPU

En este tutorial se implementa BAAI/bge-reranker-base, un reordenador de codificadores cruzados que evalúa en qué medida un documento responde a una consulta. Configura el entorno, genera registros y registra el modelo con empaquetado exprés, despliega el endpoint y lo consulta.

Las implementaciones de GPU suelen producir errores debido a conflictos de versión de dependencia, por ejemplo, torch y CUDA. Las implementaciones rápidas resuelven esto de dos maneras:

  • El conjunto fijo publicado de bibliotecas preinstaladas en cada versión del entorno de GPU sin servidor está presente durante el servicio exactamente como está en el cuaderno: la misma versión del entorno, las mismas versiones. Estas bibliotecas no se vuelven a empaquetar.
  • Las dependencias adicionales que instale en la sesión del cuaderno (por ejemplo, con %pip install) se empaquetan durante el registro y se restauran durante el servicio.

En conjunto, esto significa que un modelo que se ejecuta en su cuaderno sigue funcionando cuando se sirve.

Paso 1: Configura un notebook serverless con GPU

Cree un cuaderno en un proceso de GPU sin servidor con una GPU A10 y seleccione la versión 5 del entorno, el entorno de IA. El entorno de inteligencia artificial incluye PyTorch y bibliotecas de aprendizaje automático comunes (torch, transformersy otras). Para conocer las versiones fijadas exactas, consulte Entorno de GPU sin servidor, versión 5 (Versión preliminar).

Instale los paquetes que requiere la implementación rápida:

# Express deployment requires recent MLflow and Databricks SDK versions.
%pip install "mlflow>=3.12" "databricks-sdk>=0.102.0"
# Install the libraries your model needs. transformers is preinstalled in the
# v5 AI environment; install it explicitly because this model depends on it.
%pip install transformers
%restart_python

También puede declarar dependencias a través de un entorno sin servidor, pero la instalación en el cuaderno es la ruta de acceso más sencilla. Desarrolla utilizando las versiones fijadas del entorno, de modo que el entorno del cuaderno coincida con el entorno de servicio.

Dado que este modelo se ejecuta en GPU, debes registrarlo desde un Integration Runtime de GPU sin servidor. Si, por error, realizas el registro desde un entorno de proceso sin servidor (serverless) basado en CPU, el modelo se empaqueta con dependencias de CPU y el punto de conexión de servicio de la GPU no se inicia. Añade la siguiente comprobación para que se detecte rápidamente el error si el cuaderno no se ejecuta en un entorno de GPU:

import os

# This model is intended to be served on GPU, so we must log and register from a Serverless GPU runtime.
if not os.environ.get("DATABRICKS_ACCELERATOR"):
    raise RuntimeError(
        "This model MUST be logged+registered from a serverless GPU runtime, otherwise the correct dependencies will not be packaged for serving."
    )

Note

Esta comprobación solo es necesaria porque el reclasificador se ejecuta en la GPU. Un modelo de CPU no lo necesita.

Paso 2: Registro del modelo con MLflow

Carga el reranker como un text-classification pipeline y regístralo con el mlflow.transformers flavor nativo. El formato nativo captura automáticamente las dependencias de pip del modelo y se ejecuta en la GPU. No es necesario establecer pip_requirements, un task o un punto de entrada.

import mlflow
from transformers import pipeline

# BAAI/bge-reranker-base is a cross-encoder reranker: it scores how well a document answers a query.
pipe = pipeline("text-classification", model="BAAI/bge-reranker-base")

model_info = mlflow.transformers.log_model(
    transformers_model=pipe,
    name="bge_reranker",
    input_example={
        "text": "What is Databricks?",
        "text_pair": "Databricks is a data and AI company.",
    },
)

Importante

No registre el modelo con el argumento registered_model_name de log_model. Ese argumento no acepta env_pack, por lo que registra un modelo no express. Para habilitar la implementación rápida, regístrese en un paso independiente con register_model (paso 3), que acepta env_pack.

Paso 3: Registrar el modelo en el catálogo de Unity con empaquetado rápido

Registre el modelo en El catálogo de Unity y establezca el env_pack parámetro para habilitar la implementación rápida. Esto empaqueta los artefactos del modelo y las dependencias que has añadido a la sesión del cuaderno durante el registro, de modo que el servicio los reutiliza además de las bibliotecas preinstaladas de la versión del entorno.

import mlflow
from mlflow.utils.env_pack import EnvPackConfig

mlflow.set_registry_uri("databricks-uc")

model_version = mlflow.register_model(
    model_uri=model_info.model_uri,
    name="main.default.bge_reranker",
    env_pack=EnvPackConfig(name="databricks_model_serving"),
)

Puede usar la cadena abreviada env_pack="databricks_model_serving" en lugar de EnvPackConfig(name="databricks_model_serving"). Para áreas de trabajo sin acceso a Internet o con bibliotecas personalizadas, establezca install_dependencies=False (consulte El env_pack parámetro ).

El registro requiere databricks-sdk>=0.102.0. Las versiones anteriores pueden agotar el tiempo de espera al cargar artefactos de modelo de gran tamaño.

Paso 4: Creación de un punto de conexión de servicio

Implemente el modelo registrado con el SDK de Azure Databricks. Este paso de implementación es el mismo que para cualquier modelo personalizado; solo el paso de registro (paso 3) difiere para express.

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import (
    EndpointCoreConfigInput,
    ServedEntityInput,
    ServingModelWorkloadType,
)

ENDPOINT_NAME = "bge-reranker-endpoint"

w = WorkspaceClient()
w.serving_endpoints.create_and_wait(
    name=ENDPOINT_NAME,
    config=EndpointCoreConfigInput(
        name=ENDPOINT_NAME,
        served_entities=[
            ServedEntityInput(
                name="bge-reranker",
                entity_name=model_version.name,
                entity_version=model_version.version,
                workload_type=ServingModelWorkloadType.GPU_SMALL,
                workload_size="Small",
                scale_to_zero_enabled=False,
            )
        ],
    ),
)

create_and_wait bloquea hasta que el punto de conexión esté listo. GPU_SMALL es suficiente para este reclassificador. Dado que la implementación reutiliza la misma versión del entorno y restaura las dependencias que añadió en el cuaderno, el modelo implementado se ejecuta con las mismas versiones de las bibliotecas con las que realizó el desarrollo, independientemente del tipo de GPU.

Mientras se despliega el punto de conexión, abra la pestaña Eventos del punto de conexión en la interfaz de usuario de Serving. Dado que se trata de un despliegue exprés, el registro de eventos no muestra eventos de creación de imágenes de contenedor (en un despliegue estándar se muestra Container image creation initiated seguido de Container image creation finished successfully). Cuando finaliza el punto de conexión, su estado muestra Listo.

Paso 5: Consultar el punto de conexión

Un codificador cruzado evalúa una consulta con respecto a un documento, por lo que debes enviar los campos text y text_pair. Haz consultas de forma programática con el SDK de Databricks o con curl.

SDK de Databricks

w.serving_endpoints.query(
    name=ENDPOINT_NAME,
    dataframe_records=[
        {"text": "What is Databricks?", "text_pair": "Databricks is a data and AI company."},
    ],
)

curl

curl -X POST \
  -u "token:$DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"dataframe_records":[{"text":"What is Databricks?","text_pair":"Databricks is a data and AI company."}]}' \
  https://<workspace-url>/serving-endpoints/bge-reranker-endpoint/invocations

El punto de conexión devuelve una puntuación de relevancia para cada par de documentos de consulta; las puntuaciones más altas indican una mejor coincidencia. Utilice estas puntuaciones para reordenar los documentos candidatos.

Cuaderno de ejemplo

Importe el siguiente cuaderno para ejecutar este tutorial de un extremo a otro.

Cuaderno de inicio del reclassificador Express

Obtener el portátil

Parámetro env_pack

En el inicio rápido anterior se muestra una implementación rápida para un modelo de GPU. Las implementaciones rápidas también funcionan para los modelos de CPU. En cada caso, habilitará la implementación rápida pasando env_pack a register_model:

import mlflow
from mlflow.utils.env_pack import EnvPackConfig

mlflow.register_model(
    model_info.model_uri,
    model_name,
    env_pack=EnvPackConfig(name="databricks_model_serving"),
)

env_pack empaqueta y prepara los artefactos del modelo y las dependencias que has añadido a la sesión del cuaderno en el momento del registro, por lo que el registro tarda más que una llamada sin env_pack.

EnvPackConfig acepta un install_dependencies parámetro (True de forma predeterminada). Cuando True, las dependencias del modelo se instalan en el entorno actual para confirmar que el entorno es válido.

Note

El registro puede producir un error en áreas de trabajo sin acceso a Internet o cuando el modelo depende de bibliotecas personalizadas, si install_dependencies es True. En estos casos, establezca install_dependencies en False.

Puede sustituir la cadena "databricks_model_serving" por EnvPackConfig(...) como abreviada. Es equivalente a EnvPackConfig(name="databricks_model_serving", install_dependencies=True).

  • Last updated on