> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/notions-de-base/inference-and-deployment/sglang-guide.md). # Guide de déploiement et d'inférence SGLang Guide pour enregistrer et déployer des LLM sur SGLang afin de servir des LLM en production Vous pouvez servir n'importe quel LLM ou modèle finement ajusté via [SGLang](https://github.com/sgl-project/sglang) pour une inférence à faible latence et haut débit. SGLang prend en charge l'inférence de modèles texte et image/vidéo sur n'importe quelle configuration GPU, avec prise en charge de certains GGUF. ### :computer:Installation de SGLang Pour installer SGLang et Unsloth sur des GPU NVIDIA, vous pouvez utiliser ce qui suit dans un environnement virtuel (ce qui ne cassera pas vos autres bibliothèques Python) ```shellscript # FACULTATIF utiliser un environnement virtuel python -m venv unsloth_env source unsloth_env/bin/activate # Installer Rust, outlines-core puis SGLang 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 ``` Pour **Docker** Configurations à exécuter : {% 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:Dépannage des problèmes d'installation de SGLang Remarque : si vous voyez ce qui suit, mettez à jour Rust et outlines-core comme indiqué dans [#setting-up-sglang](#setting-up-sglang "mention") {% code overflow="wrap" %} ``` astuce : cela indique généralement un problème avec le package ou l'environnement de compilation. aide : `outlines-core` (v0.1.26) a été inclus parce que `sglang` (v0.5.5.post2) dépend de `outlines` (v0.1.11), qui dépend de `outlines-core` ``` {% endcode %} Si vous voyez un problème Flashinfer comme ci-dessous : ``` /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 | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ compilation interrompue. ninja : compilation arrêtée : la sous-commande a échoué. Solutions possibles : 1. définissez --mem-fraction-static sur une valeur plus petite (par ex. 0.8 ou 0.7) 2. définissez --cuda-graph-max-bs sur une valeur plus petite (par ex. 16) 3. désactivez torch compile en n'utilisant pas --enable-torch-compile 4. désactivez CUDA graph avec --disable-cuda-graph. (Non recommandé. Forte perte de performances) Ouvrez un ticket sur GitHub https://github.com/sgl-project/sglang/issues/new/choose ``` Supprimez le cache flashinfer via `rm -rf .cache/flashinfer` et aussi le répertoire indiqué dans le message d'erreur, par exemple `rm -rf ~/.cache/flashinfer` ### :truck:Déploiement des modèles SGLang Pour déployer n'importe quel modèle, par exemple [unsloth/Llama-3.2-1B-Instruct](https://huggingface.co/unsloth/Llama-3.2-1B-Instruct), faites ce qui suit dans un terminal séparé (sinon cela bloquera votre terminal actuel - vous pouvez aussi utiliser tmux) : {% 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 %}
Vous pouvez ensuite utiliser la bibliothèque OpenAI Chat Completions pour appeler le modèle (dans un autre terminal ou en utilisant tmux) : ```python # Installer 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": "Combien font 2+2 ?"},], ) print(completion.choices[0].message.content) ``` Et vous obtiendrez `2 + 2 = 4.` ### 🦥Déploiement des fine-tunes Unsloth dans SGLang Après le fine-tuning [Fine-tuning Guide](/docs/fr/commencer/fine-tuning-llms-guide.md) ou en utilisant nos notebooks à [Notebooks Unsloth](/docs/fr/commencer/unsloth-notebooks.md), vous pouvez enregistrer ou déployer vos modèles directement via SGLang dans un seul flux de travail. Un exemple de script de fine-tuning Unsloth, par exemple : ```python from unsloth import FastLanguageModel import torch model, tokenizer = FastLanguageModel.from_pretrained( model_name = "unsloth/gpt-oss-20b", max_seq_length = 2048, load_in_4bit = True, ) model = FastLanguageModel.get_peft_model(model) ``` **Pour enregistrer en 16 bits pour SGLang, utilisez :** ```python model.save_pretrained_merged("finetuned_model", tokenizer, save_method = "merged_16bit") ## OU pour téléverser sur Hugging Face : model.push_to_hub_merged("hf/model", tokenizer, save_method = "merged_16bit", token = "") ``` **Pour enregistrer uniquement les adaptateurs LoRA**, utilisez soit : ```python model.save_pretrained("finetuned_model") tokenizer.save_pretrained("finetuned_model") ``` Ou utilisez simplement notre fonction intégrée pour le faire : ```python model.save_pretrained_merged("model", tokenizer, save_method = "lora") ## OU pour téléverser sur Hugging Face model.push_to_hub_merged("hf/model", tokenizer, save_method = "lora", token = "") ``` ### :railway\_car:gpt-oss-20b : guide de déploiement Unsloth et SGLang Ci-dessous se trouve un tutoriel étape par étape avec des instructions pour entraîner le [gpt-oss](/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune.md)-20b en utilisant Unsloth et le déployer avec SGLang. Il inclut des benchmarks de performance sur plusieurs formats de quantification. {% stepper %} {% step %} #### Formats de fine-tuning et d'exportation Unsloth Si vous êtes nouveau dans le fine-tuning, vous pouvez lire notre [guide](/docs/fr/commencer/fine-tuning-llms-guide.md), ou essayez le notebook de fine-tuning gpt-oss 20B à [gpt-oss](/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune.md) Après l'entraînement, vous pouvez exporter le modèle dans plusieurs formats : {% code overflow="wrap" %} ```python model.save_pretrained_merged( "finetuned_model", tokenizer, save_method = "merged_16bit", ) ## Pour les conversions mxfp4 spécifiques à gpt-oss : model.save_pretrained_merged( "finetuned_model", tokenizer, save_method = "mxfp4", # (UNIQUEMENT POUR gpt-oss, sinon choisissez "merged_16bit") ) ``` {% endcode %} {% endstep %} {% step %} #### Déploiement avec SGLang Nous avons enregistré notre fine-tune gpt-oss dans le dossier "finetuned\_model", et donc dans un nouveau terminal, nous pouvons lancer le modèle finement ajusté comme point de terminaison d'inférence avec SGLang : ```shellscript python -m sglang.launch_server \ --model-path finetuned_model \ --host 0.0.0.0 --port 30002 ``` Vous devrez peut-être attendre un peu sur `Capture des lots (bs=1 mémoire_disponible=20.84 Go) :` ! {% endstep %} {% step %} #### Appel du point de terminaison d'inférence : Pour appeler le point de terminaison d'inférence, ouvrez d'abord un nouveau terminal. Nous pouvons ensuite appeler le modèle comme ci-dessous : {% 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": "Combien font 2+2 ?"},], ) print(completion.choices[0].message.content) ## OUTPUT ## # <|channel|>analysis<|message|>L'utilisateur pose une simple question de mathématiques. Nous devons répondre 4. Nous devons également respecter la politique. Aucun problème.<|end|><|start|>assistant<|channel|>final<|message|>2 + 2 égale 4. ``` {% endcode %} {% endstep %} {% endstepper %} ### :gem:Quantification en ligne FP8 Pour déployer des modèles avec la quantification en ligne FP8, qui permet 30 à 50 % de débit supplémentaire et 50 % d'utilisation mémoire en moins, avec une prise en charge d'une longueur de contexte 2x plus longue avec SGLang, vous pouvez faire ce qui suit : {% 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 %} Vous pouvez également utiliser `--kv-cache-dtype fp8_e5m2` qui a une plage dynamique plus large, ce qui pourrait résoudre les problèmes d'inférence FP8 si vous en voyez. Ou utilisez nos quantifications float8 pré-quantifiées listées dans ou certaines sont listées ci-dessous : {% embed url="" %} {% embed url="" %} ### ⚡Benchmarking de SGLang Voici du code que vous pouvez exécuter pour tester la vitesse de performance de votre modèle finement ajusté : ```shellscript python -m sglang.launch_server \ --model-path finetuned_model \ --host 0.0.0.0 --port 30002 ``` Puis dans un autre terminal ou via tmux : ```shellscript # Taille de lot=8, Entrée=1024, Sortie=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 ``` Vous verrez l'exécution du benchmark comme ci-dessous :
Nous avons utilisé un GPU B200x1 avec gpt-oss-20b et obtenu les résultats ci-dessous (débit d'environ 2 500 tokens) | Lot/Entrée/Sortie | TTFT (s) | ITL (s) | Débit d'entrée | Débit de sortie | | ----------------- | -------- | ------- | -------------- | --------------- | | 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 | Voir pour les arguments du serveur pour SGLang. ### :person\_running:Mode hors ligne interactif de SGLang Vous pouvez également utiliser SGLang en mode hors ligne (c.-à-d. sans serveur) dans un environnement Python interactif. {% code overflow="wrap" %} ```python import sglang as sgl engine = sgl.Engine(model_path = "unsloth/Qwen3-0.6B", random_seed = 42) prompt = "Aujourd'hui est une journée ensoleillée et j'aime" sampling_params = {"temperature": 0, "max_new_tokens": 256} outputs = engine.generate(prompt, sampling_params)["text"] print(outputs) engine.shutdown() ``` {% endcode %} ### :sparkler:GGUF dans SGLang SGLang prend également en charge les GGUF, ce qui est intéressant ! **Qwen3 MoE est encore en cours de construction, mais la plupart des modèles denses (Llama 3, Qwen 3, Mistral, etc.) sont pris en charge.** Installez d'abord le dernier package Python gguf via : {% code overflow="wrap" %} ```shellscript pip install -e "git+https://github.com/ggml-org/llama.cpp.git#egg=gguf&subdirectory=gguf-py" # installer un package Python depuis un sous-répertoire du dépôt ``` {% endcode %} Puis, par exemple, en mode hors ligne de SGLang, vous pouvez faire : {% 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 = "Aujourd'hui est une journée ensoleillée et j'aime" sampling_params = {"temperature": 0, "max_new_tokens": 256} outputs = engine.generate(prompt, sampling_params)["text"] print(outputs) engine.shutdown() ``` {% endcode %} ### :clapper:Service GGUF à haut débit avec SGLang Téléchargez d'abord le fichier GGUF spécifique comme ci-dessous : {% 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 %} Puis servez le fichier spécifique `Qwen3-32B-UD-Q4_K_XL.gguf` corrects `--served-model-name unsloth/Qwen3-32B` et nous avons également besoin du tokenizer compatible avec HuggingFace 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 This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/fr/notions-de-base/inference-and-deployment/sglang-guide.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. 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.