Disponibilização de vLLM para modelos de linguagem somente de texto e multimodais em GPUs do Cloud

Resumo

Neste tutorial, mostramos o processo de implantação e disponibilização dos modelos Llama 3.1 e 3.2 usando o vLLM na Vertex AI. Ele foi projetado para ser usado com dois notebooks separados: Servir o Llama 3.1 com vLLM para implantar modelos somente de texto do Llama 3.1 e Servir o Llama 3.2 multimodal com vLLM para implantar modelos multimodais do Llama 3.2 que processam entradas de texto e imagem. As etapas descritas nesta página mostram como processar a inferência de modelos em GPUs de maneira eficiente e personalizar modelos para diversos aplicativos, além de fornecer as ferramentas para integrar modelos de linguagem avançados aos seus projetos.

Ao final deste guia, você vai saber como:

  • Faça o download de modelos Llama pré-criados do Hugging Face com o contêiner vLLM.
  • Use o vLLM para implantar esses modelos em instâncias de GPU no Google Cloud Model Garden da Vertex AI.
  • Exiba modelos de maneira eficiente para processar solicitações de inferência em grande escala.
  • Execute a inferência em solicitações somente de texto e de texto e imagem.
  • Faça a limpeza.
  • Depurar a implantação.

Principais recursos do vLLM

Recurso Descrição
PagedAttention (link em inglês) Um mecanismo de atenção otimizado que gerencia a memória de forma eficiente durante a inferência. Oferece suporte à geração de texto de alta capacidade, alocando dinamicamente recursos de memória, permitindo a escalonabilidade de várias solicitações simultâneas.
Lotes contínuos Consolida várias solicitações de entrada em um único lote para processamento paralelo, maximizando a utilização e a capacidade de processamento da GPU.
Streaming de token Permite a saída de tokens por token em tempo real durante a geração de texto. Ideal para aplicativos que exigem baixa latência, como chatbots ou sistemas de IA interativos.
Compatibilidade do modelo Oferece suporte a uma ampla variedade de modelos pré-treinados em frameworks conhecidos, como o Hugging Face Transformers. Facilita a integração e o teste de diferentes LLMs.
Várias GPUs e vários hosts Permite a veiculação eficiente de modelos ao distribuir a carga de trabalho entre várias GPUs em uma única máquina e em várias máquinas em um cluster, aumentando significativamente a capacidade de processamento e a capacidade de escalonamento.
Implantação eficiente Oferece integração perfeita com APIs, como a conclusão de chat do OpenAI, facilitando a implantação para casos de uso de produção.
Integração total com modelos do Hugging Face O vLLM é compatível com o formato de artefatos do modelo Hugging Face e oferece suporte ao carregamento do HF, facilitando a implantação de modelos Llama com outros modelos conhecidos, como Gemma, Phi e Qwen, em uma configuração otimizada.
Projeto de código aberto orientado pela comunidade O vLLM é um framework de código aberto que incentiva as contribuições da comunidade, promovendo melhorias contínuas na eficiência da veiculação de LLMs.

Tabela 1: resumo dos recursos do vLLM

Personalizações de vLLM da Vertex AI do Google: melhore a performance e a integração

A implementação do vLLM no Model Garden da Vertex AI não é uma integração direta da biblioteca de código aberto. A Vertex AI mantém uma versão personalizada e otimizada do vLLM, que é adaptada especificamente para melhorar o desempenho, a confiabilidade e a integração perfeita no Google Cloud.

  • Otimizações de desempenho:
    • Download paralelo do Cloud Storage:acelera significativamente os tempos de carregamento e implantação do modelo, permitindo a recuperação de dados em paralelo do Cloud Storage, reduzindo a latência e melhorando a velocidade de inicialização.
  • Melhorias de recursos:
    • LoRA dinâmico com suporte aprimorado de armazenamento em cache e Cloud Storage:estende os recursos dinâmicos do LoRA com mecanismos de armazenamento em cache local e tratamento de erros robusto, além de suporte ao carregamento de pesos do LoRA diretamente de caminhos do Cloud Storage e URLs assinados. Isso simplifica o gerenciamento e a implantação de modelos personalizados.
    • Análise de chamadas de função do Llama 3.1/3.2:implementa a análise especializada para chamadas de função do Llama 3.1/3.2, melhorando a robustez na análise.
    • Armazenamento em cache de prefixo de memória do host:o vLLM externo só oferece suporte ao armazenamento em cache de prefixo de memória da GPU.
    • Decodificação especulativa:esse é um recurso do vLLM, mas a Vertex AI realizou experimentos para encontrar configurações de modelos de alto desempenho.

Essas personalizações específicas da Vertex AI, embora muitas vezes sejam transparentes para o usuário final, permitem maximizar a performance e a eficiência das implantações do Llama 3.1 no Vertex AI Model Garden.

  • Integração com o ecossistema da Vertex AI:
    • Suporte ao formato de entrada/saída de previsão da Vertex AI:garante a compatibilidade total com os formatos de entrada e saída de previsão da Vertex AI, simplificando o processamento de dados e a integração com outros serviços da Vertex AI.
    • Variáveis de ambiente do Vertex:respeita e aproveita as variáveis de ambiente da Vertex AI (AIP_*) para configuração e gerenciamento de recursos, simplificando a implantação e garantindo um comportamento consistente no ambiente da Vertex AI.
    • Gerenciamento de erros e robustez aprimorados:implementa mecanismos abrangentes de gerenciamento de erros, validação de entrada/saída e encerramento de servidor para garantir estabilidade, confiabilidade e operação perfeita no ambiente gerenciado da Vertex AI.
    • Servidor Nginx para recursos:integra um servidor Nginx ao servidor vLLM, facilitando a implantação de várias réplicas e melhorando a escalabilidade e a alta disponibilidade da infraestrutura de serviço.

Outros benefícios do vLLM

  • Desempenho de comparação: o vLLM oferece desempenho competitivo em comparação com outros sistemas de disponibilização, como a inferência de geração de texto do Hugging Face e o FasterTransformer da NVIDIA em termos de capacidade de processamento e latência.
  • Facilidade de uso: a biblioteca oferece uma API simples para integração com fluxos de trabalho existentes, permitindo implantar os modelos Llama 3.1 e 3.2 com a configuração mínima.
  • Recursos avançados: o vLLM oferece suporte a saídas de streaming (gerando respostas token por token) e processa comandos de comprimento variável de maneira eficiente, melhorando a interatividade e a capacidade de resposta em aplicativos.

Para ter uma visão geral do sistema vLLM, consulte o artigo.

Modelos compatíveis

O vLLM oferece suporte a uma ampla seleção de modelos de última geração, permitindo que você escolha o que melhor se adapta às suas necessidades. A tabela a seguir oferece uma seleção desses modelos. No entanto, para acessar uma lista completa de modelos com suporte, incluindo aqueles para inferência apenas de texto e multimodal, consulte o site oficial do vLLM.

Categoria 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 e suas variantes (Instruct, Chat), Mistral-tiny, Mistral-small, Mistral-medium
DeepSeek AI (link em inglês) 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) e variantes (Instruct, Chat), MPT-7B-StoryWriter-65k
OpenAI (em inglês) GPT-2, GPT-3, GPT-4, GPT-NeoX
Together AI (em inglês) RedPajama, Pythia
Stability AI StableLM (3B, 7B), StableLM-Alpha-3B, StableLM-Base-Alpha-7B, StableLM-Instruct-Alpha-7B
Instituto de Inovação Tecnológica (TII, na sigla em inglês) Falcon 7B, Falcon 40B e variantes (Instruct, Chat), Falcon-RW-1B, Falcon-RW-7B
BigScience (link em inglês) BLOOM, BLOOMZ
Google FLAN-T5, UL2, Gemma (2B, 7B), PaLM 2,
Salesforce CodeT5, CodeT5+
LightOn Persimmon-8B-base, Persimmon-8B-chat
EleutherAI (em inglês) GPT-Neo, Pythia
AI21 Labs (em inglês) Jamba
Cerebras (link em inglês) Cerebras-GPT
Intel Intel-NeuralChat-7B
Outros modelos importantes StarCoder, OPT, Baichuan, Aquila, Qwen, InternLM, XGen, OpenLLaMA, Phi-2, Yi, OpenCodeInterpreter, Nous-Hermes, Gemma-it, Mistral-Instruct-v0.2-7B-Zeus,

Tabela 2: alguns modelos compatíveis com a vLLM

Introdução ao Model Garden

O contêiner de veiculação de GPUs do vLLM Cloud está integrado ao Model Garden, ao Playground, à implantação com um clique e aos exemplos de bloco do Colab Enterprise. Este tutorial se concentra na família de modelos Llama da Meta AI como exemplo.

Usar o bloco do Colab Enterprise

As implantações do ambiente de testes e com um clique também estão disponíveis, mas não são descritas neste tutorial.

  1. Acesse a página do card de modelo e clique em Abrir notebook.
  2. Selecione o notebook da Vertex Serving. O notebook é aberto no Colab Enterprise.
  3. Executar pelo notebook para implantar um modelo usando o vLLM e enviar solicitações de previsão ao endpoint.

Configuração e requisitos

Esta seção descreve as etapas necessárias para configurar o projeto Google Cloud e garantir que você tenha os recursos necessários para implantar e exibir modelos vLLM.

1. Faturamento

2. Disponibilidade e cotas de GPU

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

3. Configurar um Google Cloud projeto

Execute o exemplo de código abaixo para garantir que o Google Cloud ambiente esteja configurado corretamente. Esta etapa instala as bibliotecas Python necessárias e configura o acesso aos recursos Google Cloud . incluindo estas ações:

  • Instalação: faça upgrade da biblioteca google-cloud-aiplatform e clone o repositório que contém as funções utilitárias.
  • Configuração do ambiente: definição de variáveis para o ID do projeto, a região e um bucket exclusivo do Cloud Storage para armazenar artefatos do modelo. Google Cloud
  • Ativação da API: ative as APIs Vertex AI e Compute Engine, que são essenciais para implantar e gerenciar modelos de IA.
  • Configuração do bucket: crie um bucket do Cloud Storage ou verifique um bucket existente para garantir que ele esteja na região correta.
  • Inicialização da Vertex AI: inicialize a biblioteca de cliente da Vertex AI com as configurações do projeto, do local e do bucket de preparo.
  • Configuração da conta de serviço: identifique a conta de serviço padrão para executar trabalhos da Vertex AI e conceda as permissões necessárias.
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"

Como usar o Hugging Face com o Meta Llama 3.1, 3.2 e o vLLM

As coleções Llama 3.1 e 3.2 do Meta oferecem uma variedade de modelos de linguagem grandes (LLMs) multilíngues projetados para gerar textos de alta qualidade em vários casos de uso. Esses modelos são pré-treinados e ajustados por instruções, se destacando em tarefas como diálogo multilíngue, resumo e recuperação de agentes. Antes de usar os modelos da Llama 3.1 e 3.2, você precisa concordar com os Termos de Uso, conforme mostrado na captura de tela. A biblioteca vLLM oferece um ambiente de fornecimento simplificado de código aberto com otimizações para latência, eficiência de memória e escalonabilidade.

Observação importante: para acessar esses modelos, você precisa compartilhar seus dados de contato e aceitar os Termos de Uso descritos na Política de Privacidade do Meta. Sua solicitação será analisada pelos autores do repositório.

Contrato de licença da comunidade Meta Llama 3 Figura 1: Contrato de licença da comunidade do Meta Llama 3

Visão geral das coleções do Meta Llama 3.1 e 3.2

As coleções Llama 3.1 e 3.2 atendem a diferentes escalas de implantação e tamanhos de modelo, oferecendo opções flexíveis para tarefas de diálogo multilíngue e muito mais. Consulte a página de visão geral da Lhama para mais informações.

  • Somente texto: a coleção de modelos de linguagem grandes (LLMs) multilíngues Llama 3.2 é composta por modelos generativos pré-treinados e ajustados por instrução nos tamanhos 1B e 3B (entrada/saída de texto).
  • Vision e Vision Instruct: a coleção de modelos de linguagem grandes multimodais (LLMs) Llama 3.2-Vision é uma coleção de modelos generativos de raciocínio de imagem pré-treinados e ajustados por instrução nos tamanhos 11B e 90B (entrada de texto + imagens, saída de texto). Otimização: assim como o Llama 3.1, os modelos 3.2 são adaptados para diálogos multilíngues e têm bom desempenho em tarefas de recuperação e resumo, alcançando os melhores resultados em comparativos de mercado padrão.
  • Arquitetura do modelo: o Llama 3.2 também tem um framework de transformador autorregressivo, com SFT e RLHF aplicados para alinhar os modelos com utilidade e segurança.

Tokens de acesso do usuário do Hugging Face

Este tutorial exige um token de acesso de leitura do Hub do Hugging Face para acessar os recursos necessários. Siga estas etapas para configurar a autenticação:

Configurações do token de acesso do Hugging Face Figura 2: configurações do token de acesso do Hugging Face

  1. Gere um token de acesso de leitura:

  2. Use o token:

    • Use o token gerado para autenticar e acessar repositórios públicos ou privados conforme necessário para o tutorial.
Gerenciar o token de acesso do Hugging Face Figura 3: gerenciar o token de acesso do Hugging Face

Essa configuração garante que você tenha o nível de acesso adequado sem permissões desnecessárias. Essas práticas aumentam a segurança e evitam a exposição acidental de tokens. Para mais informações sobre como configurar tokens de acesso, acesse a página de tokens de acesso do Hugging Face.

Evite compartilhar ou expor seu token publicamente ou on-line. Quando você define o token como uma variável de ambiente durante a implantação, ele permanece privado para o projeto. A Vertex AI garante a segurança impedindo que outros usuários acessem seus modelos e endpoints.

Para mais informações sobre como proteger seu token de acesso, consulte Práticas recomendadas para tokens de acesso do Hugging Face.

Implantar modelos Llama 3.1 somente de texto com o vLLM

Para implantação de modelos de linguagem grandes no nível de produção, o vLLM oferece uma solução de disponibilização eficiente que otimiza o uso da memória, reduz a latência e aumenta a capacidade de processamento. Isso torna o modelo mais adequado para processar os modelos maiores do Llama 3.1 e os modelos multimodais do Llama 3.2.

Etapa 1: escolher um modelo para implantar

Escolha a variante do modelo Llama 3.1 para implantar. As opções disponíveis incluem vários tamanhos e versões ajustadas às instruções:

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

Etapa 2: verificar o hardware e a cota de implantação

A função de implantação define a GPU e o tipo de máquina apropriados com base no tamanho do modelo e verifica a cota na região para um projeto específico:

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}.")

Verifique a disponibilidade da cota de GPU na região especificada:

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

Etapa 3: inspecionar o modelo usando o vLLM

A função a seguir faz o upload do modelo para a Vertex AI, configura as configurações de implantação e implanta o modelo em um endpoint usando o vLLM.

  1. Imagem do Docker: a implantação usa uma imagem do Docker pré-criada para o fornecimento eficiente.
  2. Configuração: configure a utilização de memória, a duração do modelo e outras configurações de vLLM. Para mais informações sobre os argumentos aceitos pelo servidor, acesse a página de documentação oficial do vLLM.
  3. Variáveis de ambiente: defina variáveis de ambiente para a autenticação e a origem de implantação.
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

Etapa 4: executar a implantação

Execute a função de implantação com o modelo e a configuração selecionados. Esta etapa implanta o modelo e retorna as instâncias do modelo e do 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,
)

Depois de executar este exemplo de código, o modelo Llama 3.1 será implantado na Vertex AI e acessível pelo endpoint especificado. Você pode interagir com ele para tarefas de inferência, como geração de texto, resumo e diálogo. Dependendo do tamanho do modelo, a implantação de um novo modelo pode levar até uma hora. Você pode verificar o progresso na Previsão on-line da Vertex.

Endpoint de implantação do Llama 3.1 no painel da Vertex Figura 4: endpoint de implantação do Llama 3.1 no painel de vértices

Como fazer previsões com o Llama 3.1 na Vertex AI

Depois de implantar o modelo Llama 3.1 na Vertex AI, você pode começar a fazer previsões enviando comandos de texto para o endpoint. Esta seção mostra um exemplo de geração de respostas com vários parâmetros personalizáveis para controlar a saída.

Etapa 1: definir a solicitação e os parâmetros

Comece configurando o comando de texto e os parâmetros de amostragem para orientar a resposta do modelo. Estes são os principais parâmetros:

  • prompt: o texto de entrada para o qual você quer que o modelo gere uma resposta. Por exemplo, instrução = "O que é um carro?".
  • max_tokens: o número máximo de tokens na saída gerada. Reduzir esse valor pode ajudar a evitar problemas de tempo limite.
  • temperature: controla a aleatoriedade das previsões. Valores mais altos (por exemplo, 1,0) aumentam a diversidade, enquanto valores mais baixos (por exemplo, 0,5) tornam a saída mais focada.
  • top_p: limita o conjunto de amostragem à probabilidade cumulativa mais alta. Por exemplo, definir top_p = 0,9 só vai considerar tokens dentro da massa de probabilidade de 90%.
  • top_k: limita a amostragem aos k tokens mais prováveis. Por exemplo, a configuração top_k = 50 vai usar apenas os 50 tokens principais.
  • raw_response: se verdadeiro, retorna a saída do modelo bruto. Se for False, aplique uma formatação adicional com a estrutura "Prompt:\n{prompt}\nOutput:\n{output}".
  • lora_id (opcional): caminho para arquivos de peso da LoRA para aplicar pesos de adaptação de baixa classificação (LoRA). Pode ser um bucket do Cloud Storage ou um URL do repositório do Hugging Face. Isso só funciona se --enable-lora estiver definido nos argumentos de implantação. O LoRA dinâmico não é compatível com modelos multimodais.
prompt = "What is a car?"
max_tokens = 50
temperature = 1.0
top_p = 1.0
top_k = 1
raw_response = False
lora_id = ""

Etapa 2: enviar a solicitação de previsão

Agora que a instância está configurada, você pode enviar a solicitação de previsão para o endpoint implantado da Vertex AI. Este exemplo mostra como fazer uma previsão e imprimir o resultado:

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

for prediction in response.predictions:
    print(prediction)

Exemplo de saída

Confira um exemplo de como o modelo pode responder à instrução "O que é um carro?":

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.

Outras observações

  • Moderação: para garantir a segurança do conteúdo, é possível moderar o texto gerado com os recursos de moderação de texto da Vertex AI.
  • Processamento de tempo limite: se você encontrar problemas como ServiceUnavailable: 503, tente reduzir o parâmetro max_tokens.

Essa abordagem oferece uma maneira flexível de interagir com o modelo Llama 3.1 usando diferentes técnicas de amostragem e adaptadores LoRA, tornando-o adequado para vários casos de uso, desde a geração de texto de uso geral até respostas específicas para tarefas.

Implantar modelos multimodais do Llama 3.2 com o vLLM

Esta seção orienta você no processo de fazer upload de modelos pré-criados do Llama 3.2 para o Registro de modelos e implantá-los em um endpoint da Vertex AI. O tempo de implantação pode levar até uma hora, dependendo do tamanho do modelo. Os modelos Llama 3.2 estão disponíveis em versões multimodais com suporte a entradas de texto e imagem. O vLLM oferece suporte a:

  • Formato somente texto
  • Formato de imagem única + texto

Esses formatos tornam o Llama 3.2 adequado para aplicativos que exigem processamento visual e de texto.

Etapa 1: escolher um modelo para implantar

Especifique a variante do modelo do Llama 3.2 que você quer implantar. O exemplo a seguir usa Llama-3.2-11B-Vision como o modelo selecionado, mas você pode escolher outras opções disponíveis com base nos seus 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

Etapa 2: configurar hardware e recursos

Selecione o hardware adequado para o tamanho do modelo. O vLLM pode usar GPUs diferentes, dependendo das necessidades computacionais do modelo:

  • Modelos 1B e 3B: use GPUs NVIDIA L4.
  • Modelos 11B: use GPUs NVIDIA A100.
  • Modelos 90B: use GPUs NVIDIA H100.

Este exemplo configura a implantação com base na seleção do 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}.")

Verifique se você tem a cota de GPU necessária:

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

Etapa 3: implantar o modelo usando o vLLM

A função a seguir processa a implantação do modelo Llama 3.2 na Vertex AI. Ele configura o ambiente do modelo, a utilização da memória e as configurações do vLLM para uma exibição 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

Etapa 4: executar a implantação

Execute a função de implantação com o modelo e as configurações configuradas. A função vai retornar as instâncias do modelo e do endpoint, que podem ser usadas para inferência.

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 implantação do Llama 3.2 no painel da Vertex Figura 5: endpoint de implantação do Llama 3.2 no Painel do Vertex

Dependendo do tamanho do modelo, a implantação de um novo modelo pode levar até uma hora. Confira o progresso em Vertex Online Prediction.

Inferência com vLLM na Vertex AI usando a rota de previsão padrão

Esta seção orienta você a configurar a inferência do modelo Llama 3.2 Vision na Vertex AI usando a rota de previsão padrão. Você vai usar a biblioteca vLLM para uma exibição eficiente e interagir com o modelo enviando um comando visual em combinação com o texto.

Para começar, verifique se o endpoint do modelo está implantado e pronto para previsões.

Etapa 1: definir a solicitação e os parâmetros

Este exemplo fornece um URL de imagem e um comando de texto, que o modelo processará para gerar uma resposta.

Exemplo de entrada de imagem para ativar o Llama 3.2 Figura 6: exemplo de entrada de imagem para a solicitação do 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}"

Etapa 2: configurar os parâmetros de previsão

Ajuste os seguintes parâmetros para controlar a resposta do modelo:

max_tokens = 64

temperature = 0.5

top_p = 0.95

Etapa 3: preparar a solicitação de previsão

Configure a solicitação de previsão com o URL da imagem, o comando e outros parâmetros.

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

Etapa 4: fazer a previsão

Envie a solicitação para o endpoint da Vertex AI e processe a resposta:

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

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

Se você encontrar um problema de tempo limite (por exemplo, ServiceUnavailable: 503 Took too long to respond when processing), tente reduzir o valor de max_tokens para um número menor, como 20, para reduzir o tempo de resposta.

Inferência com vLLM na Vertex AI usando a conclusão de chat da OpenAI

Esta seção aborda como realizar inferências nos modelos de visão Llama 3.2 usando a API OpenAI Chat Autocomplete na Vertex AI. Essa abordagem permite usar recursos multimodais enviando imagens e comandos de texto para o modelo para respostas mais interativas.

Etapa 1: executar a implantação do modelo de instrução da visão Llama 3.2

Execute a função de implantação com o modelo e as configurações configuradas. A função vai retornar as instâncias do modelo e do endpoint, que podem ser usadas para inferência.

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,
)

Etapa 2: configurar o recurso de endpoint

Comece configurando o nome do recurso de endpoint para a implantação da Vertex AI.

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

Etapa 3: instalar o SDK do OpenAI e as bibliotecas de autenticação

Para enviar solicitações usando o SDK da OpenAI, verifique se as bibliotecas necessárias estão instaladas:

!pip install -qU openai google-auth requests

Etapa 4: definir parâmetros de entrada para a conclusão do chat

Configure o URL da imagem e o comando de texto que serão enviados ao modelo. Ajuste max_tokens e temperature para controlar o tamanho da resposta e a aleatoriedade, 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

Etapa 5: configurar a autenticação e o URL base

Extraia suas credenciais e defina o URL de base para solicitações de 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

Etapa 6: enviar uma solicitação de conclusão de chat

Usando a API Chat Autocomplete da OpenAI, envie a imagem e o comando de texto para o endpoint da 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) Etapa 7: reconectar a um endpoint

Para se reconectar a um endpoint criado anteriormente, use o ID do endpoint. Essa etapa é útil se você quiser reutilizar um endpoint em vez de criar um novo.

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

Essa configuração oferece flexibilidade para alternar entre endpoints recém-criados e existentes conforme necessário, permitindo a simplificação dos testes e da implantação.

Limpeza

Para evitar cobranças contínuas e liberar recursos, exclua os modelos implantados, os endpoints e, opcionalmente, o bucket de armazenamento usado para este experimento.

Etapa 1: excluir endpoints e modelos

O código a seguir desimplanta cada modelo e exclui os endpoints associados:

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

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

Etapa 2: (opcional) excluir o bucket do Cloud Storage

Se você criou um bucket do Cloud Storage especificamente para este experimento, é possível excluí-lo definindo delete_bucket como "True". Esta etapa é opcional, mas recomendada se o bucket não for mais necessário.

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

Ao seguir estas etapas, você garante que todos os recursos usados neste tutorial sejam limpos, reduzindo custos desnecessários associados ao experimento.

Como depurar problemas comuns

Esta seção fornece orientações sobre como identificar e resolver problemas comuns encontrados durante a implantação e inferência de modelos de vLLM na Vertex AI.

Verificar os registros

Verifique os registros para identificar a causa raiz de falhas de implantação ou comportamento inesperado:

  1. Acesse o console de previsão da Vertex AI:acesse o console de previsão da Vertex AI no console do Google Cloud.
  2. Selecionar o endpoint:clique no endpoint com problemas. O status vai indicar se a implantação falhou.
  3. Conferir registros:clique no endpoint e navegue até a guia Registros ou clique em Conferir registros. Isso direciona você ao Cloud Logging, filtrado para mostrar registros específicos desse endpoint e da implantação do modelo. Também é possível acessar os registros diretamente pelo serviço do Cloud Logging.
  4. Analisar os registros:revise as entradas de registro em busca de mensagens de erro, avisos e outras informações relevantes. Confira os carimbos de data/hora para correlacionar as entradas de registro com ações específicas. Procure problemas relacionados a restrições de recursos (memória e CPU), problemas de autenticação ou erros de configuração.

Problema comum 1: falta de memória (OOM) do CUDA durante a implantação

Os erros de falta de memória (OOM) do CUDA ocorrem quando o uso de memória do modelo excede a capacidade disponível da GPU.

No caso do modelo somente de texto, usamos os seguintes argumentos do mecanismo:

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

No caso do modelo multimodal, usamos os seguintes argumentos do mecanismo:

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

A implantação do modelo multimodais com max_num_seqs = 256, como fizemos no caso do modelo somente de texto, pode causar o seguinte erro:

[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 erros de GPU por falta de memória (OOM) Figura 7: registro de erro de GPU sem memória (OOM)

Entenda max_num_seqs e a memória da GPU:

  • O parâmetro max_num_seqs define o número máximo de solicitações simultâneas que o modelo pode processar.
  • Cada sequência processada pelo modelo consome memória da GPU. O uso total de memória é proporcional a max_num_seqs vezes a memória por sequência.
  • Os modelos somente de texto (como o Meta-Llama-3.1-8B) geralmente consomem menos memória por sequência do que os modelos multimodais (como o Llama-3.2-11B-Vision-Instruct), que processam texto e imagens.

Analise o registro de erros (figura 8):

  • O registro mostra um torch.OutOfMemoryError ao tentar alocar memória na GPU.
  • O erro ocorre porque o uso de memória do modelo excede a capacidade disponível da GPU. A GPU NVIDIA L4 tem 24 GB, e definir o parâmetro max_num_seqs muito alto para o modelo multimodal causa um overflow.
  • O registro sugere definir PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True para melhorar o gerenciamento de memória, embora o principal problema aqui seja o uso de memória alto.
Mensagem de erro indicando que a implantação do Llama 3.2 falhou Figura 8: falha na implantação do Llama 3.2
Painel de detalhes da versão do modelo Figura 9: painel de detalhes da versão do modelo

Para resolver esse problema, acesse o console de previsão da Vertex AI e clique no endpoint. O status vai indicar que a implantação falhou. Clique para conferir os registros. Verifique se max-num-seqs = 256. Esse valor é muito alto para Llama-3.2-11B-Vision-Instruct. Um valor mais adequado seria 12.

Problema comum 2: é necessário um token do Hugging Face

Os erros de token de Hugging Face ocorrem quando o modelo é bloqueado e exige credenciais de autenticação adequadas para ser acessado.

A captura de tela a seguir mostra uma entrada de registro no Log Explorer do Google Cloud com uma mensagem de erro relacionada ao acesso ao modelo Meta LLaMA-3.2-11B-Vision hospedado no Hugging Face. O erro indica que o acesso ao modelo está restrito, exigindo autenticação para continuar. A mensagem especifica "Não é possível acessar o repositório restrito para o URL", destacando que o modelo é restrito e exige credenciais de autenticação adequadas para ser acessado. Essa entrada de registro pode ajudar a resolver problemas de autenticação ao trabalhar com recursos restritos em repositórios externos.

Mensagem de erro indicando que um token do Hugging Face é necessário para acessar o modelo Figura 10: erro de token do Hugging Face

Para resolver esse problema, verifique as permissões do token de acesso do Hugging Face. Copie o token mais recente e implante um novo endpoint.

Problema comum 3: modelo de chat necessário

Erros de modelo de chat ocorrem quando o modelo de chat padrão não é mais permitido, e um modelo de chat personalizado precisa ser fornecido se o tokenizer não definir um.

Esta captura de tela mostra uma entrada de registro no Log Explorer do Google Cloud, em que um ValueError ocorre devido à falta de um modelo de chat na versão 4.44 da biblioteca Transformers. A mensagem de erro indica que o modelo de chat padrão não é mais permitido e que um modelo de chat personalizado precisa ser fornecido se o tokenizer não definir um. Esse erro destaca uma mudança recente na biblioteca que exige a definição explícita de um modelo de chat, útil para depurar problemas ao implantar aplicativos baseados em chat.

Mensagem de erro indicando que um modelo de chat é necessário para acessar o modelo Figura 11: modelo de chat necessário

Para contornar esse problema, forneça um modelo de chat durante a implantação usando o argumento de entrada --chat-template. Os modelos de exemplo podem ser encontrados no repositório de exemplos de vLLM.

Problema comum 4: modelo de comprimento máximo de sequência

Erros de comprimento máximo da sequência do modelo ocorrem quando o comprimento máximo da sequência do modelo (4096) é maior do que o número máximo de tokens que podem ser armazenados no cache KV (2256).

Modelo de comprimento máximo de sequência Figura 12: Comprimento máximo de sequência muito grande

ValueError: o comprimento máximo da sequência do modelo (4096) é maior do que o número máximo de tokens que podem ser armazenados no cache KV (2256). Tente aumentar gpu_memory_utilization ou diminuir max_model_len ao inicializar o mecanismo.

Para resolver esse problema, defina max_model_len 2048, que é menor que 2256. Outra solução para esse problema é usar mais GPUs ou GPUs maiores. O tensor-parallel-size precisa ser definido de maneira adequada se você optar por usar mais GPUs.