Llama 4 mit vLLM: Ein Leitfaden mit Demo-Projekt

Die neuesten LLaMA 4-Modelle von Meta, Scout und Maverick, sind für Long-Context-Reasoning, multimodales Verstehen und effiziente Inferenz in großem Maßstab ausgelegt. In Verbindung mit vLLM, einer durchsatzstarken Inferenzmaschine mit OpenAI-kompatiblen APIs, werden diese Modelle für reale Anwendungen praktisch.

In diesem Blogpost zeige ich dir, wie du LLaMA 4 Scout auf einer Multi-GPU-RunPod-Instanz mit vLLM einsetzt und über einen lokalen oder entfernten OpenAI-kompatiblen API-Endpunkt bereitstellst. Wir behandeln die Einrichtung des Modells, den Einsatz und die API-Interaktion mit Text- und Bildeingaben.

Am Ende dieses Tutorials wirst du auch zwei vollständige Demos haben:

1. Demo zur Textvervollständigung: Eine einfache Schnittstelle, um mit LLaMA 4 über OpenAI-kompatiblen Python-Code zu chatten und Langkontext-Fähigkeiten zu erkunden.
2. Multimodale Vision Demo: Eine Schnittstelle, die sowohl Text- als auch Bildeingaben mit Hilfe der multimodalen Unterstützung von vLLM akzeptiert und geerdete Visual Reasoning-Antworten von LLaMA 4 zurückgibt.

Wir halten unsere Leserinnen und Leser mit The Median auf dem Laufenden, unserem kostenlosen Freitags-Newsletter, der die wichtigsten Meldungen der Woche aufschlüsselt. Melde dich an und bleibe in nur ein paar Minuten pro Woche auf dem Laufenden:

Warum LLaMA 4 auf vLLM verwenden?

vLLM (virtual large language model) ist ein optimiertes LLM-Inferenz-Framework, das ursprünglich am Sky Computing Lab der UC Berkeley entwickelt wurde. Es führt PagedAttention ein, ein neuartiges Speichermanagement-System, das die Fragmentierung des GPU-Speichers minimiert und ein effizientes Key-Value-Caching für extrem lange Sequenzen ermöglicht. Wenn du mehr erfahren möchtest, schau dir dieses Tutorial über vLLM.

Hier erfährst du, warum vLLM die ideale Engine für LLaMA 4 ist:

1. Hoher Durchsatz, niedrige Latenz: Der ausgelagerte KV-Cache der vLLM ermöglicht eine effiziente Inferenz, selbst bei langem Kontext.
2. Multimodal und kontextübergreifend: Es unterstützt sowohl Bilder als auch bis zu 10M Token-Kontext für das Scout-Modell.
3. OpenAI-kompatibel: Du kannst die OpenAI SDKs und Tools ohne Änderungen verwenden.
4. Skalierbar und GPU-effizient: vLLM nutzt mehrere GPUs - einschließlich H100, A100 und MI300X - und setzt Tensor- und Speicherparallelität für Inferenzen mit hohem Durchsatz ein.

Hosten von LLaMA 4 Scout auf RunPod mit vLLM

In diesem Abschnitt zeigen wir dir, wie du eine leistungsstarke Multi-GPU-Instanz auf RunPod bereitstellst, das LLaMA 4 Scout-Modell von Meta mit vLLM einsetzt und eine OpenAI-kompatible API für lokale und entfernte Inferenzen bereitstellst.

Schritt 1: Richte deine RunPod-Umgebung ein 

Bevor du das Modell startest, stelle sicher, dass dein RunPod-Konto eingerichtet ist:

• Einloggen bei RunPod.io und konfiguriere deine Abrechnung.
• Füge mindestens 25 $ zu deinem Guthaben hinzu, um sicherzustellen, dass du für die Dauer dieses Projekts große GPU-Instanzen betreiben kannst.

Schritt 2: Einsatz eines Pods mit H100 NVL-GPUs

Jetzt wollen wir einen Pod bereitstellen, der das 17B LLaMA 4 Scout Modell aufnehmen kann:

1. Gehe in den Bereich Pods und klicke auf "Pods bereitstellen".
2. Filtere die GPUs nach VRAM, setze das Minimum auf 80 GB und wähle die Option H100 NVL. Hinweis: LLaMA 4 Scout benötigt mindestens 24 GB VRAM. Für eine optimale Leistung werden wir 4x H100 NVL verwenden.

3. Scrolle nach unten und gib deinem Pod einen Namen wie "LLAMA4_DEMO".
4. Klicke unter Vorlage auf "Vorlage ändern" und wähle PyTorch 2.4.0.
5. Klicke auf "Vorlage bearbeiten", setze sowohl die Container-Festplatte als auch die Volume-Festplatte auf 1000 GB und wende Überschreibungen an.
6. (Optional) Füge dein Hugging Face-Zugangs-Token zu den Umgebungsvariablen für Modell-Downloads hinzu.

7. Setze die Anzahl der GPUs auf 4 und klicke dann auf "On-Demand bereitstellen".

Warte ein paar Minuten, bis der Pod provisioniert ist.

Schritt 3: Verbinde dich mit deinem Pod

Sobald die Schaltfläche "Verbinden" lila wird, klicke sie an. Du wirst mehrere Verbindungsoptionen sehen - du kannst entweder:

• Öffne ein JupyterLab-Terminal, um Shell-Befehle auszuführen.
• Oder verwende SSH- oder HTTP-Ports, wenn du eine Fernsteuerung möchtest.

Schritt 4: Installiere vLLM und die erforderlichen Bibliotheken

Installiere im Terminal deines Pods vLLM und seine Abhängigkeiten. Installiere vLLM und andere Bibliotheken innerhalb der Pod-Umgebung.

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

Schritt 5: LLaMA 4 Scout auf vLLM ausführen

Als Nächstes starten wir den LLaMA 4 Scout Modellserver mit dem folgenden Befehl:

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}'

Dieser Befehl macht Folgendes:

• Sie deaktiviert den vLLM-Compile-Cache für einen schnelleren Start.
• Führe das Modell auf 4 GPUs aus und verwende dabei Tensor-Parallelität.
• Dann wird aufgrund von Speicherbeschränkungen eine maximale Kontextlänge von 100.000 Token festgelegt. Hinweis - Wenn du das Modell mit einer Kontextlänge von 10M betreiben willst, brauchst du mindestens 8 x H100 GPUs.
• Sie ermöglicht die Einstellung der Aufmerksamkeitstemperatur, um die Genauigkeit bei der Inferenz von langen Kontexten zu verbessern.

Jetzt, wo deine API auf Port 8000 läuft, erstellst du ein neues Jupyter Notebook in derselben Pod-Umgebung.

Textvervollständigung mit Llama 4 Scout

In dieser Demo werden wir mit einem einfachen Python-Skript mit dem lokal gehosteten LLaMA 4 Scout-Modell interagieren, das über vLLM bereitgestellt wird. Das Modell wird über eine API offengelegt, die es uns ermöglicht, einen Gesprächsassistenten zu entwickeln, der den Dialog mit mehreren Gesprächspartnern unterstützt.

Schritt 1: Voraussetzungen

Wir verwenden das offizielle OpenAI Python SDK, um mit der vLLM API zu kommunizieren, und die Colorama-Bibliothek für die farbige Terminalausgabe. Du kannst beides mit installieren:

pip install openai colorama

Nach der Installation importierst du die erforderlichen Module:

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

Schritt 2: Initialisiere den Client

Wir konfigurieren den OpenAI-Client so, dass er auf unseren lokal laufenden vLLM-Server zeigt. Wenn dein Einsatz keinen API-Schlüssel erfordert (das ist das Standardverhalten für lokale Läufe), gib "EMPTY" als Schlüssel an:

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

Dieser Code initialisiert die Colorama-Bibliothek für die farbige Terminalausgabe mit einem automatischen Reset nach jedem Druck. Anschließend wird ein OpenAI-kompatibler Client mit der OpenAI-Klasse eingerichtet, der auf eine lokal gehostete vLLM-API verweist.

Schritt 3: Start der Chatschleife

Als Nächstes implementieren wir eine einfache Schleife, um eine kontinuierliche Interaktion mit dem Modell zu ermöglichen. Der Gesprächsverlauf bleibt über mehrere Runden hinweg erhalten, so dass der Dialog über mehrere Runden hinweg geführt werden kann.

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

Ein einfaches terminalbasiertes Chat-Interface wird mit einem Gesprächsverlauf und einem Systemprompt initialisiert, das kontinuierlich Benutzereingaben in einer Schleife entgegennimmt. Jede Nutzernachricht wird an den Nachrichtenverlauf angehängt und über den API-Aufruf client.chat.completions.create() an das Modell Llama-4-Scout-17B-16E-Instruct gesendet.

Die Antwort des Modells wird mit Colorama in grüner Farbe gedruckt und dem Nachrichtenverlauf hinzugefügt, so dass ein Dialog mit mehreren Umdrehungen möglich ist, bis der Benutzer "exit" oder "quit" eingibt.

Im nächsten Abschnitt werden wir untersuchen, wie man multimodale Inferenzen mit Bild- und Texteingaben über dieselbe API durchführen kann.

Multimodale Bild- und Textinferenz mit LLaMA 4 Scout

In dieser Demo zeigen wir dir, wie du sowohl Bild- als auch Texteingaben an das LLaMA 4 Scout-Modell senden kannst, das über vLLM gehostet wird und dessen native multimodale Fähigkeiten nutzt. Damit kannst du visuelles Reasoning, Bildunterschriften oder multimodale Fragen und Antworten durchführen - alles über eine einzige OpenAI-kompatible API.

Schritt 1: Voraussetzungen

In diesem Beispiel wird das OpenAI SDK als Schnittstelle zum vLLM-Server verwendet. Wenn du es noch nicht installiert hast, kannst du es ausführen:

pip install openai

Importiere dann das gewünschte Modul: 

from openai import OpenAI

Schritt 2: Den API-Client einrichten

Verbinde dich mit deinem lokalen vLLM-Server über die OpenAI-kompatible Schnittstelle. Wenn dein Server keine Authentifizierung verlangt, verwende "EMPTY" als API-Schlüssel.

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

Das obige Codeschnipsel initialisiert einen OpenAI-kompatiblen Client für lokale Inferenzen mit dem vLLM-Server. api_key ist auf "EMPTY" gesetzt (keine Anmeldung erforderlich) und base_url verweist auf den lokalen vLLM-API-Endpunkt.

Schritt 3: Eine multimodale Aufforderung einreichen

Wir senden jetzt eine Chat-Aufforderung, die sowohl ein Bild als auch eine Textanweisung enthält. LLaMA 4 Scout verarbeitet das Bild zusammen mit der Abfrage und gibt eine beschreibende Antwort zurück.

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)

Nachdem die multimodale Inferenz mit dem LLaMA 4 Scout-Modell durchgeführt wurde, erstellen wir eine Chat-Eingabe, die sowohl eine Bild-URL als auch eine Textaufforderung enthält, die nach dem OpenAI-Chat-Schema formatiert sind. Die Methode client.chat.completions.create() wird verwendet, um diese multimodale Anfrage an das Modell zu senden, das das Bild und den dazugehörigen Text verarbeitet, um eine kontextbezogene Antwort zu generieren.

Fazit

In diesem Tutorial haben wir das LLaMA 4 Scout-Modell von Meta mit vLLM auf RunPod gehostet und es über OpenAI-kompatible Endpunkte für Text- und multimodale Inferenzen zugänglich gemacht. Durch die Kombination des hohen Durchsatzes von vLLM und der leistungsstarken Infrastruktur von RunPod haben wir ein kosteneffizientes Setup für die Bedienung moderner LLMs mit langen Kontext- und Vision-Fähigkeiten geschaffen.

Wenn du mehr über LLaMA 4 und vLLM erfahren möchtest, schau mal rein:

• Llama 4 Übersicht
• Llama 4 offizielle Modellkarte
• vLLM GitHub
• Ungeschliffene Quantisierungsverfahren