Servicio optimizado de modelos de lenguaje grande (LLM)

Artículo
12/30/2024

Importante

Esta característica está en versión preliminar pública.

Importante

Los ejemplos de código de esta guía usan API en desuso. Databricks recomienda usar la experiencia de rendimiento aprovisionado para la inferencia optimizada de LLM. Consulte Migración de puntos de conexión de servicio de LLM optimizados a rendimiento aprovisionado.

En este artículo se muestra cómo habilitar optimizaciones para modelos de lenguaje grande (LLM) en Mosaic AI Model Serving.

El servicio LLM optimizado proporciona mejoras de rendimiento y latencia en el intervalo de 3 a 5 veces mejor en comparación con los enfoques de servicio tradicionales. En la tabla siguiente se resumen las familias de LLM admitidas y sus variantes.

Databricks recomienda instalar modelos fundacionales mediante Marketplace de Databricks. Busque una familia de modelos y, en la página del modelo, seleccione Obtener acceso y proporcione credenciales de inicio de sesión para instalar el modelo en el catálogo de Unity.

Familia de modelos	Instalar desde el marketplace
Llama 2	Modelos de Llama 2
MPT
Mistral	Modelos mistrales

Requisitos

El servicio LLM optimizado se admite como parte de la versión preliminar pública de las implementaciones de GPU.
El modelo debe registrarse con MLflow 2.4 y versiones posteriores o Databricks Runtime 13.2 ML y versiones posteriores.

Al implementar modelos, es esencial que el tamaño del parámetro del modelo coincida con el tamaño de proceso adecuado. Para modelos con 50 000 millones de parámetros o más, póngase en contacto con el equipo de la cuenta de Azure Databricks para acceder a las GPU necesarias.

Tamaño del parámetro del modelo	Tamaño de proceso recomendado	Tipo de carga de trabajo
7 mil millones	1xA100	`GPU_LARGE`
13 mil millones	1xA100	`GPU_LARGE`
30-34 mil millones	1xA100	`GPU_LARGE`
70 mil millones	2xA100	`GPU_LARGE_2`

Registro del modelo de lenguaje grande

En primer lugar, registre el modelo con el tipo MLflow transformers y especifique el campo de tarea en los metadatos de MLflow con metadata = {"task": "llm/v1/completions"}. Esto especifica la firma de API que se usa para el punto de conexión de servicio del modelo.

El servicio LLM optimizado es compatible con los tipos de ruta admitidos por Azure Databricks AI Gateway; actualmente, llm/v1/completions. Si hay una familia de modelos o un tipo de tarea que desea atender y que no es compatible, póngase en contacto con el equipo de la cuenta de Azure Databricks.

model = AutoModelForCausalLM.from_pretrained("mosaicml/mpt-7b-instruct",torch_dtype=torch.bfloat16, trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("mosaicml/mpt-7b-instruct")
with mlflow.start_run():
    components = {
        "model": model,
        "tokenizer": tokenizer,
    }
    mlflow.transformers.log_model(
        artifact_path="model",
        transformers_model=components,
        input_example=["Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\nWhat is Apache Spark?\n\n### Response:\n"],
        metadata={"task": "llm/v1/completions"},
        registered_model_name='mpt'
    )

Una vez registrado el modelo, puede registrar los modelos en Unity Catalog con lo siguiente, donde reemplace CATALOG.SCHEMA.MODEL_NAME por el nombre de tres niveles del modelo.


mlflow.set_registry_uri("databricks-uc")

registered_model_name=CATALOG.SCHEMA.MODEL_NAME

Creación del punto de conexión de servicio del modelo

A continuación, cree el punto de conexión de servicio del modelo. Si el modelo fuera compatible con el servicio optimizado para LLM, Azure Databricks creará automáticamente un punto de conexión de servicio de modelo optimizado al intentar servirlo.

import requests
import json

# Set the name of the MLflow endpoint
endpoint_name = "llama2-3b-chat"

# Name of the registered MLflow model
model_name = "ml.llm-catalog.llama-13b"

# Get the latest version of the MLflow model
model_version = 3

# Specify the type of compute (CPU, GPU_SMALL, GPU_LARGE, etc.)
workload_type = "GPU_LARGE"

# Specify the scale-out size of compute (Small, Medium, Large, etc.)
workload_size = "Small"

# Specify Scale to Zero (only supported for CPU endpoints)
scale_to_zero = False

# Get the API endpoint and token for the current notebook context
API_ROOT = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiUrl().get()
API_TOKEN = dbutils.notebook.entry_point.getDbutils().notebook().getContext().apiToken().get()

# send the POST request to create the serving endpoint

data = {
    "name": endpoint_name,
    "config": {
        "served_models": [
            {
                "model_name": model_name,
                "model_version": model_version,
                "workload_size": workload_size,
                "scale_to_zero_enabled": scale_to_zero,
                "workload_type": workload_type,
            }
        ]
    },
}

headers = {"Context-Type": "text/json", "Authorization": f"Bearer {API_TOKEN}"}

response = requests.post(
    url=f"{API_ROOT}/api/2.0/serving-endpoints", json=data, headers=headers
)

print(json.dumps(response.json(), indent=4))

Formato de esquema de entrada y salida

Un punto de conexión de servicio LLM optimizado tiene esquemas de entrada y salida que Azure Databricks controla. Se admiten cuatro formatos diferentes.

dataframe_split es el Dataframe de Pandas serializado con JSON en la orientación split.


{
  "dataframe_split":{
    "columns":["prompt"],
    "index":[0],
    "data":[["Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"]]
  },
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1","word2"],
    "candidate_count": 1
  }
}

dataframe_records es el Dataframe de Pandas serializado con JSON en la orientación records.

{
  "dataframe_records": [{"prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"}],
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1","word2"],
    "candidate_count": 1
  }
}

instances

{
  "instances": [
   {
     "prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
   }
  ],
  "params": {
  "temperature": 0.5,
  "max_tokens": 100,
  "stop": ["word1","word2"],
  "candidate_count": 1
  }
}

inputs


{
  "inputs": {
    "prompt": "Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instructions:\nWhat is Apache Spark?\n\n### Response:\n"
  },
  "params": {
    "temperature": 0.5,
    "max_tokens": 100,
    "stop": ["word1","word2"],
    "candidate_count": 1
  }
}

Consultar el punto de conexión

Una vez que el punto de conexión esté listo, puede consultarlo realizando una solicitud de API. Según el tamaño y la complejidad del modelo, el punto de conexión puede tardar 30 minutos o más en prepararse.


data = {
    "inputs": {
        "prompt": [
            "Hello, I'm a language model,"
        ]
    },
    "params": {
        "max_tokens": 100,
        "temperature": 0.0
    }
}

headers = {"Context-Type": "text/json", "Authorization": f"Bearer {API_TOKEN}"}

response = requests.post(
    url=f"{API_ROOT}/serving-endpoints/{endpoint_name}/invocations", json=data, headers=headers
)

print(json.dumps(response.json()))

Limitaciones

Teniendo en cuenta el aumento de los requisitos de instalación para los modelos servidos en la GPU, la creación de imágenes de contenedor para el servicio de GPU lleva más tiempo que la creación de imágenes para el servicio de CPU.
- El tamaño del modelo también afecta a la creación de imágenes. Por ejemplo, los modelos que tienen 30 mil millones de parámetros o más pueden tardar al menos una hora en compilarse.
- Databricks reutiliza el mismo contenedor la próxima vez que se implemente la misma versión del modelo, por lo que las implementaciones posteriores tardarán menos tiempo.
El escalado automático para el servicio de GPU tarda más tiempo que el servicio de CPU, debido a un mayor tiempo de configuración para los modelos servidos en el proceso de GPU. Databricks recomienda sobreaprovisionar para evitar el tiempo de espera de las solicitudes.

Compartir a través de