Was ist vLLM? vLLM installieren und verwenden, erklärt

```html

Willkommen zum umfassenden Leitfaden zu vLLM! Wenn Sie in der Welt der Large Language Models (LLMs) tätig sind, sind Sie wahrscheinlich auf die Herausforderungen der Inferenzgeschwindigkeit und des Durchsatzes gestoßen. Das effiziente Bedienen dieser massiven Modelle kann zu einem Engpass werden. Hier kommt vLLM als bahnbrechende Lösung ins Spiel. Dieses Tutorial führt Sie durch alles, was Sie als Anfänger wissen müssen: was vLLM ist, warum es wichtig ist, wie man es installiert und wie man es sowohl für die Offline-Stapelverarbeitung als auch für das Online-Serving verwendet.

Was genau ist vLLM?

Im Kern ist vLLM eine Bibliothek mit hohem Durchsatz und speichereffizient, die speziell für die Inferenz und das Serving von Large Language Models (LLMs) entwickelt wurde. Entwickelt von Forschern und Ingenieuren mit dem Ziel, die Leistungsgrenzen bestehender Serving-Systeme zu überwinden, beschleunigt vLLM den Prozess der Gewinnung von Vorhersagen (Inferenz) aus LLMs erheblich.

Traditionelle Methoden für die LLM-Inferenz haben oft Schwierigkeiten mit der Verwaltung des großen Speicherbedarfs des Aufmerksamkeit-Mechanismus des Modells (insbesondere des KV-Cache) und der effizienten Stapelverarbeitung eingehender Anfragen. vLLM führt neuartige Techniken ein, insbesondere PagedAttention, um diese Herausforderungen direkt anzugehen. Es ermöglicht einen viel höheren Durchsatz (mehr Anfragen pro Sekunde) und kann Modelle schneller und kostengünstiger bedienen als viele Standard-Hugging Face Transformers-Implementierungen oder andere Serving-Frameworks, wenn es um gleichzeitige Anfragen geht.

Stellen Sie sich vLLM als einen hochoptimierten Motor für die Ausführung vortrainierter LLMs vor. Sie stellen das Modell und die Prompts bereit, und vLLM übernimmt die komplexe Aufgabe, Text schnell und effizient zu generieren, sei es für einen einzelnen großen Stapel von Prompts oder für viele gleichzeitige Benutzer, die mit einem bereitgestellten Modell interagieren.

Warum vLLM für die LLM-Inferenz wählen?

Mehrere überzeugende Gründe machen vLLM zu einer bevorzugten Wahl für Entwickler und Organisationen, die mit LLMs arbeiten:

1. State-of-the-Art-Leistung: vLLM liefert einen deutlich höheren Durchsatz im Vergleich zu vielen Basisimplementierungen. Dies bedeutet, dass Sie mehr Benutzeranfragen gleichzeitig bearbeiten oder große Datensätze mit derselben Hardware schneller verarbeiten können.
2. Effizientes Speichermanagement: Die Kerninnovation, PagedAttention, reduziert die Speicherverschwendung drastisch, indem der KV-Cache effektiver verwaltet wird. Dies ermöglicht es Ihnen, größere Modelle auf Ihre GPUs zu passen oder bestehende Modelle mit weniger Speicheraufwand zu bedienen, wodurch möglicherweise die Hardwarekosten gesenkt werden.
3. Kontinuierliches Batching: Im Gegensatz zum statischen Batching (bei dem der Server auf einen vollen Batch wartet, bevor er ihn verarbeitet) verwendet vLLM kontinuierliches Batching. Es verarbeitet Anfragen dynamisch, sobald sie eintreffen, wodurch die GPU-Auslastung erheblich verbessert und die Latenz für einzelne Anfragen reduziert wird.
4. OpenAI-kompatibler Server: vLLM enthält einen integrierten Server, der die OpenAI-API nachahmt. Dies macht es unglaublich einfach, vLLM als Drop-in-Ersatz für Anwendungen zu verwenden, die bereits mit dem OpenAI Python-Client oder kompatiblen Tools erstellt wurden. Sie können oft Ihre Endpoint-URL und Ihren API-Schlüssel wechseln, und Ihr vorhandener Code funktioniert mit Ihrer selbst gehosteten vLLM-Instanz.
5. Benutzerfreundlichkeit: Trotz seiner ausgeklügelten Interna bietet vLLM eine relativ einfache API sowohl für die Offline-Inferenz (LLM-Klasse) als auch für das Online-Serving (vllm serve-Befehl).
6. Breite Modellkompatibilität: vLLM unterstützt eine breite Palette beliebter Open-Source-LLMs, die auf dem Hugging Face Hub (und möglicherweise ModelScope) verfügbar sind.
7. Aktive Entwicklung und Community: vLLM ist ein aktiv gepflegtes Open-Source-Projekt mit einer wachsenden Community, das kontinuierliche Verbesserungen, Fehlerbehebungen und Unterstützung für neue Modelle und Funktionen gewährleistet.
8. Optimierte Kernel: vLLM verwendet hochoptimierte CUDA-Kernel für verschiedene Operationen, wodurch die Leistung auf NVIDIA-GPUs weiter gesteigert wird.

Wenn Geschwindigkeit, Effizienz und Skalierbarkeit für Ihre LLM-Anwendung entscheidend sind, ist vLLM eine Technologie, die Sie ernsthaft in Betracht ziehen sollten.

Welche Modelle unterstützt vLLM?

vLLM unterstützt eine breite Palette beliebter Transformer-basierter Modelle, die auf dem Hugging Face Hub gehostet werden. Dazu gehören viele Varianten von:

• Llama (Llama, Llama 2, Llama 3)
• Mistral & Mixtral
• Qwen & Qwen2
• GPT-2, GPT-J, GPT-NeoX
• OPT
• Bloom
• Falcon
• MPT
• Und viele andere, einschließlich multimodaler Modelle.

Die Liste wächst ständig. Für die aktuellste und umfassendste Liste der offiziell unterstützten Modelle beziehen Sie sich immer auf die offizielle vLLM-Dokumentation:

vLLM Supported Models List

Wenn ein Modell nicht explizit aufgeführt ist, könnte es trotzdem funktionieren, wenn seine Architektur einer unterstützten ähnelt, aber die Kompatibilität ist ohne offizielle Unterstützung oder Tests nicht garantiert. Das Hinzufügen neuer Modellarchitekturen erfordert in der Regel Code-Beiträge zum vLLM-Projekt.

Einige wichtige vLLM-Terminologien:

Obwohl vLLM auf den ersten Blick einfach zu bedienen ist, hilft das Verständnis einiger seiner Kernkonzepte, zu verstehen, warum es so effektiv ist:

• PagedAttention: Dies ist die Flaggschiff-Funktion von vLLM. Bei herkömmlichen Aufmerksamkeitsmechanismen erfordert der Key-Value (KV)-Cache (der Zwischenergebnisse für die Generierung speichert) zusammenhängende Speicherblöcke. Dies führt zu Fragmentierung und verschwendetem Speicher (intern und extern). PagedAttention funktioniert wie virtueller Speicher in Betriebssystemen. Es unterteilt den KV-Cache in nicht zusammenhängende Blöcke (Seiten), was eine viel flexiblere und effizientere Speicherverwaltung ermöglicht. Es reduziert den Speicheraufwand erheblich (in einigen Fällen um bis zu 90 % laut den Entwicklern) und ermöglicht Funktionen wie gemeinsam genutzte Präfixe ohne Speicherduplizierung.
• Kontinuierliches Batching: Anstatt auf das Eintreffen einer festen Anzahl von Anfragen zu warten, bevor mit der Berechnung begonnen wird (statisches Batching), ermöglicht das kontinuierliche Batching der vLLM-Engine, mit der Verarbeitung neuer Sequenzen zu beginnen, sobald alte Sequenzen innerhalb eines Batches mit der Generierung von Tokens fertig sind. Dadurch bleibt die GPU ständig ausgelastet, wodurch der Durchsatz maximiert und die durchschnittliche Wartezeit für Anfragen reduziert wird.

Diese beiden Techniken arbeiten synergistisch zusammen, um die beeindruckenden Leistungseigenschaften von vLLM zu erzielen.

Bevor Sie mit vLLM beginnen, müssen Sie Folgendes überprüfen:

Bevor Sie vLLM installieren und ausführen können, stellen Sie sicher, dass Ihr System die folgenden Anforderungen erfüllt:

1. Betriebssystem: Linux ist das primär unterstützte Betriebssystem. Während es möglicherweise Community-Bemühungen für andere Betriebssysteme (wie WSL2 unter Windows oder macOS) gibt, bietet Linux die unkomplizierteste und offiziell unterstützte Erfahrung.
2. Python-Version: vLLM benötigt Python 3.9, 3.10, 3.11 oder 3.12. Es wird dringend empfohlen, eine virtuelle Umgebung zu verwenden, um Ihre Python-Abhängigkeiten zu verwalten.
3. NVIDIA GPU mit CUDA: Für optimale Leistung und Zugriff auf die Kernfunktionen benötigen Sie eine NVIDIA GPU mit einer Rechenfähigkeit, die von PyTorch unterstützt wird, und das erforderliche CUDA-Toolkit installiert. vLLM ist stark auf CUDA für seine optimierten Kernel angewiesen. Während CPU-basierte Inferenz und Unterstützung für andere Beschleuniger (wie AMD-GPUs oder AWS Inferentia/Trainium) verfügbar sind oder sich in der Entwicklung befinden, beinhaltet der primäre Weg NVIDIA-Hardware. Überprüfen Sie die offizielle PyTorch-Website auf CUDA-Kompatibilität mit Ihrer spezifischen GPU-Treiberversion.
4. PyTorch: vLLM basiert auf PyTorch. Der Installationsprozess kümmert sich in der Regel um die Installation einer kompatiblen Version, aber stellen Sie sicher, dass Sie eine funktionierende PyTorch-Installation haben, die mit Ihrer CUDA-Version kompatibel ist, falls Probleme auftreten.

Schritt-für-Schritt-Anleitung zur Installation von vLLM

Der empfohlene Weg zur Installation von vLLM ist die Verwendung eines Paketmanagers innerhalb einer virtuellen Umgebung. Dies verhindert Konflikte mit anderen Python-Projekten. Hier sind die Schritte mit gängigen Tools:

Verwendung von pip mit vLLM

pip ist das Standard-Python-Paketinstallationsprogramm.

Erstellen und aktivieren Sie eine virtuelle Umgebung (empfohlen):

python -m venv vllm-env
source vllm-env/bin/activate
# Unter Windows verwenden Sie: vllm-env\\\\Scripts\\\\activate

Installieren Sie vLLM:

pip install vllm

Dieser Befehl lädt die neueste stabile Version von vLLM und seine Kernabhängigkeiten herunter und installiert sie, einschließlich einer kompatiblen Version von PyTorch für Ihr erfasstes CUDA-Setup (falls möglich).

Verwendung von Conda mit vLLM

Conda ist ein weiterer beliebter Umgebungs- und Paketmanager, insbesondere in der Data-Science-Community.

Erstellen und aktivieren Sie eine Conda-Umgebung:

conda create -n vllm-env python=3.11 -y # Oder verwenden Sie 3.9, 3.10, 3.12
conda activate vllm-env

Installieren Sie vLLM mit pip innerhalb von Conda: Es wird im Allgemeinen empfohlen, pip zu verwenden, um vLLM auch innerhalb einer Conda-Umgebung zu installieren, um sicherzustellen, dass Sie problemlos den neuesten kompatiblen Build erhalten.

pip install vllm

Möglicherweise müssen Sie PyTorch zuerst separat über Conda installieren, wenn Sie es so verwalten möchten, um die Kompatibilität sicherzustellen: conda install pytorch torchvision torchaudio pytorch-cuda=11.8 -c pytorch -c nvidia (passen Sie die CUDA-Version nach Bedarf an). Führen Sie dann pip install vllm aus.

Verwendung von uv mit vLLM

uv ist ein neuer, extrem schneller Python-Paketinstallationsprogramm und -Resolver.

Installieren Sie uv (falls noch nicht geschehen): Befolgen Sie die Anweisungen in der offiziellen uv-Dokumentation.

Erstellen und aktivieren Sie eine Umgebung mit uv:

uv venv vllm-env --python 3.12 --seed # Oder verwenden Sie 3.9, 3.10, 3.11
source vllm-env/bin/activate
# Unter Windows verwenden Sie: vllm-env\\\\Scripts\\\\activate

Installieren Sie vLLM mit uv:

uv pip install vllm

Überprüfen Ihrer vLLM-Installation

Nach der Installation können Sie sie schnell überprüfen, indem Sie versuchen, vLLM in einen Python-Interpreter zu importieren oder einen einfachen Befehl auszuführen:

# Aktivieren Sie zuerst Ihre virtuelle Umgebung (z. B. source vllm-env/bin/activate)
python -c "import vllm; print(vllm.__version__)"

Dadurch sollte die installierte vLLM-Version ohne Fehler ausgegeben werden.

Versuchen Sie alternativ den Hilfe-Befehl für den Server (erfordert eine erfolgreiche Installation):

vllm --help

Durchführen von Offline-Stapel-Inferenz mit vLLM

Offline-Stapel-Inferenz bezieht sich auf das gleichzeitige Generieren von Text für eine vordefinierte Liste von Eingabeaufforderungen. Dies ist nützlich für Aufgaben wie die Bewertung eines Modells, das Generieren von Antworten für einen Datensatz oder das Vorberechnen von Ergebnissen. vLLM macht dies mit seiner LLM-Klasse effizient.

Verständnis der LLM-Klasse von vLLM

Die vllm.LLM-Klasse ist der Haupteinstiegspunkt für die Offline-Inferenz. Sie initialisieren sie, indem Sie das Modell angeben, das Sie verwenden möchten.

from vllm import LLM

# Initialisieren Sie die LLM-Engine mit einem Modell vom Hugging Face Hub
# Stellen Sie sicher, dass Sie genügend GPU-Speicher für das ausgewählte Modell haben!
# Beispiel: Verwendung eines kleineren Modells wie OPT-125m
llm = LLM(model="facebook/opt-125m")

# Beispiel: Verwendung eines größeren Modells wie Llama-3-8B-Instruct (erfordert erheblichen GPU-Speicher)
# llm = LLM(model="meta-llama/Meta-Llama-3-8B-Instruct")

print("vLLM-Engine initialisiert.")

Standardmäßig lädt vLLM Modelle vom Hugging Face Hub herunter. Wenn Ihr Modell auf ModelScope gehostet wird, müssen Sie die Umgebungsvariable VLLM_USE_MODELSCOPE=1 bevor Sie Ihr Python-Skript ausführen, festlegen.

Konfigurieren der vLLM-Sampling-Parameter

Um zu steuern, wie der Text generiert wird, verwenden Sie die vllm.SamplingParams-Klasse. Dies ermöglicht es Ihnen, Parameter wie Folgendes festzulegen:

• temperature: Steuert die Zufälligkeit. Niedrigere Werte (z. B. 0,2) machen die Ausgabe deterministischer und fokussierter; höhere Werte (z. B. 0,8) erhöhen die Zufälligkeit.
• top_p (Nucleus Sampling): Berücksichtigt nur die wahrscheinlichsten Tokens, deren kumulative Wahrscheinlichkeit top_p überschreitet. Ein üblicher Wert ist 0,95.
• top_k: Berücksichtigt nur die top_k wahrscheinlichsten Tokens in jedem Schritt.
• max_tokens: Die maximale Anzahl von Tokens, die für jede Eingabeaufforderung generiert werden sollen.
• stop: Eine Liste von Zeichenfolgen, die, wenn sie generiert werden, den Generierungsprozess für diese bestimmte Eingabeaufforderung stoppen.

from vllm import SamplingParams

# Definieren Sie Sampling-Parameter
# Wenn nicht angegeben, verwendet vLLM möglicherweise Standardwerte aus der generation_config.json des Modells
sampling_params = SamplingParams(
    temperature=0.7,
    top_p=0.9,
    max_tokens=100, # Begrenzen Sie die Länge des generierten Texts
    stop=["\\\\n", " Human:", " Assistant:"] # Stoppen Sie die Generierung, wenn diese Tokens erscheinen
)

print("Sampling-Parameter konfiguriert.")

Wichtiger Hinweis: Standardmäßig versucht vLLM, Einstellungen aus der Datei generation_config.json zu laden und zu verwenden, die dem Modell auf dem Hugging Face Hub zugeordnet ist. Wenn Sie dies ignorieren und die Standard-Sampling-Parameter von vLLM verwenden möchten, es sei denn, sie werden von Ihrem SamplingParams-Objekt überschrieben, initialisieren Sie die LLM-Klasse wie folgt: llm = LLM(model="...", generation_config="vllm"). Wenn Sie ein SamplingParams-Objekt an die generate-Methode übergeben, haben diese Parameter immer Vorrang vor der Konfiguration des Modells und den Standardwerten von vLLM.

Ausführen Ihres ersten vLLM-Stapeljobs

Kombinieren wir nun das LLM-Objekt, SamplingParams und eine Liste von Prompts, um Text zu generieren.

from vllm import LLM, SamplingParams

# 1. Definieren Sie Ihre Eingabeaufforderungen
prompts = [
    "Die Hauptstadt Frankreichs ist",
    "Erklären Sie die Relativitätstheorie in einfachen Worten:",
    "Schreiben Sie ein kurzes Gedicht über einen Regentag:",
    "Übersetzen Sie 'Hallo, Welt!' ins Deutsche:",
]

# 2. Konfigurieren Sie Sampling-Parameter
sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=150)

# 3. Initialisieren Sie die vLLM-Engine (verwenden Sie ein für Ihre Hardware geeignetes Modell)
try:
    # Verwendung eines relativ kleinen, leistungsfähigen Modells
    llm = LLM(model="mistralai/Mistral-7B-Instruct-v0.1")
    # Oder für kleinere GPUs:
    # llm = LLM(model="facebook/opt-1.3b")
    # llm = LLM(model="facebook/opt-125m")
except Exception as e:
    print(f"Fehler beim Initialisieren von LLM: {e}")
    print("Bitte stellen Sie sicher, dass Sie über genügend GPU-Speicher verfügen und CUDA korrekt eingerichtet ist.")
    exit()

# 4. Generieren Sie Text für die Prompts
# Die Generate-Methode nimmt die Liste der Prompts und Sampling-Parameter entgegen
print("Generieren von Antworten...")
outputs = llm.generate(prompts, sampling_params)
print("Generierung abgeschlossen.")

# 5. Drucken Sie die Ergebnisse aus
# Die Ausgabe ist eine Liste von RequestOutput-Objekten
for output in outputs:
    prompt = output.prompt
    generated_text = output.outputs[0].text # Holen Sie sich den Text aus der ersten generierten Sequenz
    print("-" * 20)
    print(f"Prompt: {prompt!r}")
    print(f"Generierter Text: {generated_text!r}")
    print("-" * 20)

Dieses Skript initialisiert vLLM, definiert Prompts und Parameter, führt den Generierungsprozess effizient in einem Batch aus und gibt dann die Ausgabe für jede Eingabeaufforderung aus. Der llm.generate()-Aufruf verarbeitet intern die Komplexität des Batchings und der GPU-Ausführung.

Einrichten des vLLM OpenAI-kompatiblen Servers

Eine der leistungsstärksten Funktionen von vLLM ist seine Fähigkeit, als Hochleistungs-Backend-Server zu fungieren, der dieselbe Sprache wie die OpenAI-API spricht. Dies ermöglicht es Ihnen, Ihre eigenen Open-Source-Modelle einfach zu hosten und sie in Anwendungen zu integrieren, die für OpenAI entwickelt wurden.

Starten des vLLM-Servers

Das Starten des Servers ist mit dem Befehl vllm serve in Ihrem Terminal unkompliziert.

Aktivieren Sie Ihre virtuelle Umgebung, in der vLLM installiert ist.

source vllm-env/bin/activate

Führen Sie den Befehl vllm serve aus: Sie müssen das Modell angeben, das Sie bedienen möchten.

# Beispiel mit Mistral-7B-Instruct
vllm serve mistralai/Mistral-7B-Instruct-v0.1

# Beispiel mit einem kleineren Modell wie Qwen2-1.5B-Instruct
# vllm serve Qwen/Qwen2-1.5B-Instruct

Dieser Befehl führt Folgendes aus:

• Laden Sie das angegebene Modell herunter (falls noch nicht zwischengespeichert).
• Laden Sie das Modell auf Ihre GPU(s).
• Starten Sie einen Webserver (standardmäßig mit Uvicorn).
• Hören Sie auf eingehende API-Anfragen, typischerweise unter http://localhost:8000.

Häufige Optionen:

• -model <model_name_or_path>: (Erforderlich) Das zu bedienende Modell.
• -host <ip_address>: Die IP-Adresse, an die der Server gebunden werden soll (z. B. 0.0.0.0, um ihn in Ihrem Netzwerk zugänglich zu machen). Der Standardwert ist localhost.
• -port <port_number>: Der Port, auf dem gelauscht werden soll. Der Standardwert ist 8000.
• -tensor-parallel-size <N>: Für das Serving mit mehreren GPUs teilt das Modell auf N GPUs auf.
• -api-key <your_key>: Wenn gesetzt, erwartet der Server diesen API-Schlüssel im Header Authorization: Bearer <your_key> eingehender Anfragen. Sie können auch die Umgebungsvariable VLLM_API_KEY festlegen.
• -generation-config vllm: Verwenden Sie die Standard-Sampling-Parameter von vLLM anstelle der generation_config.json des Modells.
• -chat-template <path_to_template_file>: Verwenden Sie eine benutzerdefinierte Jinja-Chat-Template-Datei anstelle der im Tokenizer-Config definierten.

Der Server gibt Protokolle aus, die angeben, dass er ausgeführt wird und bereit ist, Anfragen anzunehmen.

Interagieren mit dem vLLM-Server: Completions-API

Sobald der Server läuft, können Sie Anfragen an seinen /v1/completions-Endpunkt senden, genau wie bei der älteren Completions-API von OpenAI.

Verwendung von curl:

curl <http://localhost:8000/v1/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "prompt": "San Francisco ist eine Stadt in",
        "max_tokens": 50,
        "temperature": 0.7
    }'

(Ersetzen Sie "mistralai/Mistral-7B-Instruct-v0.1" durch das tatsächliche Modell, das Sie bedienen)

Verwendung der openai Python-Bibliothek:

from openai import OpenAI

# Richten Sie den Client auf Ihren vLLM-Server-Endpunkt aus
client = OpenAI(
    api_key="EMPTY", # Verwenden Sie "EMPTY" oder Ihren tatsächlichen Schlüssel, wenn Sie einen mit --api-key festgelegt haben
    base_url="<http://localhost:8000/v1>"
)

print("Senden der Anfrage an den vLLM-Server (Completions)...")

try:
    completion = client.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Der Modellname muss mit dem bedienten übereinstimmen
        prompt="Erklären Sie die Vorteile der Verwendung von vLLM:",
        max_tokens=150,
        temperature=0.5
    )

    print("Antwort:")
    print(completion.choices[0].text)

except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")

(Denken Sie daran, den Modellnamen zu ersetzen, wenn Sie einen anderen bedienen)

Interagieren mit dem vLLM-Server: Chat Completions-API

vLLM unterstützt auch den moderneren /v1/chat/completions-Endpunkt, der für Konversationsmodelle und strukturierte Nachrichtenformate (System-, Benutzer-, Assistenten-Rollen) geeignet ist.

Verwendung von curl:

curl <http://localhost:8000/v1/chat/completions> \\\\
    -H "Content-Type: application/json" \\\\
    -d '{
        "model": "mistralai/Mistral-7B-Instruct-v0.1",
        "messages": [
            {"role": "system", "content": "Sie sind ein hilfreicher Assistent."},
            {"role": "user", "content": "Was ist der Hauptvorteil von PagedAttention in vLLM?"}
        ],
        "max_tokens": 100,
        "temperature": 0.7
    }'

(Ersetzen Sie den Modellnamen nach Bedarf)

Verwendung der openai Python-Bibliothek:

from openai import OpenAI

# Richten Sie den Client auf Ihren vLLM-Server-Endpunkt aus
client = OpenAI(
    api_key="EMPTY", # Verwenden Sie "EMPTY" oder Ihren tatsächlichen Schlüssel
    base_url="<http://localhost:8000/v1>"
)

print("Senden der Anfrage an den vLLM-Server (Chat Completions)...")

try:
    chat_response = client.chat.completions.create(
        model="mistralai/Mistral-7B-Instruct-v0.1", # Der Modellname muss mit dem bedienten übereinstimmen
        messages=[
            {"role": "system", "content": "Sie sind ein hilfreicher Programmierassistent."},
            {"role": "user", "content": "Schreiben Sie eine einfache Python-Funktion zur Berechnung der Fakultät."}
        ],
        max_tokens=200,
        temperature=0.5
    )

    print("Antwort:")
    print(chat_response.choices[0].message.content)

except Exception as e:
    print(f"Ein Fehler ist aufgetreten: {e}")

(Denken Sie daran, den Modellnamen bei Bedarf zu ersetzen)

Die Verwendung des OpenAI-kompatiblen Servers ist eine leistungsstarke Möglichkeit, Hochleistungs-LLM-Inferenz-Endpunkte mit minimalen Änderungen an Ihrer vorhandenen Anwendungslogik bereitzustellen.

Sprechen wir über vLLM-Aufmerksamkeits-Backends

vLLM verwendet spezialisierte "Backends", um den Aufmerksamkeitsmechanismus effizient zu berechnen. Diese Backends sind optimierte Implementierungen, die verschiedene Bibliotheken oder Techniken nutzen, hauptsächlich für NVIDIA-GPUs. Die Wahl des Backends kann sich auf die Leistung und den Speicherverbrauch auswirken. Die wichtigsten sind:

1. FlashAttention: Verwendet die FlashAttention-Bibliothek (Versionen 1 und 2). FlashAttention ist ein hochoptimierter Aufmerksamkeitsalgorithmus, der die Berechnung erheblich beschleunigt und den Speicherverbrauch reduziert, indem er die Materialisierung der großen Zwischenaufmerksamkeitsmatrix im GPU High Bandwidth Memory (HBM) vermeidet. Es ist oft die schnellste Option für viele moderne GPUs (wie Ampere-, Hopper-Architekturen) und Sequenzlängen. vLLM enthält typischerweise vorgefertigte Wheels mit FlashAttention-Unterstützung.
2. Xformers: Nutzt die xFormers-Bibliothek, die von Meta AI entwickelt wurde. xFormers bietet auch speichereffiziente und optimierte Aufmerksamkeitsimplementierungen (wie MemoryEfficientAttention). Es bietet eine breite Kompatibilität über verschiedene GPU-Architekturen hinweg und kann eine gute Alternative oder ein Fallback sein, wenn FlashAttention für ein bestimmtes Szenario nicht verfügbar oder optimal ist. Die Standardinstallation von vLLM enthält oft Unterstützung für xFormers.
3. FlashInfer: Eine neuere Backend-Option, die die FlashInfer-Bibliothek verwendet. FlashInfer bietet hochoptimierte Kernel, die speziell für die Bereitstellung von LLMs zugeschnitten sind und sich auf verschiedene Prefill- und Decoding-Szenarien konzentrieren, einschließlich Funktionen wie spekulativem Decoding und effizienter Handhabung von Paged-KV-Caches. Es gibt typischerweise keine vorgefertigten vLLM-Wheels, die FlashInfer enthalten, was bedeutet, dass Sie es separat in Ihrer Umgebung installieren müssen, bevor vLLM es verwenden kann. Beziehen Sie sich auf die offizielle FlashInfer-Dokumentation oder die vLLM-Dockerfiles für Installationsanweisungen, wenn Sie beabsichtigen, dieses Backend zu verwenden.

Automatische Backend-Auswahl: Standardmäßig erkennt vLLM automatisch das am besten geeignete und leistungsfähigste Aufmerksamkeits-Backend basierend auf Ihrer Hardware (GPU-Architektur), installierten Bibliotheken (ist FlashAttention/xFormers/FlashInfer verfügbar?) und dem verwendeten spezifischen Modell. Es führt Überprüfungen durch, um die Kompatibilität sicherzustellen und versucht, die beste Out-of-the-Box-Leistung ohne manuelle Konfiguration zu erzielen.

Manuelle Backend-Auswahl: In einigen fortgeschrittenen Anwendungsfällen oder zu Benchmarking-Zwecken möchten Sie möglicherweise vLLM zwingen, ein bestimmtes Backend zu verwenden. Sie können dies tun, indem Sie die Umgebungsvariable VLLM_ATTENTION_BACKEND bevor Sie Ihren vLLM-Prozess starten (entweder das Offline-Skript oder den Server) festlegen.

# Beispiel: Erzwingen der Verwendung von FlashAttention (falls installiert und kompatibel)
export VLLM_ATTENTION_BACKEND=FLASH_ATTN
python your_offline_script.py
# oder
# export VLLM_ATTENTION_BACKEND=FLASH_ATTN
# vllm serve your_model ...

# Beispiel: Erzwingen der Verwendung von xFormers
export VLLM_ATTENTION_BACKEND=XFORMERS
python your_offline_script.py

# Beispiel: Erzwingen der Verwendung von FlashInfer (erfordert vorherige Installation)
export VLLM_ATTENTION_BACKEND=FLASHINFER
python your_offline_script.py

Für die meisten Anfänger wird empfohlen, sich auf die automatische Backend-Auswahl von vLLM zu verlassen. Das manuelle Festlegen des Backends ist typischerweise Experimenten oder der Fehlerbehebung spezifischer Leistungsprobleme vorbehalten.

Fehlerbehebung bei häufigen vLLM-Installations- und Nutzungsproblemen

Obwohl vLLM auf Benutzerfreundlichkeit abzielt, können Sie auf einige häufige Hürden stoßen, insbesondere während der Einrichtung. Hier sind einige häufige Probleme und ihre potenziellen Lösungen:

1. CUDA Out of Memory (OOM)-Fehler:

• Problem: Sie sehen Fehler wie torch.cuda.OutOfMemoryError: CUDA out of memory.
• Ursache: Das LLM, das Sie laden möchten, benötigt mehr GPU-VRAM, als auf Ihrer Hardware verfügbar ist. Größere Modelle (z. B. 7B-Parameter und höher) verbrauchen erheblichen Speicher.
• Lösungen:
• Verwenden Sie ein kleineres Modell: Versuchen Sie zuerst, eine kleinere Variante (z. B. opt-1.3b, Qwen/Qwen2-1.5B-Instruct) zu laden, um zu bestätigen, dass Ihr Setup funktioniert.
• Reduzieren Sie die Batch-Größe (Server): Obwohl vLLM das Batching dynamisch verarbeitet, kann eine sehr hohe Parallelität immer noch den Speicher überschreiten. Überwachen Sie die Nutzung.
• Verwenden Sie Quantisierung: Laden Sie quantisierte Versionen des Modells (z. B. AWQ, GPTQ, GGUF – überprüfen Sie die vLLM-Dokumentation