Servicio de vLLM para modelos de lenguaje de solo texto y multimodales en GPUs de Cloud

Resumen

En este tutorial se explica el proceso de desplegar y servir modelos Llama 3.1 y 3.2 con vLLM en Vertex AI. Se ha diseñado para usarse junto con dos cuadernos independientes: Serve Llama 3.1 with vLLM para implementar modelos Llama 3.1 solo de texto y Serve Multimodal Llama 3.2 with vLLM para implementar modelos Llama 3.2 multimodales que gestionan entradas de texto e imagen. En los pasos que se describen en esta página se muestra cómo gestionar de forma eficiente la inferencia de modelos en GPUs y cómo personalizar modelos para diversas aplicaciones, lo que te proporcionará las herramientas necesarias para integrar modelos de lenguaje avanzados en tus proyectos.

Al final de esta guía, sabrás cómo hacer lo siguiente:

  • Descarga modelos Llama prediseñados de Hugging Face con el contenedor vLLM.
  • Usa vLLM para desplegar estos modelos en instancias de GPU en Google Cloud Vertex AI Model Garden.
  • Sirve modelos de forma eficiente para gestionar solicitudes de inferencia a gran escala.
  • Ejecuta inferencias en solicitudes de solo texto y en solicitudes de texto e imagen.
  • Limpieza.
  • Depurar la implementación.

Características principales de vLLM

Función Descripción
PagedAttention Un mecanismo de atención optimizado que gestiona la memoria de forma eficiente durante la inferencia. Admite la generación de texto de alto rendimiento asignando dinámicamente recursos de memoria, lo que permite escalar varias solicitudes simultáneas.
Creación de lotes continua Consolida varias solicitudes de entrada en un solo lote para procesarlas en paralelo, lo que maximiza la utilización de la GPU y el rendimiento.
Streaming de tokens Habilita la salida de tokens en tiempo real durante la generación de texto. Ideal para aplicaciones que requieren baja latencia, como chatbots o sistemas de IA interactivos.
Compatibilidad de modelos Admite una amplia gama de modelos preentrenados en frameworks populares, como Hugging Face Transformers. Facilita la integración y la experimentación con diferentes LLMs.
Multi-GPU y multi-host Permite ofrecer modelos de forma eficiente distribuyendo la carga de trabajo entre varias GPUs de una misma máquina y entre varias máquinas de un clúster, lo que aumenta significativamente el rendimiento y la escalabilidad.
Implementación eficiente Ofrece una integración perfecta con APIs, como las de finalización de chat de OpenAI, lo que facilita la implementación en casos prácticos de producción.
Integración perfecta con los modelos de Hugging Face vLLM es compatible con el formato de artefactos de modelos de Hugging Face y admite la carga desde HF, lo que facilita la implementación de modelos Llama junto con otros modelos populares, como Gemma, Phi y Qwen, en un entorno optimizado.
Proyecto de código abierto impulsado por la comunidad vLLM es de código abierto y fomenta las contribuciones de la comunidad, lo que promueve la mejora continua de la eficiencia del servicio de LLMs.

Tabla 1: Resumen de las funciones de vLLM

Personalizaciones de vLLM de Google Vertex AI: mejora el rendimiento y la integración

La implementación de vLLM en Google Vertex AI Model Garden no es una integración directa de la biblioteca de código abierto. Vertex AI mantiene una versión personalizada y optimizada de vLLM que se ha diseñado específicamente para mejorar el rendimiento, la fiabilidad y la integración perfecta en Google Cloud.

  • Optimizaciones del rendimiento:
    • Descarga paralela desde Cloud Storage: acelera significativamente los tiempos de carga e implementación de modelos al permitir la recuperación paralela de datos desde Cloud Storage, lo que reduce la latencia y mejora la velocidad de inicio.
  • Mejoras de las funciones:
    • LoRA dinámica con almacenamiento en caché mejorado y compatibilidad con Cloud Storage: amplía las funciones de LoRA dinámica con mecanismos de almacenamiento en caché en disco local y una gestión de errores sólida, además de la compatibilidad con la carga de pesos de LoRA directamente desde rutas de Cloud Storage y URLs firmadas. Esto simplifica la gestión y la implementación de modelos personalizados.
    • Análisis de llamadas de función de Llama 3.1 y 3.2: implementa un análisis especializado para las llamadas de función de Llama 3.1 y 3.2, lo que mejora la solidez del análisis.
    • Almacenamiento en caché de prefijos de memoria del host: el vLLM externo solo admite el almacenamiento en caché de prefijos de memoria de la GPU.
    • Decodificación especulativa: esta es una función de vLLM, pero Vertex AI ha realizado experimentos para encontrar configuraciones de modelos de alto rendimiento.

Estas personalizaciones específicas de Vertex AI, aunque a menudo son transparentes para el usuario final, te permiten maximizar el rendimiento y la eficiencia de tus implementaciones de Llama 3.1 en Model Garden de Vertex AI.

  • Integración del ecosistema de Vertex AI:
    • Compatibilidad con los formatos de entrada y salida de predicciones de Vertex AI: garantiza una compatibilidad perfecta con los formatos de entrada y salida de predicciones de Vertex AI, lo que simplifica la gestión de datos y la integración con otros servicios de Vertex AI.
    • Conocimiento de las variables de entorno de Vertex: respeta y aprovecha las variables de entorno de Vertex AI (AIP_*) para la configuración y la gestión de recursos, lo que agiliza la implementación y garantiza un comportamiento coherente en el entorno de Vertex AI.
    • Gestión de errores y solidez mejoradas: implementa mecanismos integrales de gestión de errores, validación de entrada/salida y finalización del servidor para garantizar la estabilidad, la fiabilidad y el funcionamiento fluido en el entorno de Vertex AI gestionado.
    • Servidor Nginx para la función: integra un servidor Nginx en el servidor vLLM, lo que facilita el despliegue de varias réplicas y mejora la escalabilidad y la alta disponibilidad de la infraestructura de servicio.

Ventajas adicionales de vLLM

  • Rendimiento de las pruebas comparativas: vLLM ofrece un rendimiento competitivo en comparación con otros sistemas de servicio, como text-generation-inference de Hugging Face y FasterTransformer de NVIDIA, en términos de rendimiento y latencia.
  • Facilidad de uso: la biblioteca proporciona una API sencilla para la integración con flujos de trabajo actuales, lo que te permite implementar los modelos Llama 3.1 y 3.2 con una configuración mínima.
  • Funciones avanzadas: vLLM admite la transmisión de resultados (generación de respuestas token a token) y gestiona de forma eficiente las peticiones de longitud variable, lo que mejora la interactividad y la capacidad de respuesta de las aplicaciones.

Para obtener una descripción general del sistema vLLM, consulta el artículo.

Modelos admitidos

vLLM ofrece compatibilidad con una amplia selección de modelos de vanguardia, lo que te permite elegir el que mejor se adapte a tus necesidades. En la tabla siguiente se ofrece una selección de estos modelos. Sin embargo, para acceder a una lista completa de modelos compatibles, incluidos los de inferencia multimodal y solo de texto, puedes consultar el sitio web oficial de vLLM.

Categoría Modelos
Meta AI Llama 3.3, Llama 3.2, Llama 3.1, Llama 3, Llama 2 y Code Llama
Mistral AI Mistral 7B, Mixtral 8x7B, Mixtral 8x22B y sus variantes (Instruct y Chat), Mistral-tiny, Mistral-small y Mistral-medium
DeepSeek AI DeepSeek-V3, DeepSeek-R1, DeepSeek-R1-Distill-Qwen-1.5B, DeepSeek-R1-Distill-Qwen-7B, DeepSeek-R1-Distill-Llama-8B, DeepSeek-R1-Distill-Qwen-14B, DeepSeek-R1-Distill-Qwen-32B, DeepSeek-R1-Distill-Llama-70B, Deepseek-vl2-tiny, Deepseek-vl2-small, Deepseek-vl2
MosaicML MPT (7B, 30B) y variantes (Instruct, Chat), MPT-7B-StoryWriter-65k
OpenAI GPT-2, GPT-3, GPT-4 y GPT-NeoX
Together AI RedPajama, Pythia
Stability AI StableLM (3B, 7B), StableLM-Alpha-3B, StableLM-Base-Alpha-7B, StableLM-Instruct-Alpha-7B
TII (Technology Innovation Institute) Falcon 7B, Falcon 40B y variantes (Instruct, Chat), Falcon-RW-1B y Falcon-RW-7B
BigScience BLOOM, BLOOMZ
Google FLAN-T5, UL2, Gemma (2B, 7B) y PaLM 2
Salesforce CodeT5 y CodeT5+
LightOn Persimmon-8B-base, Persimmon-8B-chat
EleutherAI GPT-Neo y Pythia
AI21 Labs Jamba
Cerebras Cerebras-GPT
Intel Intel-NeuralChat-7B
Otros modelos destacados StarCoder, OPT, Baichuan, Aquila, Qwen, InternLM, XGen, OpenLLaMA, Phi-2, Yi, OpenCodeInterpreter, Nous-Hermes, Gemma-it, Mistral-Instruct-v0.2-7B-Zeus,

Tabla 2: Algunos modelos compatibles con vLLM

Empezar a usar Model Garden

El contenedor de servicio de GPUs de vLLM Cloud está integrado en Model Garden, el entorno de pruebas, la implementación con un solo clic y los ejemplos de cuadernos de Colab Enterprise. En este tutorial, nos centraremos en la familia de modelos Llama de Meta AI como ejemplo.

Usar el cuaderno de Colab Enterprise

También puedes usar Playground y las implementaciones con un solo clic, pero no se describen en este tutorial.

  1. Ve a la página de la tarjeta de modelo y haz clic en Abrir cuaderno.
  2. Selecciona el cuaderno Vertex Serving. El cuaderno se abrirá en Colab Enterprise.
  3. Sigue los pasos del cuaderno para desplegar un modelo con vLLM y enviar solicitudes de predicción al endpoint.

Configuración y requisitos

En esta sección se describen los pasos necesarios para configurar tu proyecto de Google Cloudy asegurarte de que tienes los recursos necesarios para desplegar y usar modelos vLLM.

1. Facturación

2. Disponibilidad y cuotas de GPUs

Tipo de máquina Tipo de acelerador Regiones recomendadas
a2-ultragpu-1g 1 NVIDIA_A100_80GB us-central1, us-east4, europe-west4 y asia-southeast1
a3-highgpu-8g 8 NVIDIA_H100_80GB us-central1, us-west1, europe-west4, asia-southeast1

3. Configurar un Google Cloud proyecto

Ejecuta el siguiente código de ejemplo para asegurarte de que tu entorno está configurado correctamente. Google Cloud En este paso se instalan las bibliotecas de Python necesarias y se configura el acceso a los recursos de Google Cloud . Entre las acciones se incluyen las siguientes:

  • Instalación: actualiza la biblioteca google-cloud-aiplatform y clona el repositorio que contiene las funciones de utilidad.
  • Configuración del entorno: define variables para el ID del proyecto Google Cloud , la región y un segmento de Cloud Storage único para almacenar artefactos del modelo.
  • Activación de APIs: habilita las APIs de Vertex AI y Compute Engine, que son esenciales para desplegar y gestionar modelos de IA.
  • Configuración del segmento: crea un segmento de Cloud Storage o comprueba uno que ya tengas para asegurarte de que está en la región correcta.
  • Inicialización de Vertex AI: inicializa la biblioteca de cliente de Vertex AI con los ajustes de proyecto, ubicación y bucket de almacenamiento provisional.
  • Configuración de la cuenta de servicio: identifica la cuenta de servicio predeterminada para ejecutar trabajos de Vertex AI y concédele los permisos necesarios.
BUCKET_URI = "gs://"

REGION = ""

! pip3 install --upgrade --quiet 'google-cloud-aiplatform>=1.64.0'
! git clone https://github.com/GoogleCloudPlatform/vertex-ai-samples.git

import datetime
import importlib
import os
import uuid
from typing import Tuple

import requests
from google.cloud import aiplatform

common_util = importlib.import_module(
    "vertex-ai-samples.community-content.vertex_model_garden.model_oss.notebook_util.common_util"
)

models, endpoints = {}, {}

PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT"]

if not REGION:
    REGION = os.environ["GOOGLE_CLOUD_REGION"]

print("Enabling Vertex AI API and Compute Engine API.")
! gcloud services enable aiplatform.googleapis.com compute.googleapis.com

now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])

if BUCKET_URI is None or BUCKET_URI.strip() == "" or BUCKET_URI == "gs://":
    BUCKET_URI = f"gs://{PROJECT_ID}-tmp-{now}-{str(uuid.uuid4())[:4]}"
    BUCKET_NAME = "/".join(BUCKET_URI.split("/")[:3])
    ! gsutil mb -l {REGION} {BUCKET_URI}
else:
    assert BUCKET_URI.startswith("gs://"), "BUCKET_URI must start with `gs://`."
    shell_output = ! gsutil ls -Lb {BUCKET_NAME} | grep "Location constraint:" | sed "s/Location constraint://"
    bucket_region = shell_output[0].strip().lower()
    if bucket_region != REGION:
        raise ValueError(
            "Bucket region %s is different from notebook region %s"
            % (bucket_region, REGION)
        )
print(f"Using this Bucket: {BUCKET_URI}")

STAGING_BUCKET = os.path.join(BUCKET_URI, "temporal")
MODEL_BUCKET = os.path.join(BUCKET_URI, "llama3_1")

print("Initializing Vertex AI API.")
aiplatform.init(project=PROJECT_ID, location=REGION, staging_bucket=STAGING_BUCKET)

shell_output = ! gcloud projects describe $PROJECT_ID
project_number = shell_output[-1].split(":")[1].strip().replace("'", "")
SERVICE_ACCOUNT = "your service account email"
print("Using this default Service Account:", SERVICE_ACCOUNT)

! gsutil iam ch serviceAccount:{SERVICE_ACCOUNT}:roles/storage.admin $BUCKET_NAME

! gcloud config set project $PROJECT_ID
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/storage.admin"
! gcloud projects add-iam-policy-binding --no-user-output-enabled {PROJECT_ID} --member=serviceAccount:{SERVICE_ACCOUNT} --role="roles/aiplatform.user"

Usar Hugging Face con Meta Llama 3.1, 3.2 y vLLM

Las colecciones Llama 3.1 y 3.2 de Meta ofrecen una gama de modelos de lenguaje extensos (LLMs) multilingües diseñados para generar texto de alta calidad en varios casos prácticos. Estos modelos están preentrenados y ajustados mediante instrucciones, por lo que destacan en tareas como el diálogo multilingüe, la creación de resúmenes y la recuperación de información por parte de agentes. Antes de usar los modelos Llama 3.1 y 3.2, debes aceptar sus términos de uso, tal como se muestra en la captura de pantalla. La biblioteca vLLM ofrece un entorno de servicio optimizado de código abierto con optimizaciones para la latencia, la eficiencia de la memoria y la escalabilidad.

Contrato de licencia de la comunidad de Meta Llama 3 Imagen 1: Acuerdo de licencia de la comunidad de Meta Llama 3

Descripción general de las colecciones Llama 3.1 y 3.2 de Meta

Las colecciones Llama 3.1 y 3.2 se adaptan a diferentes escalas de implementación y tamaños de modelo, lo que te ofrece opciones flexibles para tareas de diálogo multilingüe y más. Consulta la página de resumen de Llama para obtener más información.

  • Solo texto: la colección Llama 3.2 de modelos de lenguaje extensos (LLMs) multilingües es una colección de modelos generativos preentrenados y ajustados con instrucciones de 1000 y 3000 millones de parámetros (texto de entrada y texto de salida).
  • Vision y Vision Instruct: la colección Llama 3.2-Vision de modelos de lenguaje extensos (LLMs) multimodales es un conjunto de modelos generativos de razonamiento de imágenes preentrenados y ajustados mediante instrucciones de 11 y 90 mil millones de parámetros (texto e imágenes de entrada y texto de salida). Optimización: al igual que Llama 3.1, los modelos 3.2 se han diseñado para el diálogo multilingüe y ofrecen un buen rendimiento en tareas de recuperación y resumen, con lo que consiguen los mejores resultados en las comparativas estándar.
  • Arquitectura del modelo: Llama 3.2 también incluye un framework de transformador autorregresivo, con SFT y RLHF aplicados para alinear los modelos con el objetivo de que sean útiles y seguros.

Tokens de acceso de usuario de Hugging Face

Para seguir este tutorial, necesitas un token de acceso de lectura del Hugging Face Hub para acceder a los recursos necesarios. Sigue estos pasos para configurar la autenticación:

Ajustes del token de acceso de Hugging Face Imagen 2: Configuración del token de acceso de Hugging Face

  1. Genera un token de acceso de lectura:

  2. Usar el token:

    • Usa el token generado para autenticarte y acceder a repositorios públicos o privados según sea necesario para el tutorial.
Gestionar el token de acceso de Hugging Face Imagen 3: Gestión del token de acceso de Hugging Face

De esta forma, te aseguras de tener el nivel de acceso adecuado sin permisos innecesarios. Estas prácticas mejoran la seguridad y evitan que los tokens se expongan accidentalmente. Para obtener más información sobre cómo configurar tokens de acceso, visita la página de tokens de acceso de Hugging Face.

No compartas ni expongas tu token públicamente ni online. Si defines tu token como variable de entorno durante la implementación, seguirá siendo privado para tu proyecto. Vertex AI garantiza su seguridad impidiendo que otros usuarios accedan a tus modelos y endpoints.

Para obtener más información sobre cómo proteger tu token de acceso, consulta las prácticas recomendadas para tokens de acceso de Hugging Face.

Desplegar modelos Llama 3.1 de solo texto con vLLM

Para desplegar modelos de lenguaje extensos a nivel de producción, vLLM ofrece una solución de servicio eficiente que optimiza el uso de la memoria, reduce la latencia y aumenta el rendimiento. Por eso, es especialmente adecuada para gestionar los modelos Llama 3.1 más grandes, así como los modelos multimodales Llama 3.2.

Paso 1: Elige un modelo para desplegar

Elige la variante del modelo Llama 3.1 que quieras implementar. Entre las opciones disponibles se incluyen varios tamaños y versiones ajustadas para seguir instrucciones:

base_model_name = "Meta-Llama-3.1-8B"  # @param ["Meta-Llama-3.1-8B", "Meta-Llama-3.1-8B-Instruct", "Meta-Llama-3.1-70B", "Meta-Llama-3.1-70B-Instruct", "Meta-Llama-3.1-405B-FP8", "Meta-Llama-3.1-405B-Instruct-FP8"]
hf_model_id = "meta-Llama/" + base_model_name

Paso 2: Comprueba el hardware y la cuota de la implementación

La función de implementación define el tipo de GPU y de máquina adecuados en función del tamaño del modelo y comprueba la cuota de ese proyecto en esa región:

if "8b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-12"
    accelerator_count = 1
elif "70b" in base_model_name.lower():
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-96"
    accelerator_count = 8
elif "405b" in base_model_name.lower():
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

Verifica la disponibilidad de la cuota de GPU en la región especificada:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Paso 3: Inspecciona el modelo con vLLM

La función siguiente sube el modelo a Vertex AI, configura los ajustes de implementación y lo implementa en un endpoint mediante vLLM.

  1. Imagen Docker: el despliegue usa una imagen Docker de vLLM prediseñada para ofrecer un servicio eficiente.
  2. Configuración: configura el uso de la memoria, la longitud del modelo y otros ajustes de vLLM. Para obtener más información sobre los argumentos admitidos por el servidor, visita la página oficial de documentación de vLLM.
  3. Variables de entorno: define variables de entorno para la autenticación y la fuente de implementación.
def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 256,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if "8b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-12"
        accelerator_count = 1
    elif "70b" in base_model_name.lower():
        accelerator_type = "NVIDIA_L4"
        machine_type = "g2-standard-96"
        accelerator_count = 8
    elif "405b" in base_model_name.lower():
        accelerator_type = "NVIDIA_H100_80GB"
        machine_type = "a3-highgpu-8g"
        accelerator_count = 8
    else:
        raise ValueError(f"Recommended GPU setting not found for: {accelerator_type} and {base_model_name}.")

    common_util.check_quota(
        project_id=PROJECT_ID,
        region=REGION,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        is_for_training=False,
    )

    vllm_args = [
        "python", "-m", "vllm.entrypoints.api_server",
        "--host=0.0.0.0",
        "--port=8080",
        f"--model={model_id}",
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}", f"--dtype={dtype}",
        f"--max-loras={max_loras}", f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}", "--disable-log-stats"
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": model_id,
        "DEPLOY_SOURCE": "notebook",
        "HF_TOKEN": HF_TOKEN
    }

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Paso 4: Ejecutar el despliegue

Ejecuta la función de implementación con el modelo y la configuración seleccionados. En este paso se despliega el modelo y se devuelven las instancias del modelo y del endpoint:

HF_TOKEN = ""

VLLM_DOCKER_URI = "us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241001_0916_RC00"

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
gpu_memory_utilization = 0.9
max_model_len = 4096
max_loras = 1

models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve"),
    model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    max_loras=max_loras,
    enforce_eager=True,
    enable_lora=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
)

Después de ejecutar este código de ejemplo, tu modelo Llama 3.1 se desplegará en Vertex AI y se podrá acceder a él a través del endpoint especificado. Puedes interactuar con él para realizar tareas de inferencia, como generar texto, resumir y mantener conversaciones. En función del tamaño del modelo, la implementación de un modelo nuevo puede tardar hasta una hora. Puedes consultar el progreso en la predicción online.

Endpoint de implementación de Llama 3.1 en el panel de Vertex Imagen 4: Endpoint de implementación de Llama 3.1 en el panel de control de Vertex

Hacer predicciones con Llama 3.1 en Vertex AI

Una vez que hayas desplegado correctamente el modelo Llama 3.1 en Vertex AI, puedes empezar a hacer predicciones enviando peticiones de texto al endpoint. En esta sección se ofrece un ejemplo de cómo generar respuestas con varios parámetros personalizables para controlar el resultado.

Paso 1: Define la petición y los parámetros

Empieza configurando tu petición de texto y los parámetros de muestreo para guiar la respuesta del modelo. Estos son los parámetros clave:

  • prompt: el texto de entrada para el que quieres que el modelo genere una respuesta. Por ejemplo, prompt = "¿Qué es un coche?".
  • max_tokens: número máximo de tokens en la salida generada. Reducir este valor puede ayudar a evitar problemas de tiempo de espera.
  • temperature: controla la aleatoriedad de las predicciones. Los valores más altos (por ejemplo, 1,0) aumentan la diversidad, mientras que los valores más bajos (por ejemplo, 0,5) hacen que el resultado sea más específico.
  • top_p: limita el conjunto de muestreo a la probabilidad acumulada superior. Por ejemplo, si se define top_p = 0,9, solo se tendrán en cuenta los tokens que se encuentren en el 90 % superior de la masa de probabilidad.
  • top_k: limita el muestreo a los k tokens más probables. Por ejemplo, si se define top_k = 50, solo se tomarán muestras de los 50 tokens principales.
  • raw_response: si es True, devuelve la salida del modelo sin procesar. Si es False, aplica formato adicional con la estructura "Prompt:\n{prompt}\nOutput:\n{output}".
  • lora_id (opcional): ruta a los archivos de peso de LoRA para aplicar los pesos de adaptación de rango bajo (LoRA). Puede ser un segmento de Cloud Storage o una URL de repositorio de Hugging Face. Ten en cuenta que esto solo funciona si --enable-lora se ha definido en los argumentos de la implementación. No se admite LoRA dinámica en modelos multimodales.
prompt = "What is a car?"
max_tokens = 50
temperature = 1.0
top_p = 1.0
top_k = 1
raw_response = False
lora_id = ""

Paso 2: Enviar la solicitud de predicción

Ahora que la instancia está configurada, puedes enviar la solicitud de predicción al endpoint de Vertex AI desplegado. En este ejemplo se muestra cómo hacer una predicción e imprimir el resultado:

response = endpoints["vllm_gpu"].predict(
    instances=instances, use_dedicated_endpoint=use_dedicated_endpoint
)

for prediction in response.predictions:
    print(prediction)

Ejemplo

Este es un ejemplo de cómo podría responder el modelo a la petición "¿Qué es un coche?":

Human: What is a car?
Assistant: A car, or a motor car, is a road-connected human-transportation system
used to move people or goods from one place to another.

Notas adicionales

  • Moderación: para asegurarte de que el contenido es seguro, puedes moderar el texto generado con las funciones de moderación de texto de Vertex AI.
  • Gestionar los tiempos de espera: si tienes problemas como ServiceUnavailable: 503, prueba a reducir el parámetro max_tokens.

Este enfoque proporciona una forma flexible de interactuar con el modelo Llama 3.1 mediante diferentes técnicas de muestreo y adaptadores LoRA, lo que lo hace adecuado para una variedad de casos prácticos, desde la generación de texto de uso general hasta las respuestas específicas de tareas.

Desplegar modelos multimodales de Llama 3.2 con vLLM

En esta sección se explica el proceso para subir modelos Llama 3.2 precompilados al registro de modelos y desplegarlos en un endpoint de Vertex AI. El tiempo de implementación puede ser de hasta una hora, en función del tamaño del modelo. Los modelos Llama 3.2 están disponibles en versiones multimodales que admiten entradas de texto e imagen. vLLM admite lo siguiente:

  • Formato de solo texto
  • Formato de imagen única y texto

Estos formatos hacen que Llama 3.2 sea adecuado para aplicaciones que requieren procesamiento visual y de texto.

Paso 1: Elige un modelo para desplegar

Especifica la variante del modelo Llama 3.2 que quieras implementar. En el siguiente ejemplo, se usa Llama-3.2-11B-Vision como modelo seleccionado, pero puedes elegir entre otras opciones disponibles en función de tus requisitos.

base_model_name = "Llama-3.2-11B-Vision"  # @param ["Llama-3.2-1B", "Llama-3.2-1B-Instruct", "Llama-3.2-3B", "Llama-3.2-3B-Instruct", "Llama-3.2-11B-Vision", "Llama-3.2-11B-Vision-Instruct", "Llama-3.2-90B-Vision", "Llama-3.2-90B-Vision-Instruct"]
hf_model_id = "meta-Llama/" + base_model_name

Paso 2: Configurar el hardware y los recursos

Selecciona el hardware adecuado para el tamaño del modelo. vLLM puede usar diferentes GPUs en función de las necesidades computacionales del modelo:

  • Modelos 1B y 3B: usa GPUs NVIDIA L4.
  • Modelos de 11.000 millones de parámetros: usa GPUs NVIDIA A100.
  • Modelos de 90.000 millones de parámetros: usa GPUs NVIDIA H100.

En este ejemplo se configura la implementación en función de la selección del modelo:

if "3.2-1B" in base_model_name or "3.2-3B" in base_model_name:
    accelerator_type = "NVIDIA_L4"
    machine_type = "g2-standard-8"
    accelerator_count = 1
elif "3.2-11B" in base_model_name:
    accelerator_type = "NVIDIA_TESLA_A100"
    machine_type = "a2-highgpu-1g"
    accelerator_count = 1
elif "3.2-90B" in base_model_name:
    accelerator_type = "NVIDIA_H100_80GB"
    machine_type = "a3-highgpu-8g"
    accelerator_count = 8
else:
    raise ValueError(f"Recommended GPU setting not found for: {base_model_name}.")

Asegúrate de que tienes la cuota de GPU necesaria:

common_util.check_quota(
    project_id=PROJECT_ID,
    region=REGION,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    is_for_training=False,
)

Paso 3: Despliega el modelo con vLLM

La siguiente función gestiona el despliegue del modelo Llama 3.2 en Vertex AI. Configura el entorno, el uso de memoria y los ajustes de vLLM del modelo para que el servicio sea eficiente.

def deploy_model_vllm(
    model_name: str,
    model_id: str,
    service_account: str,
    base_model_id: str = None,
    machine_type: str = "g2-standard-8",
    accelerator_type: str = "NVIDIA_L4",
    accelerator_count: int = 1,
    gpu_memory_utilization: float = 0.9,
    max_model_len: int = 4096,
    dtype: str = "auto",
    enable_trust_remote_code: bool = False,
    enforce_eager: bool = False,
    enable_lora: bool = False,
    max_loras: int = 1,
    max_cpu_loras: int = 8,
    use_dedicated_endpoint: bool = False,
    max_num_seqs: int = 12,
    model_type: str = None,
) -> Tuple[aiplatform.Model, aiplatform.Endpoint]:
    """Deploys trained models with vLLM into Vertex AI."""
    endpoint = aiplatform.Endpoint.create(
        display_name=f"{model_name}-endpoint",
        dedicated_endpoint_enabled=use_dedicated_endpoint,
    )

    if not base_model_id:
        base_model_id = model_id

    vllm_args = [
        "python",
        "-m",
        "vllm.entrypoints.api_server",
        "--host=0.0.0.0",
        "--port=8080",
        f"--model={model_id}",
        f"--tensor-parallel-size={accelerator_count}",
        "--swap-space=16",
        f"--gpu-memory-utilization={gpu_memory_utilization}",
        f"--max-model-len={max_model_len}",
        f"--dtype={dtype}",
        f"--max-loras={max_loras}",
        f"--max-cpu-loras={max_cpu_loras}",
        f"--max-num-seqs={max_num_seqs}",
        "--disable-log-stats",
    ]

    if enable_trust_remote_code:
        vllm_args.append("--trust-remote-code")
    if enforce_eager:
        vllm_args.append("--enforce-eager")
    if enable_lora:
        vllm_args.append("--enable-lora")
    if model_type:
        vllm_args.append(f"--model-type={model_type}")

    env_vars = {
        "MODEL_ID": base_model_id,
        "DEPLOY_SOURCE": "notebook",
    }

    # HF_TOKEN is not a compulsory field and may not be defined.
    try:
        if HF_TOKEN:
            env_vars["HF_TOKEN"] = HF_TOKEN
    except NameError:
        pass

    model = aiplatform.Model.upload(
        display_name=model_name,
        serving_container_image_uri=VLLM_DOCKER_URI,
        serving_container_args=vllm_args,
        serving_container_ports=[8080],
        serving_container_predict_route="/generate",
        serving_container_health_route="/ping",
        serving_container_environment_variables=env_vars,
        serving_container_shared_memory_size_mb=(16 * 1024),
        serving_container_deployment_timeout=7200,
    )
    print(f"Deploying {model_name} on {machine_type} with {accelerator_count} {accelerator_type} GPU(s).")

    model.deploy(
        endpoint=endpoint,
        machine_type=machine_type,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        deploy_request_timeout=1800,
        service_account=service_account,
    )
    print("endpoint_name:", endpoint.name)

    return model, endpoint

Paso 4: Ejecutar el despliegue

Ejecuta la función de implementación con el modelo y los ajustes configurados. La función devolverá las instancias del modelo y del endpoint, que puedes usar para la inferencia.

model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
models["vllm_gpu"], endpoints["vllm_gpu"] = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type=machine_type,
    accelerator_type=accelerator_type,
    accelerator_count=accelerator_count,
    gpu_memory_utilization=gpu_memory_utilization,
    max_model_len=max_model_len,
    enforce_eager=True,
    use_dedicated_endpoint=use_dedicated_endpoint,
    max_num_seqs=max_num_seqs,
)
Endpoint de implementación de Llama 3.2 en el panel de control de Vertex Imagen 5: Endpoint de implementación de Llama 3.2 en el panel de control de Vertex

En función del tamaño del modelo, la implementación de un modelo nuevo puede tardar hasta una hora en completarse. Puedes consultar su progreso en la predicción online.

Inferencia con vLLM en Vertex AI mediante la ruta de predicción predeterminada

En esta sección se explica cómo configurar la inferencia del modelo Llama 3.2 Vision en Vertex AI mediante la ruta de predicción predeterminada. Usarás la biblioteca vLLM para ofrecer el servicio de forma eficiente e interactuar con el modelo enviando una petición visual combinada con texto.

Para empezar, asegúrate de que el punto de conexión de tu modelo esté desplegado y listo para las predicciones.

Paso 1: Define la petición y los parámetros

En este ejemplo se proporciona una URL de imagen y una petición de texto, que el modelo procesará para generar una respuesta.

Imagen de entrada de ejemplo para pedirle algo a Llama 3.2 Imagen 6: ejemplo de entrada de imagen para pedirle algo a Llama 3.2 
image_url = "https://images.pexels.com/photos/1254140/pexels-photo-1254140.jpeg"

raw_prompt = "This is a picture of"

# Reference prompt formatting guidelines here: https://www.Llama.com/docs/model-cards-and-prompt-formats/Llama3_2/#-base-model-prompt
prompt = f"<|begin_of_text|><|image|>{raw_prompt}"

Paso 2: Configurar los parámetros de predicción

Ajusta los siguientes parámetros para controlar la respuesta del modelo:

max_tokens = 64

temperature = 0.5

top_p = 0.95

Paso 3: Prepara la solicitud de predicción

Configura la solicitud de predicción con la URL de la imagen, la petición y otros parámetros.

instances = [
    {
        "prompt": prompt,
        "multi_modal_data": {"image": image_url},
        "max_tokens": max_tokens,
        "temperature": temperature,
        "top_p": top_p,
    },
]

Paso 4: Haz la predicción

Envía la solicitud a tu endpoint de Vertex AI y procesa la respuesta:

response = endpoints["vllm_gpu"].predict(instances=instances)

for raw_prediction in response.predictions:
    prediction = raw_prediction.split("Output:")
    print(prediction[1])

Si se produce un problema de tiempo de espera (por ejemplo, ServiceUnavailable: 503 Took too long to respond when processing), prueba a reducir el valor de max_tokens a un número inferior, como 20, para reducir el tiempo de respuesta.

Inferencia con vLLM en Vertex AI mediante la finalización de chat de OpenAI

En esta sección se explica cómo realizar inferencias en modelos de Llama 3.2 Vision con la API Chat Completions de OpenAI en Vertex AI. Este enfoque te permite usar las funciones multimodales enviando al modelo peticiones con imágenes y texto para obtener respuestas más interactivas.

Paso 1: Ejecuta el despliegue del modelo Llama 3.2 Vision Instruct

Ejecuta la función de implementación con el modelo y los ajustes configurados. La función devolverá las instancias del modelo y del endpoint, que puedes usar para la inferencia.

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
model_name = common_util.get_job_name_with_datetime(prefix=f"{base_model_name}-serve-vllm")
model, endpoint = deploy_model_vllm(
    model_name=model_name
    model_id=hf_model_id,
    base_model_id=hf_model_id,
    service_account=SERVICE_ACCOUNT,
    machine_type="a2-highgpu-1g",
    accelerator_type="NVIDIA_TESLA_A100",
    accelerator_count=1,
    gpu_memory_utilization=0.9,
    max_model_len=4096,
    enforce_eager=True,
    max_num_seqs=12,
)

Paso 2: Configurar el recurso de endpoint

Empieza configurando el nombre del recurso de endpoint de tu implementación de Vertex AI.

ENDPOINT_RESOURCE_NAME = "projects/{}/locations/{}/endpoints/{}".format(
    PROJECT_ID, REGION, endpoint.name
)

Paso 3: Instala el SDK de OpenAI y las bibliotecas de autenticación

Para enviar solicitudes mediante el SDK de OpenAI, asegúrate de que las bibliotecas necesarias estén instaladas:

!pip install -qU openai google-auth requests

Paso 4: Define los parámetros de entrada para la finalización de la conversación

Configura la URL de la imagen y la petición de texto que se enviarán al modelo. Ajusta max_tokens y temperature para controlar la longitud y la aleatoriedad de la respuesta, respectivamente.

user_image = "https://images.freeimages.com/images/large-previews/ab3/puppy-2-1404644.jpg"
user_message = "Describe this image?"
max_tokens = 50
temperature = 1.0

Paso 5: Configura la autenticación y la URL base

Obtén tus credenciales y define la URL base de las solicitudes a la API.

import google.auth
import openai

creds, project = google.auth.default()
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)

BASE_URL = (
    f"https://{REGION}-aiplatform.googleapis.com/v1beta1/{ENDPOINT_RESOURCE_NAME}"
)
try:
    if use_dedicated_endpoint:
        BASE_URL = f"https://{DEDICATED_ENDPOINT_DNS}/v1beta1/{ENDPOINT_RESOURCE_NAME}"
except NameError:
    pass

Paso 6: Envía una solicitud de finalización de chat

Con la API Chat Completions de OpenAI, envía la imagen y la petición de texto a tu endpoint de Vertex AI:

client = openai.OpenAI(base_url=BASE_URL, api_key=creds.token)

model_response = client.chat.completions.create(
    model="",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "image_url", "image_url": {"url": user_image}},
                {"type": "text", "text": user_message},
            ],
        }
    ],
    temperature=temperature,
    max_tokens=max_tokens,
)

print(model_response)

(Opcional) Paso 7: Volver a conectar con un endpoint

Para volver a conectarte a un endpoint creado anteriormente, usa el ID del endpoint. Este paso es útil si quieres reutilizar un endpoint en lugar de crear uno nuevo.

endpoint_name = ""
aip_endpoint_name = (
     f"projects/{PROJECT_ID}/locations/{REGION}/endpoints/{endpoint_name}"
)
endpoint = aiplatform.Endpoint(aip_endpoint_name)

Esta configuración ofrece flexibilidad para cambiar entre los endpoints recién creados y los que ya existen según sea necesario, lo que permite optimizar las pruebas y las implementaciones.

Limpieza

Para evitar que se te apliquen cargos y liberar recursos, elimina los modelos y los endpoints desplegados, así como el segmento de almacenamiento que has usado en este experimento (opcional).

Paso 1: Elimina los endpoints y los modelos

El siguiente código anulará la implementación de cada modelo y eliminará los endpoints asociados:

# Undeploy model and delete endpoint
for endpoint in endpoints.values():
    endpoint.delete(force=True)

# Delete models
for model in models.values():
    model.delete()

Paso 2: (Opcional) Elimina el segmento de Cloud Storage

Si has creado un segmento de Cloud Storage específicamente para este experimento, puedes eliminarlo asignando el valor True a delete_bucket. Este paso es opcional, pero se recomienda si ya no necesitas el contenedor.

delete_bucket = False
if delete_bucket:
    ! gsutil -m rm -r $BUCKET_NAME

Si sigues estos pasos, te asegurarás de que se eliminen todos los recursos utilizados en este tutorial, lo que reducirá los costes innecesarios asociados al experimento.

Depurar problemas habituales

En esta sección se ofrecen directrices para identificar y resolver problemas habituales que se producen durante la implementación y la inferencia de modelos vLLM en Vertex AI.

Consultar los registros

Consulta los registros para identificar la causa principal de los errores de implementación o del comportamiento inesperado:

  1. Ve a la consola de Vertex AI Prediction: ve a la consola de Vertex AI Prediction en la consola de Google Cloud .
  2. Selecciona el endpoint: haz clic en el endpoint que tenga problemas. El estado debe indicar si la implementación ha fallado.
  3. Ver registros: haz clic en el endpoint y, a continuación, ve a la pestaña Registros o haz clic en Ver registros. Se te redirigirá a Cloud Logging, filtrado para mostrar los registros específicos de ese endpoint y de ese despliegue del modelo. También puedes acceder a los registros directamente a través del servicio Cloud Logging.
  4. Analiza los registros: revisa las entradas de registro para ver si hay mensajes de error, advertencias y otra información relevante. Ver las marcas de tiempo para correlacionar las entradas de registro con acciones específicas. Busca problemas relacionados con las restricciones de recursos (memoria y CPU), problemas de autenticación o errores de configuración.

Problema habitual 1: falta de memoria (OOM) de CUDA durante la implementación

Los errores de falta de memoria (OOM) de CUDA se producen cuando el uso de memoria del modelo supera la capacidad de la GPU disponible.

En el caso del modelo de solo texto, hemos usado los siguientes argumentos del motor:

base_model_name = "Meta-Llama-3.1-8B"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 256

En el caso del modelo multimodal, hemos usado los siguientes argumentos del motor:

base_model_name = "Llama-3.2-11B-Vision-Instruct"
hf_model_id = f"meta-llama/{base_model_name}"
accelerator_type = "NVIDIA_L4"
accelerator_count = 1
machine_type = "g2-standard-12"
accelerator_count: int = 1
gpu_memory_utilization = 0.9
max_model_len = 4096
dtype = "auto"
max_num_seqs = 12

Si implementamos el modelo multimodal con max_num_seqs = 256, como hicimos en el caso del modelo de solo texto, podría producirse el siguiente error:

[rank0]: torch.OutOfMemoryError: CUDA out of memory. Tried to allocate 3.91 GiB. GPU 0 has a total capacity of 39.38 GiB of which 3.76 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 34.94 GiB is allocated by PyTorch, and 175.15 MiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)
Registro de errores de GPU por falta de memoria Imagen 7: registro de errores de GPU por falta de memoria (OOM)

Información sobre max_num_seqs y la memoria de la GPU:

  • El parámetro max_num_seqs define el número máximo de solicitudes simultáneas que puede gestionar el modelo.
  • Cada secuencia procesada por el modelo consume memoria de GPU. El uso total de memoria es proporcional a max_num_seqs veces la memoria por secuencia.
  • Los modelos de solo texto (como Meta-Llama-3.1-8B) suelen consumir menos memoria por secuencia que los modelos multimodales (como Llama-3.2-11B-Vision-Instruct), que procesan tanto texto como imágenes.

Revisa el registro de errores (imagen 8):

  • El registro muestra un torch.OutOfMemoryError al intentar asignar memoria en la GPU.
  • El error se produce porque el uso de memoria del modelo supera la capacidad de la GPU disponible. La GPU NVIDIA L4 tiene 24 GB y, si se asigna un valor demasiado alto al parámetro max_num_seqs para el modelo multimodal, se produce un desbordamiento.
  • El registro sugiere definir PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True para mejorar la gestión de la memoria, aunque el problema principal es el alto uso de memoria.
Mensaje de error que indica que no se ha podido implementar Llama 3.2 Imagen 8: Despliegue fallido de Llama 3.2
Panel de detalles de la versión del modelo Imagen 9: panel de detalles de la versión del modelo

Para solucionar este problema, vaya a la consola de Vertex AI Prediction y haga clic en el endpoint. El estado debe indicar que la implementación ha fallado. Haz clic para ver los registros. Verifica que max-num-seqs = 256. Este valor es demasiado alto para Llama-3.2-11B-Vision-Instruct. Un valor más adecuado sería 12.

Problema habitual 2: se necesita un token de Hugging Face

Los errores de token de Hugging Face se producen cuando el modelo está protegido y requiere credenciales de autenticación adecuadas para acceder a él.

En la siguiente captura de pantalla se muestra una entrada de registro de Log Explorer de Google Cloud en la que se muestra un mensaje de error relacionado con el acceso al modelo Meta LLaMA-3.2-11B-Vision alojado en Hugging Face. El error indica que el acceso al modelo está restringido y que se requiere autenticación para continuar. El mensaje indica específicamente que no se puede acceder al repositorio protegido de la URL, lo que destaca que el modelo está protegido y requiere las credenciales de autenticación adecuadas para acceder. Esta entrada de registro puede ayudar a solucionar problemas de autenticación al trabajar con recursos restringidos en repositorios externos.

Mensaje de error que indica que se necesita un token de Hugging Face para acceder al modelo Imagen 10: error de token de Hugging Face

Para solucionar este problema, verifica los permisos de tu token de acceso de Hugging Face. Copia el token más reciente e implementa un nuevo endpoint.

Problema habitual 3: Se necesita una plantilla de chat

Los errores de plantilla de chat se producen cuando ya no se permite la plantilla de chat predeterminada y se debe proporcionar una plantilla de chat personalizada si el tokenizador no define ninguna.

En esta captura de pantalla se muestra una entrada de registro en el explorador de registros de Google Cloud, donde se produce un error ValueError debido a que falta una plantilla de chat en la versión 4.44 de la biblioteca transformers. El mensaje de error indica que la plantilla de chat predeterminada ya no se permite y que se debe proporcionar una plantilla de chat personalizada si el tokenizador no define ninguna. Este error destaca un cambio reciente en la biblioteca que requiere la definición explícita de una plantilla de chat, lo que resulta útil para depurar problemas al implementar aplicaciones basadas en chat.

Mensaje de error que indica que se necesita una plantilla de chat para acceder al modelo Imagen 11: Plantilla de chat necesaria

Para evitarlo, asegúrate de proporcionar una plantilla de chat durante la implementación mediante el argumento de entrada --chat-template. Puede encontrar plantillas de ejemplo en el repositorio de ejemplos de vLLM.

Problema habitual 4: longitud de secuencia máxima del modelo

Los errores de longitud máxima de secuencia del modelo se producen cuando la longitud máxima de secuencia del modelo (4096) es mayor que el número máximo de tokens que se pueden almacenar en la caché KV (2256).

Longitud máxima de secuencia del modelo Imagen 12: longitud máxima de secuencia demasiado grande

ValueError: La longitud máxima de secuencia del modelo (4096) es mayor que el número máximo de tokens que se pueden almacenar en la caché de KV (2256). Prueba a aumentar gpu_memory_utilization o disminuir max_model_len al inicializar el motor.

Para solucionar este problema, asigna el valor 2048 a max_model_len, que es inferior a 2256. Otra solución para este problema es usar más GPUs o GPUs más grandes. Si decides usar más GPUs, tendrás que definir el valor de tensor-parallel-size de forma adecuada.

Notas de la versión del contenedor vLLM de Model Garden

Versiones principales

vLLM estándar


Fecha de lanzamiento
Arquitectura
Versión de vLLM
URI de contenedor
17 de julio del 2025
ARM
v0.9.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250717_0916_arm_RC01
10 de julio del 2025
x86
v0.9.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250710_0916_RC01
20 de junio del 2025
x86
A partir de la versión 0.9.1, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250620_0916_RC01
11 de junio del 2025
x86
v0.9.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250611_0916_RC01
2 de junio del 2025
x86
v0.9.0
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250601_0916_RC01
6 de mayo del 2025
x86
v0.8.5.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250506_0916_RC01
29 de abril del 2025
x86
v0.8.4
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250429_0916_RC01, 20250430_0916_RC00_maas
17 de abril del 2025
x86
v0.8.4
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250417_0916_RC01
10 de abril del 2025
x86
A partir de la versión 0.8.3, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250410_0917_RC01
7 de abril del 2025
x86
v0.8.3
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250407_0917_RC01, 20250407_0917_RC0120250429_0916_RC00_maas
7 de abril del 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250404_0916_RC01
5 de abril del 2025
x86
A partir de la versión 0.8.2, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250405_1205_RC01
31 de marzo del 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250401_0916_RC01
Mar 26, 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250327_0916_RC01
Mar 23, 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250324_0916_RC01
21 mar. 2025
x86
v0.8.1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250321_0916_RC01
Mar 11, 2025
x86
A partir de la versión 0.7.3, commit
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250312_0916_RC01
Mar 3, 2025
x86
v0.7.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250304_0916_RC01
14 de enero del 2025
x86
v0.6.4.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250114_0916_RC00_maas
2 dic., 2024
x86
v0.6.4.post1
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241202_0916_RC00_maas
12 de noviembre del 2024
x86
v0.6.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241112_0916_RC00_maas
16 oct. 2024
x86
v0.6.2
us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20241016_0916_RC00_maas

vLLM optimizado


Fecha de lanzamiento
Arquitectura
URI de contenedor
21 de enero del 2025
x86
us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20250121_0835_RC00
29 de octubre del 2024
x86
us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20241029_0835_RC00

Versiones adicionales

Puedes consultar la lista completa de versiones estándar de contenedores de vLLM de VMG en la página de Artifact Registry.

Las versiones de vLLM-TPU en estado experimental se etiquetan con <yyyymmdd_hhmm_tpu_experimental_RC00>.