Entrega de vLLM para modelos de lenguaje de solo texto y multimodales en GPU de Cloud

Resumen

En este instructivo, se explica el proceso de implementación y entrega de los modelos Llama 3.1 y 3.2 con vLLM en Gemini Enterprise Agent Platform. Está diseñado para usarse junto con dos notebooks independientes: Entrega Llama 3.1 con vLLM para implementar modelos Llama 3.1 de solo texto y Entrega Llama 3.2 multimodal con vLLM para implementar modelos multimodales Llama 3.2 que administran entradas de imagen y texto. En esta página, se indica cómo administrar de manera eficiente la inferencia de modelos en GPU y personalizar modelos para diversas aplicaciones. De esta manera, contarás con las herramientas necesarias para integrar modelos de lenguaje avanzados en tus proyectos.

Al final de esta guía, podrás hacer lo siguiente:

  • Descargar modelos Llama compilados previamente de Hugging Face con el contenedor de vLLM
  • Usar vLLM para implementar estos modelos en instancias de GPU en Google Cloud Model Garden de Gemini Enterprise Agent Platform
  • Entregar modelos de forma eficiente para procesar solicitudes de inferencia a gran escala
  • Ejecutar inferencias en solicitudes de solo texto y solicitudes de imagen y texto
  • Realizar una limpieza
  • Depurar la implementación

Funciones clave de vLLM

Función Descripción
PagedAttention Un mecanismo de atención optimizado que administra la memoria de manera eficiente durante la inferencia. Admite la generación de texto de alta capacidad de procesamiento asignando dinámicamente recursos de memoria, lo que permite la escalabilidad para múltiples solicitudes simultáneas.
Agrupación en lotes continua Consolida varias solicitudes de entrada en un solo lote para el procesamiento paralelo, lo que maximiza el uso y la capacidad de procesamiento de la GPU.
Transmisión de tokens Habilita la salida token por token en tiempo real durante la generación de texto. Es ideal para aplicaciones que requieren baja latencia, como chatbots o sistemas de IA interactivos.
Compatibilidad de modelos Admite una amplia variedad de modelos entrenados previamente en frameworks populares, como Hugging Face Transformers. Facilita la integración y la experimentación con diferentes LLM.
Varias GPU y varios hosts Permite una entrega de modelos eficiente, ya que distribuye la carga de trabajo entre varias GPU dentro de una sola máquina y entre varias máquinas de un clúster, lo que aumenta significativamente la capacidad de procesamiento y la escalabilidad.
Implementación eficiente Ofrece una integración fluida con APIs, como las de finalización de chats de OpenAI, lo que facilita la implementación para casos de uso 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 de 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 en la eficiencia de la entrega de LLM.

Tabla 1: Resumen de las funciones de vLLM

Personalizaciones de vLLM de Gemini Enterprise Agent Platform: Mejora el rendimiento y la integración

La implementación de vLLM en Model Garden de Gemini Enterprise Agent Platform no es una integración directa de la biblioteca de código abierto. Gemini Enterprise Agent Platform mantiene una versión personalizada y optimizada de vLLM que se adapta específicamente para mejorar el rendimiento, la confiabilidad y la integración perfecta dentro de Google Cloud.

  • Optimizaciones del rendimiento:
    • Descarga paralela desde Cloud Storage: Acelera de forma significativa los tiempos de carga y de implementación de modelos, ya que habilita la recuperación de datos paralela desde Cloud Storage, lo que reduce la latencia y mejora la velocidad de inicio.
  • Mejoras de funciones:
    • LoRA dinámico con memoria caché del disco mejorada y compatibilidad con Cloud Storage: Extiende las capacidades de LoRA dinámico con mecanismos de memoria caché del disco local y un manejo de errores sólido, junto con la compatibilidad para cargar pesos de LoRA directamente desde rutas de acceso de Cloud Storage y URLs firmadas. Esto simplifica la administración y la implementación de modelos personalizados.
    • Análisis de llamadas a funciones de Llama 3.1/3.2: Implementa un análisis especializado para las llamadas a funciones de Llama 3.1/3.2, lo que mejora la solidez en el 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 GPU.
    • Decodificación especulativa: Esta es una función de vLLM existente, pero Gemini Enterprise Agent Platform ejecutó experimentos para encontrar configuraciones de modelos de alto rendimiento.

Estas personalizaciones específicas de Gemini Enterprise Agent Platform, aunque suelen ser transparentes para el usuario final, te permiten maximizar el rendimiento y la eficiencia de tus implementaciones de Llama 3.1 en Model Garden de Gemini Enterprise Agent Platform.

  • Integración en el ecosistema de Gemini Enterprise Agent Platform:
    • Compatibilidad con el formato de entrada y salida de predicciones de Gemini Enterprise Agent Platform: Garantiza la compatibilidad sin problemas con los formatos de entrada y salida de predicciones de Gemini Enterprise Agent Platform, lo que simplifica el manejo de datos y la integración con otros servicios de Gemini Enterprise Agent Platform.
    • Reconocimiento de variables de entorno de Agent Platform: Respeta y aprovecha las variables de entorno de Gemini Enterprise Agent Platform (AIP_*) para la configuración y la administración de recursos, lo que optimiza la implementación y garantiza un comportamiento coherente dentro del entorno de Gemini Enterprise Agent Platform.
    • Manejo de errores y solidez mejorados: Implementa mecanismos integrales de manejo de errores, validación de entrada y salida, y finalización del servidor para garantizar la estabilidad, la confiabilidad y el funcionamiento sin problemas dentro del entorno administrado de Gemini Enterprise Agent Platform.
    • Servidor de Nginx para la capacidad: Integra un servidor de Nginx sobre el servidor de vLLM, lo que facilita la implementación de varias réplicas y mejora la escalabilidad y la alta disponibilidad de la infraestructura de entrega.

Beneficios adicionales de vLLM

  • Rendimiento de comparativas: vLLM ofrece un rendimiento competitivo en comparación con otros sistemas de entrega, como la inferencia de generación de texto de Hugging Face y FasterTransformer de NVIDIA, en términos de capacidad de procesamiento y latencia.
  • Facilidad de uso: La biblioteca proporciona una API sencilla para la integración con los flujos de trabajo existentes, lo que te permite implementar los modelos de Llama 3.1 y 3.2 con una configuración mínima.
  • Funciones avanzadas: vLLM admite salidas de transmisión (generación de respuestas token por token) y controla de manera eficiente las instrucciones de longitud variable, lo que mejora la interactividad y la capacidad de respuesta en las aplicaciones.

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

Modelos compatibles

vLLM proporciona compatibilidad con una amplia selección de modelos de estado del arte, lo que te permite elegir el modelo que mejor se adapte a tus necesidades. En la siguiente tabla, se ofrece una selección de estos modelos. Sin embargo, para acceder a una lista completa de los modelos compatibles, incluidos los de inferencia multimodal y de solo 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, Code Llama
Mistral AI Mistral 7B, Mixtral 8x7B, Mixtral 8x22B y sus variantes (Instruct, 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, 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, Falcon-RW-7B
BigScience BLOOM, BLOOMZ
Google FLAN-T5, UL2, Gemma (2B, 7B), PaLM 2,
Salesforce CodeT5, CodeT5+
LightOn Persimmon-8B-base, Persimmon-8B-chat
EleutherAI GPT-Neo, 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

Primeros pasos con Model Garden

El contenedor de entrega de GPU de Cloud de vLLM está integrado en Model Garden, el entorno de pruebas, la implementación con un clic y los ejemplos de notebooks de Colab Enterprise. En este instructivo, se usa como ejemplo la familia de modelos Llama de Meta AI.

Usa el notebook de Colab Enterprise

Las implementaciones de Playground y un clic también están disponibles, pero no se describen en este instructivo.

  1. Navega a la página de la tarjeta de modelo y haz clic en Abrir notebook.
  2. En el cuadro de diálogo Abrir notebook, para el notebook model_garden_pytorch_llama3_1_deployment.ipynb (Implementación), haz clic en Colab Enterprise. El notebook se abre en Colab Enterprise.
  3. Ejecuta el notebook para implementar un modelo con vLLM y envía solicitudes de predicción al extremo.

Configuración y requisitos

En esta sección, se describen los pasos necesarios para configurar tu proyecto de Google Cloud y asegurarte de tener los recursos necesarios para implementar y entregar modelos de vLLM.

1. Facturación

2. Disponibilidad y cuotas de GPU

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

3. Configura un proyecto de Google Cloud

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

  • 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 de Google Cloud , la región y un bucket de Cloud Storage único para almacenar artefactos de modelos.
  • Activación de APIs: Habilita las APIs de Gemini Enterprise Agent Platform y la API de Compute Engine, que son esenciales para implementar y administrar modelos de IA.
  • Configuración del bucket: Crea un bucket de Cloud Storage nuevo o verifica uno existente para asegurarte de que esté en la región correcta.
  • Inicialización de Gemini Enterprise Agent Platform: Inicializa la biblioteca cliente de Gemini Enterprise Agent Platform con la configuración del proyecto, la ubicación y el bucket de etapa de pruebas.
  • Configuración de la cuenta de servicio: Identifica la cuenta de servicio predeterminada para ejecutar los trabajos de Gemini Enterprise Agent Platform y otorgarle 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 Agent Platform 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 Agent Platform 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"

Usa Hugging Face con Meta Llama 3.1, 3.2 y vLLM

Las colecciones Llama 3.1 y 3.2 de Meta proporcionan una variedad de modelos de lenguaje grandes (LLM) multilingües diseñados para la generación de texto de alta calidad en varios casos de uso. Estos modelos están previamente entrenados y ajustados para instrucciones, y se destacan en tareas como el diálogo multilingüe, el resumen y la recuperación agéntica. Antes de usar los modelos Llama 3.1 y 3.2, debes aceptar sus condiciones de uso, como se muestra en la captura de pantalla. La biblioteca de vLLM ofrece un entorno de entrega 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 Figura 1: Contrato de licencia de la comunidad de Meta Llama 3

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

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

  • Solo texto: La colección de modelos de lenguaje grandes (LLM) multilingües de Llama 3.2 es una colección de modelos generativos previamente entrenados y ajustados por instrucciones en tamaños de 1,000 millones y 3,000 millones (entrada de texto, salida de texto).
  • Vision y Vision Instruct: La colección Llama 3.2-Vision de modelos de lenguaje grandes (LLM) multimodales es una colección de modelos generativos de razonamiento de imágenes preentrenados y ajustados por instrucciones en tamaños de 11B y 90B (entrada de texto e imágenes, salida de texto). Optimización: Al igual que Llama 3.1, los modelos 3.2 están adaptados para el diálogo multilingüe y tienen un buen rendimiento en tareas de recuperación y resumen, lo que permite obtener los mejores resultados en comparativas estándar.
  • Arquitectura del modelo: Llama 3.2 también cuenta con un framework de transformador autorregresivo, con SFT y RLHF aplicados para alinear los modelos para que sean útiles y seguros.

Tokens de acceso de usuario de Hugging Face

En este instructivo, se requiere un token de acceso de lectura de Hugging Face Hub para acceder a los recursos necesarios. Sigue estos pasos para configurar la autenticación:

Configuración del token de acceso de Hugging Face Figura 2: Configuración del token de acceso de Hugging Face
  1. Genera un token de acceso de lectura:

  2. Usa el token:

    • Usa el token generado para autenticar y acceder a repositorios públicos o privados, según sea necesario para el instructivo.
Administra el token de acceso de Hugging Face Figura 3: Administra el token de acceso de Hugging Face

Esta configuración garantiza que tengas el nivel de acceso adecuado sin permisos innecesarios. Estas prácticas mejoran la seguridad y evitan la exposición accidental de los tokens. Para obtener más información sobre cómo configurar tokens de acceso, visita la página de tokens de acceso de Hugging Face.

Evita compartir o exponer tu token públicamente o en línea. Cuando configuras tu token como una variable de entorno durante la implementación, este permanece privado para tu proyecto. Gemini Enterprise Agent Platform garantiza su seguridad, ya que impide que otros usuarios accedan a tus modelos y extremos.

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

Implementa modelos Llama 3.1 de solo texto con vLLM

Para la implementación a nivel de producción de modelos de lenguaje grandes, vLLM proporciona una solución de entrega eficiente que optimiza el uso de memoria, reduce la latencia y aumenta la capacidad de procesamiento. Esto hace que sea especialmente adecuado para controlar los modelos de Llama 3.1 más grandes, así como los modelos de Llama 3.2 multimodales.

Paso 1: Elige un modelo para implementar

Elige la variante del modelo Llama 3.1 que deseas implementar. Las opciones disponibles incluyen varios tamaños y versiones ajustadas por 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: Verifica el hardware y la cuota de implementación

La función de implementación establece la GPU y el tipo de máquina adecuados según el tamaño del modelo y verifica la cuota en esa región para un proyecto en particular:

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 que especificaste:

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 siguiente función sube el modelo a Gemini Enterprise Agent Platform, establece los parámetros de configuración de la implementación y lo implementa en un extremo con vLLM.

  1. Imagen de Docker: La implementación usa una imagen de Docker de vLLM compilada previamente para una entrega eficiente.
  2. Configuración: Configura el uso de memoria, la longitud del modelo y otros parámetros de configuración de vLLM. Para obtener más información sobre los argumentos que admite el servidor, visita la página de documentación oficial de vLLM.
  3. Variables de entorno: Establece 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 Agent Platform."""
    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: Ejecuta la implementación

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

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 esta muestra de código, tu modelo de Llama 3.1 se implementará en Gemini Enterprise Agent Platform y se podrá acceder a él a través del extremo especificado. Puedes interactuar con él para tareas de inferencia, como la generación de texto, el resumen y el diálogo. Según el tamaño del modelo, la implementación de un modelo nuevo puede tardar hasta una hora. Puedes verificar el progreso en la predicción en línea.

Extremo de implementación de Llama 3.1 en el panel de Agent Platform Figura 4: Extremo de implementación de Llama 3.1 en el panel de Agent Platform

Realiza predicciones con Llama 3.1 en Gemini Enterprise Agent Platform

Después de implementar correctamente el modelo Llama 3.1 en Gemini Enterprise Agent Platform, puedes comenzar a realizar predicciones enviando instrucciones de texto al extremo. En esta sección, se proporciona un ejemplo de generación de respuestas con varios parámetros personalizables para controlar el resultado.

Paso 1: Define tu instrucción y los parámetros

Comienza por configurar la instrucción de texto y los parámetros de muestreo para guiar la respuesta del modelo. Estos son los parámetros clave:

  • prompt: Es el texto de entrada para el que deseas que el modelo genere una respuesta. Por ejemplo, prompt = "What is a car?".
  • max_tokens: Es la cantidad máxima de tokens en el resultado generado. Reducir este valor puede ayudar a evitar problemas de tiempo de espera.
  • temperature: Controla la aleatorización 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 enfocado.
  • top_p: Limita el grupo de muestreo a la probabilidad acumulativa más alta. Por ejemplo, si configuras top_p = 0.9, solo se considerarán los tokens dentro del 90% superior de la masa de probabilidad.
  • top_k: Limita el muestreo a los k tokens más probables. Por ejemplo, si configuras top_k = 50, solo se muestrearán los 50 tokens principales.
  • raw_response: Si es True, devuelve el resultado del modelo sin procesar. Si es False, aplica un formato adicional con la estructura "Prompt:\n{prompt}\nOutput:\n{output}".
  • lora_id (opcional): Es la ruta de acceso a los archivos de pesos de LoRA para aplicar los pesos de la adaptación de bajo rango (LoRA). Puede ser un bucket de Cloud Storage o una URL del repositorio de Hugging Face. Ten en cuenta que esto solo funciona si se configura --enable-lora en los argumentos de implementación. La LoRA dinámica no es compatible con los 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: Envía la solicitud de predicción

Ahora que la instancia está configurada, puedes enviar la solicitud de predicción al extremo de Gemini Enterprise Agent Platform implementado. En este ejemplo, se muestra cómo realizar una predicción y mostrar el resultado:

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

for prediction in response.predictions:
    print(prediction)

Resultado de ejemplo

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

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 garantizar que el contenido sea seguro, puedes moderar el texto generado con las funciones de moderación de texto de Agent Platform.
  • Cómo controlar los tiempos de espera: Si tienes problemas como ServiceUnavailable: 503, intenta reducir el parámetro max_tokens.

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

Implementa modelos de Llama 3.2 multimodales con vLLM

En esta sección, se explica el proceso de subir modelos de Llama 3.2 compilados previamente a Model Registry y, luego, implementarlos en un extremo de Gemini Enterprise Agent Platform. El tiempo de implementación puede tardar hasta una hora, según el tamaño del modelo. Los modelos de Llama 3.2 están disponibles en versiones multimodales que admiten entradas de texto y de imagen. vLLM admite lo siguiente:

  • Formato de solo texto
  • Formato de imagen única + 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 implementar

Especifica la variante del modelo de Llama 3.2 que deseas implementar. En el siguiente ejemplo, se usa Llama-3.2-11B-Vision como el modelo seleccionado, pero puedes elegir entre otras opciones disponibles según 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: Configura el hardware y los recursos

Selecciona el hardware adecuado para el tamaño del modelo. vLLM puede usar diferentes GPU según las necesidades de procesamiento del modelo:

  • Modelos 1B y 3B: Usa GPU NVIDIA L4.
  • Modelos de 11,000 millones de parámetros: Usa GPUs NVIDIA A100.
  • Modelos 90B: Usa GPU NVIDIA H100.

En este ejemplo, se configura la implementación según 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 tener 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: Implementa el modelo con vLLM

La siguiente función controla la implementación del modelo Llama 3.2 en Gemini Enterprise Agent Platform. Configura el entorno del modelo, el uso de memoria y los parámetros de configuración de vLLM para una entrega 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 Agent Platform."""
    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: Ejecuta la implementación

Ejecuta la función de implementación con el modelo y los parámetros de configuración establecidos. La función devolverá las instancias del modelo y del extremo, 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,
)
Extremo de implementación de Llama 3.2 en el panel de Agent Platform Figura 5: Extremo de implementación de Llama 3.2 en el panel de Agent Platform

Según el tamaño del modelo, la implementación del modelo nuevo puede tardar hasta una hora en completarse. Puedes verificar su progreso en la predicción en línea.

Inferencia con vLLM en Gemini Enterprise Agent Platform con la ruta de predicción predeterminada

En esta sección, se explica cómo configurar la inferencia para el modelo Llama 3.2 Vision en Gemini Enterprise Agent Platform con la ruta de predicción predeterminada. Usarás la biblioteca de vLLM para una entrega eficiente y, luego, interactuarás con el modelo enviando una instrucción visual combinada con texto.

Para comenzar, asegúrate de que el extremo del modelo esté implementado y listo para las predicciones.

Paso 1: Define tu instrucción y los parámetros

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

Entrada de imagen de muestra para dar instrucciones a Llama 3.2 Figura 6: Imagen de entrada de muestra para enviar instrucciones 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: Configura 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 instrucció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: Realiza la predicción

Envía la solicitud al extremo de Gemini Enterprise Agent Platform 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 tienes un problema de tiempo de espera (por ejemplo, ServiceUnavailable: 503 Took too long to respond when processing), intenta reducir el valor de max_tokens a un número más bajo, como 20, para mitigar el tiempo de respuesta.

Inferencia con vLLM en Gemini Enterprise Agent Platform con OpenAI Chat Completion

En esta sección, se explica cómo realizar inferencias en los modelos de Llama 3.2 Vision con la API de OpenAI Chat Completions en Gemini Enterprise Agent Platform. Este enfoque te permite usar capacidades multimodales enviando imágenes e instrucciones de texto al modelo para obtener respuestas más interactivas.

Paso 1: Ejecuta la implementación del modelo Llama 3.2 Vision Instruct

Ejecuta la función de implementación con el modelo y los parámetros de configuración establecidos. La función devolverá las instancias del modelo y del extremo, 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: Configura el recurso de extremo

Comienza por configurar el nombre del recurso del extremo para tu implementación de Gemini Enterprise Agent Platform.

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 con el SDK de OpenAI, asegúrate de que estén instaladas las bibliotecas necesarias:

!pip install -qU openai google-auth requests

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

Configura la URL de la imagen y la instrucció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

Recupera tus credenciales y establece la URL base para 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 de Chat Completions de OpenAI, envía la imagen y la instrucción de texto a tu extremo de Gemini Enterprise Agent Platform:

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)

Paso 7 (opcional): Vuelve a conectarte a un extremo existente

Para volver a conectarte a un extremo creado anteriormente, usa el ID del extremo. Este paso es útil si quieres volver a usar un extremo 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 proporciona flexibilidad para cambiar entre los extremos recién creados y los existentes según sea necesario, lo que permite optimizar las pruebas y la implementación.

Limpieza

Para evitar cargos continuos y liberar recursos, asegúrate de borrar los modelos implementados, los extremos y, de manera opcional, el bucket de almacenamiento que se usó en este experimento.

Paso 1: Borra extremos y modelos

El siguiente código anulará la implementación de cada modelo y borrará los extremos 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: Borra el bucket de Cloud Storage (opcional)

Si creaste un bucket de Cloud Storage específicamente para este experimento, puedes borrarlo configurando delete_bucket como True. Este paso es opcional, pero se recomienda si ya no necesitas el bucket.

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

Si sigues estos pasos, te aseguras de que se limpien todos los recursos que se usaron en este instructivo, lo que reduce los costos innecesarios asociados con el experimento.

Depura problemas comunes

En esta sección, se proporciona orientación para identificar y resolver problemas comunes que se encuentran durante la implementación y la inferencia de modelos de vLLM en Gemini Enterprise Agent Platform.

Verifica los registros

Verifica los registros para identificar la causa raíz de las fallas de implementación o el comportamiento inesperado:

  1. Navega a la consola de Gemini Enterprise Agent Platform Prediction: Ve a la consola de Gemini Enterprise Agent Platform Prediction en la consola de Google Cloud .
  2. Selecciona el extremo: Haz clic en el extremo que tiene problemas. El estado debe indicar si la implementación falló.
  3. Ver registros: Haz clic en el extremo y, luego, navega a la pestaña Registros o haz clic en Ver registros. Esto te dirigirá a Cloud Logging, filtrado para mostrar los registros específicos de ese extremo y la implementación del modelo. También puedes acceder a los registros directamente a través del servicio de Cloud Logging.
  4. Analiza los registros: Revisa las entradas de registro para ver los mensajes de error, las advertencias y otra información relevante. Visualiza 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: CUDA sin memoria insuficiente (OOM) durante la implementación

Los errores de memoria insuficiente (OOM) de CUDA ocurren cuando el uso de memoria del modelo supera la capacidad disponible de la GPU.

En el caso del modelo de solo texto, usamos 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, usamos 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

Implementar el modelo multimodal con max_num_seqs = 256, como hicimos en el caso del modelo de solo texto, podría causar 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 memoria insuficiente (OOM) Figura 7: Registro de errores de GPU por memoria insuficiente (OOM)

Comprende la memoria de max_num_seqs y de la GPU:

  • El parámetro max_num_seqs define la cantidad máxima de solicitudes simultáneas que puede controlar el modelo.
  • Cada secuencia que procesa el modelo consume memoria de GPU. El uso de memoria total 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 texto e imágenes.

Revisa el registro de errores (figura 8):

  • El registro muestra un torch.OutOfMemoryError cuando se intenta asignar memoria en la GPU.
  • El error se produce porque el uso de memoria del modelo supera la capacidad de GPU disponible. La GPU NVIDIA L4 tiene 24 GB, y establecer el parámetro max_num_seqs demasiado alto para el modelo multimodal provoca un desbordamiento.
  • En el registro, se sugiere configurar PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True para mejorar la administración de la memoria, aunque el problema principal aquí es el uso elevado de memoria.
Mensaje de error que indica que falló la implementación de Llama 3.2 Figura 8: Implementación fallida de Llama 3.2
Panel de detalles de la versión del modelo Figura 9: Panel de detalles de la versión del modelo

Para resolver este problema, navega a la consola de predicción de Gemini Enterprise Agent Platform y haz clic en el extremo. El estado debería indicar que la implementación falló. 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á restringido y requiere credenciales de autenticación adecuadas para acceder.

En la siguiente captura de pantalla, se muestra una entrada de registro en el Explorador de registros de Google Cloud con 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, por lo que se requiere autenticación para continuar. El mensaje indica específicamente "No se puede acceder al repositorio controlado para la URL", lo que destaca que el modelo está controlado y requiere credenciales de autenticación adecuadas para acceder. Esta entrada de registro puede ayudar a solucionar problemas de autenticación cuando se trabaja con recursos restringidos en repositorios externos.

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

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

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 asignador de token no define una.

En esta captura de pantalla, se muestra una entrada de registro en el Explorador de registros de Google Cloud, en la que se produce un 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 ya no se permite la plantilla de chat predeterminada y que se debe proporcionar una plantilla de chat personalizada si el asignador de token no define una. Este error destaca un cambio reciente en la biblioteca que requiere la definición explícita de una plantilla de chat, lo que es útil para depurar problemas cuando se implementan aplicaciones basadas en chat.

Mensaje de error que indica que se necesita una plantilla de chat para acceder al modelo Figura 11: Se necesita una plantilla de chat

Para evitar esto, asegúrate de proporcionar una plantilla de chat durante la implementación con el argumento de entrada --chat-template. Puedes encontrar plantillas de muestra en el repositorio de ejemplos de vLLM.

Problema habitual 4: Longitud máxima de la secuencia del modelo

Los errores de longitud máxima de la secuencia del modelo ocurren cuando la longitud máxima de la secuencia del modelo (4096) es mayor que la cantidad máxima de tokens que se pueden almacenar en la caché de KV (2256).

Longitud máxima de la secuencia del modelo Figura 12: Longitud máxima de la secuencia demasiado grande

ValueError: La longitud máxima de la secuencia del modelo (4096) es mayor que la cantidad máxima de tokens que se pueden almacenar en la caché de KV (2256). Intenta aumentar gpu_memory_utilization o disminuir max_model_len cuando inicialices el motor.

Para resolver este problema, establece max_model_len en 2048, que es menor que 2256. Otra solución para este problema es usar más GPU o GPU más grandes. tensor-parallel-size deberá configurarse de forma adecuada si se opta por usar más GPU.

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

Lanzamientos principales

vLLM estándar


Fecha de lanzamiento

Arquitectura

Versión de vLLM

URI del contenedor
17 de julio de 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 de 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 de 2025
x86

Después de la versión 0.9.1, confirmación

us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250620_0916_RC01
11 de junio de 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 de 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 de 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 de 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 de 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 de 2025
x86

Después 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 de 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 de 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 de 2025
x86

Después 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 de 2025
x86

v0.8.1

us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250401_0916_RC01
26 mar, 2025
x86

v0.8.1

us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250327_0916_RC01
23 de marzo de 2025
x86

v0.8.1

us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250324_0916_RC01
21 de marzo de 2025
x86

v0.8.1

us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-vllm-serve:20250321_0916_RC01
11 de marzo de 2025
x86

Después 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
3 de marzo de 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 de 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 de diciembre de 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 de 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 2017
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 del contenedor
Jan 21, 2025
x86

us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20250121_0835_RC00
29 de octubre de 2024
x86

us-docker.pkg.dev/vertex-ai-restricted/vertex-vision-model-garden-dockers/pytorch-vllm-optimized-serve:20241029_0835_RC00

Lanzamientos adicionales

La lista completa de las versiones de contenedores de vLLM estándar de VMG se puede encontrar en la página de Artifact Registry.

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