SGLang Deployment & Inference Anleitung

Anleitung zum Speichern und Bereitstellen von LLMs in SGLang zum Servieren von LLMs in der Produktion

Sie können jedes LLM oder feinabgestimmte Modell über SGLang für latenzarme, hochdurchsatzfähige Inferenz bereitstellen. SGLang unterstützt Text- sowie Bild-/Video-Modellinferenz auf beliebiger GPU-Konfiguration und bietet Unterstützung für einige GGUFs.

💻SGLang installieren

Um SGLang und Unsloth auf NVIDIA-GPUs zu installieren, können Sie das Folgende in einer virtuellen Umgebung verwenden (die Ihre anderen Python-Bibliotheken nicht beeinträchtigt)

# OPTIONAL eine virtuelle Umgebung verwenden
python -m venv unsloth_env
source unsloth_env/bin/activate

# Rust, outlines-core und dann SGLang installieren
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env && sudo apt-get install -y pkg-config libssl-dev
pip install --upgrade pip && pip install uv
uv pip install "sglang" && uv pip install unsloth

Für Docker Setups laufen:

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server --model-path unsloth/Llama-3.1-8B-Instruct --host 0.0.0.0 --port 30000

🐛Fehlerbehebung bei SGLang-Installationsproblemen

Beachten Sie: Wenn Sie Folgendes sehen, aktualisieren Sie Rust und outlines-core wie in angegeben SGLang

Hinweis: Dies weist normalerweise auf ein Problem mit dem Paket oder der Build-Umgebung hin.
  Hilfe: `outlines-core` (v0.1.26) wurde eingeschlossen, weil `sglang` (v0.5.5.post2) von `outlines` (v0.1.11) abhängt, welches von `outlines-core` abhängt

Wenn Sie ein Flashinfer-Problem wie unten sehen:

/home/daniel/.cache/flashinfer/0.5.2/100a/generated/batch_prefill_with_kv_cache_dtype_q_bf16_dtype_kv_bf16_dtype_o_bf16_dtype_idx_i32_head_dim_qk_64_head_dim_vo_64_posenc_0_use_swa_False_use_logits_cap_False_f16qk_False/batch_prefill_ragged_kernel_mask_1.cu:1:10: fatal error: flashinfer/attention/prefill.cuh: No such file or directory
    1 | #include <flashinfer/attention/prefill.cuh>
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Kompilierung abgebrochen.
ninja: Build gestoppt: Unterbefehl fehlgeschlagen.

Mögliche Lösungen:
1. Setzen Sie --mem-fraction-static auf einen kleineren Wert (z. B. 0.8 oder 0.7)
2. Setzen Sie --cuda-graph-max-bs auf einen kleineren Wert (z. B. 16)
3. Deaktivieren Sie torch compile, indem Sie --enable-torch-compile nicht verwenden
4. Deaktivieren Sie CUDA-Graph mit --disable-cuda-graph. (Nicht empfohlen. Großer Leistungsverlust)
Öffnen Sie ein Issue auf GitHub https://github.com/sgl-project/sglang/issues/new/choose

Entfernen Sie den flashinfer-Cache über rm -rf .cache/flashinfer und auch das im Fehlermeldung angegebene Verzeichnis, z. B. rm -rf ~/.cache/flashinfer

🚚SGLang-Modelle bereitstellen

Um ein beliebiges Modell bereitzustellen, zum Beispiel unsloth/Llama-3.2-1B-Instruct, führen Sie das Folgende in einem separaten Terminal aus (ansonsten blockiert es Ihr aktuelles Terminal – Sie können auch tmux verwenden):

python3 -m sglang.launch_server \
    --model-path unsloth/Llama-3.2-1B-Instruct \
    --host 0.0.0.0 --port 30000

Sie können dann die OpenAI Chat Completions-Bibliothek verwenden, um das Modell aufzurufen (in einem anderen Terminal oder mit tmux):

# Installieren Sie openai via pip install openai
from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://0.0.0.0:30000/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Llama-3.2-1B-Instruct",
    messages = [{"role": "user", "content": "What is 2+2?"},],
)
print(completion.choices[0].message.content)

Und Sie erhalten 2 + 2 = 4.

🦥Unsloth-Finetunes in SGLang bereitstellen

Nach dem Fine-Tuning Fine-tuning Guide oder unter Verwendung unserer Notebooks unter Unsloth-Notebooks, Sie können Ihre Modelle direkt über SGLang innerhalb eines einzigen Workflows speichern oder bereitstellen. Ein Beispielskript zum Finetuning mit Unsloth, z. B.:

from unsloth import FastLanguageModel
import torch
model, tokenizer = FastLanguageModel.from_pretrained(
    ] # Mehr Modelle unter https://huggingface.co/unsloth
    max_seq_length = 2048,
    load_in_4bit = True,
)
model = FastLanguageModel.get_peft_model(model)

Um in 16-Bit für SGLang zu speichern, verwenden Sie:

model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "merged_16bit")
## ODER zum Hochladen zu HuggingFace:
model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "")

Nur die LoRA-Adapter speichern, verwenden Sie entweder:

model.save_pretrained("finetuned_model")
tokenizer.save_pretrained("finetuned_model")

Oder verwenden Sie einfach unsere eingebaute Funktion dafür:

model.save_pretrained_merged("model", tokenizer, save_method = "lora")
## ODER zum Hochladen zu HuggingFace
model.push_to_hub_merged("hf/model", tokenizer, save_method = "lora", token = "")

🚃gpt-oss-20b: Unsloth- & SGLang-Bereitstellungsanleitung

Unten finden Sie ein Schritt-für-Schritt-Tutorial mit Anweisungen zum Training des gpt-oss-20b mithilfe von Unsloth und dessen Bereitstellung mit SGLang. Es enthält Leistungsbenchmarks für mehrere Quantisierungsformate.

1

Unsloth Feinabstimmung und Exportformate

Wenn Sie neu beim Finetuning sind, können Sie unseren Leitfadenlesen oder das gpt-oss 20B Finetuning-Notebook ausprobieren unter gpt-oss Nach dem Training können Sie das Modell in mehreren Formaten exportieren:

model.save_pretrained_merged(
    "finetuned_model", 
    tokenizer, 
    save_method = "merged_16bit",
)
## Für gpt-oss-spezifische mxfp4-Konversionen:
model.save_pretrained_merged(
    "finetuned_model", 
    tokenizer, 
    save_method = "mxfp4", # (NUR FÜR gpt-oss, andernfalls wählen Sie "merged_16bit")
)

2

Bereitstellung mit SGLang

Wir haben unser gpt-oss-Finetune in den Ordner "finetuned_model" gespeichert, und daher können wir in einem neuen Terminal das feinabgestimmte Modell als Inferenz-Endpunkt mit SGLang starten:

python -m sglang.launch_server \
    --model-path finetuned_model \
    --host 0.0.0.0 --port 30002

Sie müssen möglicherweise etwas warten bei Erfassen von Batches (bs=1 avail_mem=20.84 GB): !

3

Aufruf des Inferenz-Endpunkts:

Um den Inferenz-Endpunkt aufzurufen, starten Sie zuerst ein neues Terminal. Dann können wir das Modell wie unten aufrufen:

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://0.0.0.0:30002/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "finetuned_model",
    messages = [{"role": "user", "content": "What is 2+2?"},],
)
print(completion.choices[0].message.content)

## AUSGABE ##
# <|channel|>analysis<|message|>Der Benutzer stellt eine einfache Mathematikfrage. Wir sollten 4 antworten. Außerdem sollten wir die Richtlinien einhalten. Keine Probleme.<|end|><|start|>assistant<|channel|>final<|message|>2 + 2 ergibt 4.

💎FP8 Online-Quantisierung

Um Modelle mit FP8-Online-Quantisierung bereitzustellen, die 30 bis 50 % mehr Durchsatz und 50 % weniger Speicherverbrauch sowie Unterstützung für doppelt so lange Kontextlängen mit SGLang ermöglichen, können Sie Folgendes tun:

python -m sglang.launch_server \
    --model-path unsloth/Llama-3.2-1B-Instruct \
    --host 0.0.0.0 --port 30002 \
    --quantization fp8 \
    --kv-cache-dtype fp8_e4m3

Sie können auch verwenden --kv-cache-dtype fp8_e5m2 welches einen größeren Dynamikbereich hat und FP8-Inferenzprobleme lösen könnte, falls Sie welche sehen. Oder verwenden Sie unsere vorquantisierten float8-Quants, die in https://huggingface.co/unsloth/models?search=-fp8 oder einige sind unten aufgeführt:

unsloth/Llama-3.2-3B-FP8-Dynamic · Hugging Facehuggingface

unsloth/Llama-3.3-70B-Instruct-FP8-Dynamic · Hugging Facehuggingface

⚡SGLang-Benchmarking

Unten ist etwas Code, den Sie ausführen können, um die Leistungsgeschwindigkeit Ihres feinabgestimmten Modells zu testen:

python -m sglang.launch_server \
    --model-path finetuned_model \
    --host 0.0.0.0 --port 30002

Dann in einem anderen Terminal oder via tmux:

# Batch-Größe=8, Eingabe=1024, Ausgabe=1024
python -m sglang.bench_one_batch_server \
    --model finetuned_model \
    --base-url http://0.0.0.0:30002 \
    --batch-size 8 \
    --input-len 1024 \
    --output-len 1024

Sie werden den Benchmarking-Durchlauf wie unten sehen:

Wir verwendeten eine B200x1-GPU mit gpt-oss-20b und erzielten die folgenden Ergebnisse (~2.500 Tokens Durchsatz)

Batch/Eingabe/Ausgabe	TTFT (s)	ITL (s)	Eingabe-Durchsatz	Ausgabe-Durchsatz
8/1024/1024	0.40	3.59	20,718.95	2,562.87
8/8192/1024	0.42	3.74	154,459.01	2,473.84

Siehe https://docs.sglang.ai/advanced_features/server_arguments.html für Server-Argumente für SGLang.

🏃SGLang interaktiver Offline-Modus

Sie können SGLang auch im Offline-Modus (d. h. nicht als Server) innerhalb einer interaktiven Python-Umgebung verwenden.

import sglang as sgl
engine = sgl.Engine(model_path = "unsloth/Qwen3-0.6B", random_seed = 42)

prompt = "Heute ist ein sonniger Tag und ich mag"
sampling_params = {"temperature": 0, "max_new_tokens": 256}
outputs = engine.generate(prompt, sampling_params)["text"]
print(outputs)
engine.shutdown()

🎇GGUFs in SGLang

SGLang unterstützt interessanterweise auch GGUFs! Qwen3 MoE ist noch im Aufbau, aber die meisten dichten Modelle (Llama 3, Qwen 3, Mistral usw.) werden unterstützt.

Installieren Sie zuerst das neueste gguf-Python-Paket via:

pip install -e "git+https://github.com/ggml-org/llama.cpp.git#egg=gguf&subdirectory=gguf-py" # ein Python-Paket aus einem Repo-Unterverzeichnis installieren

Dann können Sie beispielsweise im Offline-Modus von SGLang folgendes tun:

from huggingface_hub import hf_hub_download
model_path = hf_hub_download(
    "unsloth/Qwen3-32B-GGUF",
    filename = "Qwen3-32B-UD-Q4_K_XL.gguf",
)
import sglang as sgl
engine = sgl.Engine(model_path = model_path, random_seed = 42)

prompt = "Heute ist ein sonniger Tag und ich mag"
sampling_params = {"temperature": 0, "max_new_tokens": 256}
outputs = engine.generate(prompt, sampling_params)["text"]
print(outputs)
engine.shutdown()

🎬Hoher Durchsatz beim Serving von GGUFs mit SGLang

Laden Sie zunächst die spezifische GGUF-Datei wie unten herunter:

from huggingface_hub import hf_hub_download
hf_hub_download("unsloth/Qwen3-32B-GGUF", filename="Qwen3-32B-UD-Q4_K_XL.gguf", local_dir=".")

Servieren Sie dann die spezifische Datei Qwen3-32B-UD-Q4_K_XL.gguf haben und verwenden Sie --served-model-name unsloth/Qwen3-32B und außerdem benötigen wir den HuggingFace-kompatiblen Tokenizer via --tokenizer-path

python -m sglang.launch_server \
    --model-path Qwen3-32B-UD-Q4_K_XL.gguf \
    --host 0.0.0.0 --port 30002 \
    --served-model-name unsloth/Qwen3-32B \
    --tokenizer-path unsloth/Qwen3-32B