Llama 4 com vLLM: Um guia com projeto de demonstração

Os modelos LLaMA 4 mais recentes da Meta, Scout e Maverick, foram desenvolvidos para raciocínio de contexto longo, compreensão multimodal e inferência eficiente em escala. Quando combinados com o vLLM, um mecanismo de inferência de alto rendimento com APIs compatíveis com OpenAI, esses modelos se tornam práticos para aplicativos do mundo real.

Nesta postagem do blog, mostrarei a você como implantar o LLaMA 4 Scout em uma instância RunPod com várias GPUs usando o vLLM e como servi-lo por meio de um endpoint de API local ou remoto compatível com OpenAI. Abordaremos a configuração do modelo, a implantação e a interação com a API usando entradas de texto e imagem.

Ao final deste tutorial, você também terá duas demonstrações completas:

1. Demonstração de conclusão de texto: Uma interface simples para você conversar com o LLaMA 4 usando código Python compatível com OpenAI e explorar recursos de contexto longo.
2. Demonstração de visão multimodal: Uma interface que aceita entradas de texto e imagem usando o suporte multimodal do vLLM e retorna respostas de raciocínio visual fundamentadas do LLaMA 4.

Mantemos nossos leitores atualizados sobre as últimas novidades em IA enviando o The Median, nosso boletim informativo gratuito de sexta-feira que detalha as principais histórias da semana. Inscreva-se e fique atento em apenas alguns minutos por semana:

Por que usar o LLaMA 4 no vLLM?

O vLLM (virtual large language model) é uma estrutura de inferência LLM otimizada, desenvolvida originalmente no Sky Computing Lab da UC Berkeley, que apresenta o PagedAttention, um novo sistema de gerenciamento de memória que minimiza a fragmentação da memória da GPU e permite o armazenamento em cache eficiente de valores-chave para sequências extremamente longas. Para saber mais, confira este tutorial sobre vLLM.

Veja por que o vLLM é o mecanismo ideal para atender ao LLaMA 4:

1. Alta taxa de transferência, baixa latênciaO cache KV paginado do vLLM permite uma inferência eficiente, mesmo com contexto longo.
2. Pronto para multimodais e de contexto longo: Ele suporta imagens e até 10 milhões de tokens de contexto para o modelo Scout.
3. Compatível com OpenAI: Você pode usar os SDKs e as ferramentas da OpenAI sem modificações.
4. Dimensionável e eficiente em termos de GPUO vLLM aproveita totalmente várias GPUs, incluindo H100, A100 e MI300X, usando tensor e paralelismo de memória para inferência de alto rendimento.

Hospedando o LLaMA 4 Scout no RunPod com o vLLM

Nesta seção, veremos como provisionar uma instância avançada de várias GPUs no RunPod, implantar o modelo LLaMA 4 Scout do Meta usando o vLLM e expor uma API compatível com OpenAI para inferência local e remota.

Etapa 1: Configure seu ambiente RunPod 

Antes de iniciar o modelo, certifique-se de que sua conta RunPod esteja configurada:

• Faça login no RunPod.io e configure sua cobrança.
• Adicione pelo menos US$ 25 ao seu saldo para garantir que você possa executar instâncias grandes de GPU durante a duração deste projeto.

Etapa 2: Implantar um pod com GPUs H100 NVL

Agora, vamos fornecer um pod capaz de hospedar o modelo 17B LLaMA 4 Scout:

1. Vá para a seção Pods e clique em "Deploy a Pod".
2. Filtre as GPUs por VRAM, definindo o mínimo como 80 GB, e selecione a opção H100 NVL. Observação: O LLaMA 4 Scout requer pelo menos 24 GB de VRAM. Para obter o desempenho ideal, usaremos 4x H100 NVL.

3. Role para baixo e dê ao seu pod um nome como "LLAMA4_DEMO".
4. Em Template (Modelo), clique em "Change Template" (Alterar modelo) e selecione PyTorch 2.4.0.
5. Clique em "Edit Template" (Editar modelo), defina o disco do contêiner e o disco do volume como 1000 GB e aplique as substituições.
6. (Opcional) Adicione seu token de acesso Hugging Face às variáveis de ambiente para downloads de modelos.

7. Defina a contagem de GPUs como 4 e, em seguida, clique em "Deploy On-Demand".

Aguarde alguns minutos para que o pod seja provisionado.

Etapa 3: Conecte-se ao seu pod

Quando o botão "Connect" ficar roxo, clique nele. Você verá várias opções de conexão - você pode:

• Abra um terminal do JupyterLab para executar comandos do shell.
• Ou use portas SSH ou HTTP se você quiser controle remoto.

Etapa 4: Instale o vLLM e as bibliotecas necessárias

No terminal dentro de seu pod, instale o vLLM e suas dependências. Instale o vLLM e outras bibliotecas dentro do ambiente do pod.

pip install -U vllm
pip install transformers accelerate pillow #optional

Etapa 5: Execute o LLaMA 4 Scout no vLLM

Em seguida, iniciamos o servidor do modelo LLaMA 4 Scout usando o seguinte comando:

VLLM_DISABLE_COMPILE_CACHE=1 vllm serve meta-llama/Llama-4-Scout-17B-16E-Instruct \
--tensor-parallel-size 4 \
--max-model-len 100000 --override-generation-config='{"attn_temperature_tuning": true}'

Esse comando faz o seguinte:

• Desativa o cache de compilação do vLLM para acelerar a inicialização.
• Execute o modelo em 4 GPUs usando o paralelismo de tensor.
• Em seguida, ele define um comprimento máximo de contexto de 100.000 tokens devido a restrições de memória. Observação - Se você quiser executar o modelo com um comprimento de contexto de 10M, precisará de pelo menos 8 GPUs H100.
• Ele permite a configuração do ajuste da temperatura de atenção para melhorar a precisão na inferência de contexto longo.

Agora que sua API está sendo executada na porta 8000, crie um novo Jupyter Notebook no mesmo ambiente de pod.

Conclusão de texto com o Llama 4 Scout

Nesta demonstração, vamos interagir com o modelo LLaMA 4 Scout hospedado localmente e servido via vLLM usando um script Python simples. O modelo é exposto por meio da API, o que nos permite criar um assistente de conversação que ofereça suporte a diálogos com várias voltas.

Etapa 1: Pré-requisitos

Usaremos o SDK oficial do Python da OpenAI para nos comunicarmos com a API vLLM e a biblioteca Colorama para a saída colorida do terminal. Você pode instalar ambos usando:

pip install openai colorama

Depois de instalado, importe os módulos necessários:

from openai import OpenAI
from colorama import Fore, Style, init

Etapa 2: Inicializar o cliente

Configuramos o cliente OpenAI para apontar para o nosso servidor vLLM em execução local. Se a sua implantação não exigir uma chave de API (o comportamento padrão para execuções locais), passe "EMPTY" como a chave:

# Initialize colorama
init(autoreset=True)
# Set up client
openai_api_key = "EMPTY"  
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

Esse código inicializa a biblioteca Colorama para a saída colorida do terminal com uma redefinição automática após cada impressão. Em seguida, ele configura um cliente compatível com OpenAI usando a classe OpenAI, apontando para uma API vLLM hospedada localmente.

Etapa 3: Iniciar o loop de bate-papo

Em seguida, implementamos um loop simples para permitir a interação contínua com o modelo. O histórico da conversa é preservado em todos os turnos, permitindo o comportamento de diálogo em vários turnos.

# Initialize message history
messages = [
    {"role": "system", "content": "You are a helpful assistant."}
]
print("Start chatting with the assistant! Type 'exit' or 'quit' to end.\n")
while True:
    user_input = input(f"{Fore.BLUE}User: {Style.RESET_ALL}")
    if user_input.strip().lower() in ["exit", "quit"]:
        print("Exiting chat. Goodbye!")
        break
    messages.append({"role": "user", "content": user_input})
    chat_response = client.chat.completions.create(
        model="meta-llama/Llama-4-Scout-17B-16E-Instruct",
        messages=messages,
    )
    assistant_message = chat_response.choices[0].message.content
    print(f"{Fore.GREEN}Assistant: {assistant_message}\n{Style.RESET_ALL}")
    messages.append({"role": "assistant", "content": assistant_message})

Uma interface de bate-papo simples baseada em terminal é inicializada com um histórico de conversas e um prompt do sistema que aceita continuamente a entrada do usuário em um loop. Cada mensagem do usuário é anexada ao histórico de mensagens e enviada ao modelo Llama-4-Scout-17B-16E-Instruct por meio da chamada à API client.chat.completions.create().

A resposta do modelo é impressa em verde usando Colorama e adicionada novamente ao histórico de mensagens, permitindo um diálogo de várias voltas até que o usuário digite "sair" ou "quit".

Na próxima seção, exploraremos como executar a inferência multimodal com entradas de imagem + texto usando a mesma API.

Inferência de texto e imagem multimodal com o escoteiro LLaMA 4

Nesta demonstração, exploraremos como enviar entradas de imagem e texto para o modelo do LLaMA 4 Scout hospedado via vLLM usando seus recursos multimodais nativos. Isso permite que você execute raciocínio visual, legendagem de imagens ou perguntas e respostas multimodais, tudo por meio de uma única API compatível com OpenAI.

Etapa 1: Pré-requisitos

Este exemplo usa o OpenAI SDK para fazer a interface com o servidor vLLM. Se ainda não estiver instalado, você pode executar:

pip install openai

Em seguida, importe o módulo necessário: 

from openai import OpenAI

Etapa 2: Configurar o cliente de API

Conecte-se ao seu servidor vLLM local usando a interface compatível com OpenAI. Se o seu servidor não exigir autenticação, use "EMPTY" como a chave da API.

openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8000/v1"
client = OpenAI(
    api_key=openai_api_key,
    base_url=openai_api_base,
)

O trecho de código acima inicializa um cliente compatível com OpenAI para inferência local usando o servidor vLLM. O endereço api_key está definido como "EMPTY" (sem necessidade de autenticação) e base_url aponta para o endpoint local da API vLLM.

Etapa 3: Enviar um prompt multimodal

Agora enviaremos um prompt de bate-papo que inclui uma imagem e uma instrução de texto. O LLaMA 4 Scout processará a imagem juntamente com a consulta e retornará uma resposta descritiva.

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image_url", "image_url": {"url": image_url1}},
            {"type": "text", "text": "Can you describe what's in this image?"}
        ]
    }
]
chat_response = client.chat.completions.create(
    model="meta-llama/Llama-4-Scout-17B-16E-Instruct",  
    messages=messages,
)
print("Response:", chat_response.choices[0].message.content)

Depois que a inferência multimodal usando o modelo LLaMA 4 Scout é atendida, criamos uma entrada no estilo de bate-papo contendo um URL de imagem e um prompt de texto, formatados de acordo com o esquema de bate-papo da OpenAI. O método client.chat.completions.create() é usado para enviar essa solicitação multimodal ao modelo, que processa a imagem e o texto que a acompanha para gerar uma resposta contextual.

Conclusão

Neste tutorial, hospedamos o modelo LLaMA 4 Scout do Meta usando vLLM no RunPod, tornando-o acessível por meio de pontos de extremidade compatíveis com OpenAI para inferência de texto e multimodal. Ao combinar o alto rendimento do vLLM e a infraestrutura avançada do RunPod, criamos uma configuração econômica para atender a LLMs de última geração com recursos de visão e contexto longos.

Para saber mais sobre o LLaMA 4 e o vLLM, confira:

• Visão geral do Llama 4
• Cartão do modelo oficial do Llama 4
• vLLM GitHub
• Técnicas de quantização sem suavização