Llama 4 con vLLM: guida con progetto demo

Gli ultimi modelli LLaMA 4 di Meta, Scout e Maverick, sono progettati per il ragionamento su lunghi contesti, la comprensione multimodale e un'inferenza efficiente su larga scala. Insieme a vLLM, un motore di inferenza ad alto throughput con API compatibili con OpenAI, questi modelli diventano pratici per applicazioni reali.

In questo post, ti mostrerò come distribuire LLaMA 4 Scout su un'istanza RunPod multi‑GPU usando vLLM e servirlo tramite un endpoint API compatibile con OpenAI locale o remoto. Vedremo configurazione del modello, deployment e interazione via API usando sia input testuali che di immagini.

Al termine di questo tutorial avrai anche due demo complete:

1. Demo di completamento testo: un'interfaccia semplice per chattare con LLaMA 4 usando codice Python compatibile con OpenAI ed esplorare le capacità su lunghi contesti.
2. Demo multimodale di visione: un'interfaccia che accetta sia testo che immagini grazie al supporto multimodale di vLLM e restituisce risposte di ragionamento visivo basate su LLaMA 4.

Teniamo i nostri lettori aggiornati sulle ultime novità dell'AI con The Median, la nostra newsletter gratuita del venerdì che riepiloga le storie chiave della settimana. Iscriviti e resta sul pezzo in pochi minuti a settimana:

Perché usare LLaMA 4 su vLLM?

vLLM (virtual large language model) è un framework di inferenza per LLM ottimizzato, sviluppato originariamente allo Sky Computing Lab di UC Berkeley, che introduce PagedAttention, un nuovo sistema di gestione della memoria che riduce la frammentazione della memoria GPU e consente un caching efficiente delle key‑value per sequenze estremamente lunghe. Per saperne di più, dai un'occhiata a questo tutorial su vLLM.

Ecco perché vLLM è il motore ideale per servire LLaMA 4:

1. Alto throughput, bassa latenza: la cache KV paginata di vLLM abilita un'inferenza efficiente, anche con contesti lunghi.
2. Pronto per multimodale e lunghi contesti: supporta sia le immagini sia fino a 10M token di contesto per il modello Scout.
3. Compatibile con OpenAI: puoi usare SDK e strumenti OpenAI senza modifiche.
4. Scalabile ed efficiente su GPU: vLLM sfrutta appieno più GPU—incluse H100, A100 e MI300X—usando parallelismo dei tensori e della memoria per un'inferenza ad alto throughput.

Hosting di LLaMA 4 Scout su RunPod con vLLM

In questa sezione vedremo come predisporre una potente istanza multi‑GPU su RunPod, distribuire il modello LLaMA 4 Scout di Meta con vLLM ed esporre un'API compatibile con OpenAI sia per inferenza locale che remota.

Passo 1: configura l'ambiente RunPod 

Prima di avviare il modello, assicurati che il tuo account RunPod sia configurato:

• Accedi a RunPod.io e configura la fatturazione.
• Aggiungi almeno 25 $ al tuo saldo per assicurarti di poter eseguire istanze GPU di grandi dimensioni per tutta la durata di questo progetto.

Passo 2: distribuisci un pod con GPU H100 NVL

Ora predisponiamo un pod in grado di ospitare il modello LLaMA 4 Scout da 17B:

1. Vai alla sezione Pods e clicca su “Deploy a Pod”.
2. Filtra le GPU per VRAM impostando il minimo a 80 GB e seleziona l'opzione H100 NVL. Nota: LLaMA 4 Scout richiede almeno 24 GB di VRAM. Per prestazioni ottimali useremo 4x H100 NVL.

3. Scorri verso il basso e dai un nome al tuo pod, ad esempio “LLAMA4_DEMO”.
4. Sotto Template, clicca “Change Template” e seleziona PyTorch 2.4.0.
5. Clicca “Edit Template”, imposta sia Container Disk che Volume Disk a 1000 GB e applica gli override.
6. (Opzionale) Aggiungi il tuo token di accesso Hugging Face alle variabili d'ambiente per scaricare i modelli.

7. Imposta GPU Count a 4, quindi clicca “Deploy On-Demand”.

Attendi qualche minuto per il provisioning del pod.

Passo 3: connetti il tuo pod

Quando il pulsante “Connect” diventa viola, cliccalo. Vedrai più opzioni di connessione—puoi:

• Aprire un terminale JupyterLab per eseguire comandi shell.
• Oppure usare porte SSH o HTTP se vuoi il controllo remoto.

Passo 4: installa vLLM e le librerie richieste

Nel terminale dentro il tuo pod, installa vLLM e le sue dipendenze. Installa vLLM e le altre librerie nell'ambiente del pod.

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

Passo 5: esegui LLaMA 4 Scout su vLLM

Ora avviamo il server del modello LLaMA 4 Scout usando il seguente 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}'

Questo comando fa quanto segue:

• Disabilita la compile cache di vLLM per un avvio più rapido.
• Esegue il modello su 4 GPU usando il parallelismo dei tensori.
• Imposta poi una lunghezza massima del contesto di 100.000 token per vincoli di memoria. Nota: se vuoi eseguire il modello con un contesto da 10M, ti servono almeno 8 x H100 GPU.
• Abilita la configurazione di attention temperature tuning per migliorare l'accuratezza nell'inferenza su lunghi contesti.

Ora che la tua API è in esecuzione sulla porta 8000, crea un nuovo Jupyter Notebook nello stesso ambiente del pod.

Completamento di testo con Llama 4 Scout

In questa demo interagiremo con il modello LLaMA 4 Scout ospitato in locale e servito via vLLM usando un semplice script Python. Il modello è esposto tramite API, permettendoci di costruire un assistente conversazionale che supporta dialoghi multi‑turno.

Passo 1: prerequisiti

Useremo l'SDK Python ufficiale di OpenAI per comunicare con l'API vLLM e la libreria Colorama per output colorati in terminale. Puoi installarli entrambi con:

pip install openai colorama

Una volta installati, importa i moduli necessari:

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

Passo 2: inizializza il client

Configuriamo il client OpenAI per puntare al nostro server vLLM in esecuzione locale. Se il tuo deployment non richiede una chiave API (comportamento predefinito per esecuzioni locali), passa "EMPTY" come chiave:

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

Questo codice inizializza la libreria Colorama per l'output colorato in terminale con reset automatico dopo ogni print. Quindi configura un client compatibile con OpenAI usando la classe OpenAI, puntando a un'API vLLM ospitata in locale.

Passo 3: avvia il loop di chat

Implementiamo quindi un semplice loop per consentire un'interazione continua con il modello. La cronologia della conversazione viene mantenuta tra i turni, abilitando un comportamento di dialogo multi‑turno.

# 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})

Viene inizializzata una semplice interfaccia da terminale con una cronologia della conversazione e un prompt di sistema che accetta continuamente input dell'utente in un loop. Ogni messaggio dell'utente viene aggiunto alla cronologia e inviato al modello Llama-4-Scout-17B-16E-Instruct tramite la chiamata API client.chat.completions.create().

La risposta del modello viene stampata in verde usando Colorama e aggiunta alla cronologia, consentendo un dialogo multi‑turno finché l'utente non digita "exit" o "quit".

Nella prossima sezione, vedremo come eseguire inferenza multimodale con input immagine + testo usando la stessa API.

Inferenza multimodale immagine e testo con LLaMA 4 Scout

In questa demo esploreremo come inviare sia immagini che testo al modello LLaMA 4 Scout ospitato via vLLM usando le sue capacità multimodali native. Questo ti consente di effettuare ragionamento visivo, image captioning o Q&A multimodale—tutto tramite un'unica API compatibile con OpenAI.

Passo 1: prerequisiti

Questo esempio usa l'SDK OpenAI per interfacciarsi con il server vLLM. Se non è già installato, esegui:

pip install openai

Quindi importa il modulo richiesto: 

from openai import OpenAI

Passo 2: configura il client API

Connettiti al tuo server vLLM locale usando l'interfaccia compatibile con OpenAI. Se il server non richiede autenticazione, usa "EMPTY" come chiave API.

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

Il codice sopra inizializza un client compatibile con OpenAI per l'inferenza locale usando il server vLLM. La api_key è impostata a "EMPTY" (nessuna auth richiesta) e base_url punta all'endpoint API vLLM locale.

Passo 3: invia un prompt multimodale

Ora invieremo un prompt di chat che include sia un'immagine che un'istruzione testuale. LLaMA 4 Scout elaborerà l'immagine insieme alla richiesta e restituirà una risposta descrittiva.

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)

Una volta servita l'inferenza multimodale con il modello LLaMA 4 Scout, costruiamo un input in stile chat contenente sia un URL di immagine che un prompt testuale, formattato secondo lo schema chat di OpenAI. Il metodo client.chat.completions.create() viene usato per inviare questa richiesta multimodale al modello, che elabora l'immagine e il testo associato per generare una risposta contestualizzata.

Conclusione

In questo tutorial abbiamo ospitato il modello LLaMA 4 Scout di Meta usando vLLM su RunPod, rendendolo accessibile tramite endpoint compatibili con OpenAI sia per inferenza testuale che multimodale. Combinando l'alto throughput di vLLM e la potente infrastruttura di RunPod, abbiamo creato un setup conveniente per servire LLM all'avanguardia con lunghi contesti e capacità di visione.

Per saperne di più su LLaMA 4 e vLLM, dai un'occhiata a:

• Panoramica di Llama 4
• Scheda modello ufficiale di Llama 4
• vLLM su GitHub
• Tecniche di quantizzazione Unsloth