# SGLang-Bereitstellungs- und Inferenzanleitung Sie können jedes LLM oder feinabgestimmte Modell über [SGLang](https://github.com/sgl-project/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. ### :computer: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) ```shellscript # 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: {% code overflow="wrap" %} ```shellscript docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=" \ --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 ``` {% endcode %} ### :bug:Fehlerbehebung bei SGLang-Installationsproblemen Beachten Sie: Wenn Sie Folgendes sehen, aktualisieren Sie Rust und outlines-core wie in angegeben [#setting-up-sglang](#setting-up-sglang "mention") {% code overflow="wrap" %} ``` 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 ``` {% endcode %} 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 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 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` ### :truck:SGLang-Modelle bereitstellen Um ein beliebiges Modell bereitzustellen, zum Beispiel [unsloth/Llama-3.2-1B-Instruct](https://huggingface.co/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): {% code overflow="wrap" %} ```shellscript python3 -m sglang.launch_server \ --model-path unsloth/Llama-3.2-1B-Instruct \ --host 0.0.0.0 --port 30000 ``` {% endcode %}
Sie können dann die OpenAI Chat Completions-Bibliothek verwenden, um das Modell aufzurufen (in einem anderen Terminal oder mit tmux): ```python # 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](/docs/de/loslegen/fine-tuning-llms-guide.md) oder unter Verwendung unserer Notebooks unter [Unsloth-Notebooks](/docs/de/loslegen/unsloth-notebooks.md), Sie können Ihre Modelle direkt über SGLang innerhalb eines einzigen Workflows speichern oder bereitstellen. Ein Beispielskript zum Finetuning mit Unsloth, z. B.: ```python 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:** ```python 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: ```python model.save_pretrained("finetuned_model") tokenizer.save_pretrained("finetuned_model") ``` Oder verwenden Sie einfach unsere eingebaute Funktion dafür: ```python 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 = "") ``` ### :railway\_car:gpt-oss-20b: Unsloth- & SGLang-Bereitstellungsanleitung Unten finden Sie ein Schritt-für-Schritt-Tutorial mit Anweisungen zum Training des [gpt-oss](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md)-20b mithilfe von Unsloth und dessen Bereitstellung mit SGLang. Es enthält Leistungsbenchmarks für mehrere Quantisierungsformate. {% stepper %} {% step %} #### Unsloth Feinabstimmung und Exportformate Wenn Sie neu beim Finetuning sind, können Sie unseren [Leitfaden](/docs/de/loslegen/fine-tuning-llms-guide.md)lesen oder das gpt-oss 20B Finetuning-Notebook ausprobieren unter [gpt-oss](/docs/de/modelle/gpt-oss-how-to-run-and-fine-tune.md) Nach dem Training können Sie das Modell in mehreren Formaten exportieren: {% code overflow="wrap" %} ```python 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") ) ``` {% endcode %} {% endstep %} {% step %} #### 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: ```shellscript 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):` ! {% endstep %} {% step %} #### Aufruf des Inferenz-Endpunkts: Um den Inferenz-Endpunkt aufzurufen, starten Sie zuerst ein neues Terminal. Dann können wir das Modell wie unten aufrufen: {% code overflow="wrap" %} ```python 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. ``` {% endcode %} {% endstep %} {% endstepper %} ### :gem: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: {% code overflow="wrap" %} ```shellscript 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 ``` {% endcode %} 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 oder einige sind unten aufgeführt: {% embed url="" %} {% embed url="" %} ### ⚡SGLang-Benchmarking Unten ist etwas Code, den Sie ausführen können, um die Leistungsgeschwindigkeit Ihres feinabgestimmten Modells zu testen: ```shellscript python -m sglang.launch_server \ --model-path finetuned_model \ --host 0.0.0.0 --port 30002 ``` Dann in einem anderen Terminal oder via tmux: ```shellscript # 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 für Server-Argumente für SGLang. ### :person\_running:SGLang interaktiver Offline-Modus Sie können SGLang auch im Offline-Modus (d. h. nicht als Server) innerhalb einer interaktiven Python-Umgebung verwenden. {% code overflow="wrap" %} ```python 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() ``` {% endcode %} ### :sparkler: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: {% code overflow="wrap" %} ```shellscript 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 ``` {% endcode %} Dann können Sie beispielsweise im Offline-Modus von SGLang folgendes tun: {% code overflow="wrap" %} ```python 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() ``` {% endcode %} ### :clapper:Hoher Durchsatz beim Serving von GGUFs mit SGLang Laden Sie zunächst die spezifische GGUF-Datei wie unten herunter: {% code overflow="wrap" %} ```python from huggingface_hub import hf_hub_download hf_hub_download("unsloth/Qwen3-32B-GGUF", filename="Qwen3-32B-UD-Q4_K_XL.gguf", local_dir=".") ``` {% endcode %} 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` ```shellscript 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 ``` --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/grundlagen/inference-and-deployment/sglang-guide.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.