💜Qwen3.5 - Comment l'exécuter localement

Exécutez les nouveaux LLMs Qwen3.5, y compris Medium : Qwen3.5-35B-A3B, 27B, 122B-A10B, Small : Qwen3.5-0.8B, 2B, 4B, 9B et 397B-A17B sur votre appareil local !

Qwen3.5 est la nouvelle famille de modèles d’Alibaba, comprenant Qwen3.5-35B-A3B, 27B, 122B-A10B et 397B-A17B ainsi que la nouvelle Petite série : Qwen3.5-0.8B, 2B, 4B et 9B. Les LLM hybrides multimodaux de raisonnement offrent les meilleures performances pour leur taille. Ils prennent en charge un contexte de 256K dans 201 langues, ont un mode de réflexion + sansréflexion, et excellent dans les tâches de codage agentique, de vision, de chat et de long contexte. Les modèles 35B et 27B fonctionnent sur un appareil Mac / RAM de 22 Go. Voir tous les GGUF ici.

Lancer les tutoriels Qwen3.5Ajuster Qwen3.5

Mise à jour du 17 mars : Vous pouvez maintenant exécuter Qwen3.5 dans Unsloth Studio.

Mise à jour du 5 mars : Retéléchargez Qwen3.5-35B, 27B, 122B et 397B.

• Tous les GGUF sont désormais mis à jour avec un algorithme de quantification amélioré .

• Tous utilisent nos nouvelles données imatrix. Voir certaines améliorations dans les cas d’usage de chat, de codage, de long contexte et d’appel d’outils.

• L’appel d’outils amélioré à la suite de nos corrections du modèle de chat. La correction est universelle et s’applique à n’importe quel format Qwen3.5 et n’importe quel uploader.

• Consultez les nouveaux benchmarks GGUF pour les résultats de performance d’Unsloth + notre enquête MXFP4.

• Nous retirons les couches MXFP4 de 3 GGUF Qwen3.5 : Q2_K_XL, Q3_K_XL et Q4_K_XL.

Tous les téléversements utilisent Unsloth Dynamic 2.0 pour des performances de quantification SOTA - ainsi, le 4 bits a des couches importantes remontées à 8 ou 16 bits. Merci à Qwen d’avoir donné à Unsloth un accès dès le jour zéro. Vous pouvez aussi ajuster Qwen3.5 avec Unsloth.

Pour activer ou désactiver la réflexion, voir Qwen3.5.Les petits modèles Qwen3.5 sont désactivés par défaut.

⚙️ Guide d’utilisation

Tableau : exigences matérielles pour l’inférence (unités = mémoire totale : RAM + VRAM, ou mémoire unifiée)

Qwen3.5	3 bits	4 bits	6 bits	8 bits	BF16
0,8B + 2B	3 Go	3,5 Go	5 Go	7,5 Go	9 Go
4B	4,5 Go	5,5 Go	7 Go	10 Go	14 Go
9B	5,5 Go	6,5 Go	9 Go	13 Go	19 Go
27B	14 Go	17 Go	24 Go	30 Go	54 Go
35B-A3B	17 Go	22 Go	30 Go	38 Go	70 Go
122B-A10B	60 Go	70 Go	106 Go	132 Go	245 Go
397B-A17B	180 Go	214 Go	340 Go	512 Go	810 Go

Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (VRAM + RAM système) dépasse la taille du fichier de modèle quantifié que vous téléchargez. Si ce n’est pas le cas, llama.cpp peut toujours fonctionner via un déchargement vers SSD/HDD, mais l’inférence sera plus lente.

Entre 27B et 35B-A3B, utilisez 27B si vous voulez des résultats légèrement plus précis et que cela ne tient pas sur votre appareil. Choisissez 35B-A3B si vous voulez une inférence beaucoup plus rapide.

Paramètres recommandés

• Fenêtre de contexte maximale : 262,144 (peut être étendue à 1M via YaRN)

• presence_penalty = 0.0 à 2.0 par défaut, ceci est désactivé, mais pour réduire les répétitions, vous pouvez l’utiliser ; cependant, une valeur plus élevée peut entraîner une légère baisse des performances

• Longueur de sortie adéquate: 32,768 jetons pour la plupart des requêtes

Si vous obtenez du charabia, la longueur de votre contexte est peut-être trop faible. Ou essayez d’utiliser --cache-type-k bf16 --cache-type-v bf16 ce qui peut aider.

Comme Qwen3.5 est un raisonnement hybride, les modes réflexion et sans réflexion ont des paramètres différents :

Mode réflexion :

Tâches générales	Tâches de codage précises (par ex. WebDev)
temperature = 1.0	temperature = 0.6
top_p = 0.95	top_p = 0.95
top_k = 20	top_k = 20
min_p = 0.0	min_p = 0.0
presence_penalty = 1.5	presence_penalty = 0.0
repeat penalty = désactivé ou 1.0	repeat penalty = désactivé ou 1.0

Mode réflexion pour les tâches générales :

temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

Mode réflexion pour les tâches de codage précises :

temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0

Paramètres du mode Instruct (sans réflexion) :

Tâches générales	Tâches de raisonnement
temperature = 0.7	temperature = 1.0
top_p = 0.8	top_p = 0.95
top_k = 20	top_k = 20
min_p = 0.0	min_p = 0.0
presence_penalty = 1.5	presence_penalty = 1.5
repeat penalty = désactivé ou 1.0	repeat penalty = désactivé ou 1.0

Pour désactiver la réflexion / le raisonnement, utilisez --chat-template-kwargs '{"enable_thinking":false}'

Si vous êtes sous Windows Powershell, utilisez : --chat-template-kwargs "{\"enable_thinking\":false}"

Utilisez indifféremment 'true' et 'false'.

Pour Qwen3.5 0.8B, 2B, 4B et 9B, le raisonnement est désactivé par défaut. Pour l’activer, utilisez : --chat-template-kwargs '{"enable_thinking":true}'

Instruct (sans réflexion) pour les tâches générales :

temperature=0.7, top_p=0.8, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

Instruct (sans réflexion) pour les tâches de raisonnement :

temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0

Tutoriels d’inférence Qwen3.5 :

Comme Qwen3.5 existe en de nombreuses tailles différentes, nous utiliserons Dynamic 4 bits MXFP4_MOE variantes GGUF pour toutes les charges de travail d’inférence. Cliquez ci-dessous pour accéder aux instructions du modèle désigné :

Exécuter dans Unsloth StudioQwen3.5-35B-A3B27B122B-A10B397B-A17BPetit (0.8B - 9B)

Téléversements Unsloth Dynamic GGUF :

Qwen3.5-35B-A3B	Qwen3.5-27B	Qwen3.5-122B-A10B	Qwen3.5-397B-A17B
Qwen3.5-0,8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-9B

presence_penalty = 0.0 à 2.0 par défaut, ceci est désactivé, mais pour réduire les répétitions, vous pouvez l’utiliser ; cependant, une valeur plus élevée peut entraîner une légère baisse des performances.

Actuellement, aucun GGUF Qwen3.5 ne fonctionne dans Ollama en raison de fichiers mmproj vision séparés. Utilisez des backends compatibles avec llama.cpp.

🦥 Guide d’Unsloth Studio

Qwen3.5 peut être exécuté et ajusté dans Unsloth Studio, notre nouvelle interface web open source pour l’IA locale. Unsloth Studio vous permet d’exécuter des modèles localement sur MacOS, Windows, Linux et :

• Rechercher, télécharger, exécuter des GGUF et des modèles safetensor

• Auto-réparation appel d’outils + recherche web

• Exécution de code (Python, Bash)

• Inférence automatique ajustement des paramètres (temp, top-p, etc.)

• Inférence rapide CPU + GPU via llama.cpp

• Entraîner des LLM 2x plus rapide avec 70 % de VRAM en moins

1

Installer Unsloth

Exécutez dans votre terminal :

MacOS, Linux, WSL :

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell :

irm https://unsloth.ai/install.ps1 | iex

L’installation sera rapide et prendra environ 1 à 2 minutes.

2

Lancer Unsloth

MacOS, Linux, WSL et Windows :

unsloth studio -H 0.0.0.0 -p 8888

Puis ouvrez http://localhost:8888 dans votre navigateur.

3

Rechercher et télécharger Qwen3.5

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’intégration pour choisir un modèle, un jeu de données et des paramètres de base. Vous pouvez le passer à tout moment.

Ensuite, allez dans l’onglet Studio Chat et recherchez Qwen3.5 dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités.

4

Exécuter Qwen3.5

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également éditer la longueur de contexte, le modèle de chat et d’autres paramètres.

Pour plus d’informations, vous pouvez consulter notre guide d’inférence d’Unsloth Studio.

🦙 Guides llama.cpp

Qwen3.5-35B-A3B

Pour ce guide, nous utiliserons Dynamic 4 bits, qui fonctionne très bien sur un appareil Mac / RAM de 24 Go pour une inférence rapide. Comme le modèle ne fait qu’environ 72 Go en précision F16 complète, nous n’aurons pas trop à nous soucier des performances. GGUF : Qwen3.5-35B-A3B-GGUF

Pour ces tutoriels, nous utiliserons llama.cpp pour une inférence locale rapide, surtout si vous avez un CPU.

1

Obtenez la version la plus récente llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis continuez normalement - la prise en charge de Metal est activée par défaut.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_M) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp à enregistrer dans un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes spécifiques ci-dessous, selon votre cas d’usage :

Mode réflexion :

Tâches de codage précises (par ex. WebDev) :

export LLAMA_CACHE="unsloth/Qwen3.5-35B-A3B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-35B-A3B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Mode sans réflexion :

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-35B-A3B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.7 \\
    --top-p 0.8 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

Tâches de raisonnement :

export LLAMA_CACHE="unsloth/Qwen3.5-35B-A3B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-35B-A3B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir Q4_K_M ou d’autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer la taille et la précision. Si les téléchargements se bloquent, voir : Hugging Face Hub, débogage XET

hf download unsloth/Qwen3.5-35B-A3B-GGUF \\
    --local-dir unsloth/Qwen3.5-35B-A3B-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits

4

Puis exécutez le modèle en mode conversation :

./llama.cpp/llama-cli \\
    --model unsloth/Qwen3.5-35B-A3B-GGUF/Qwen3.5-35B-A3B-UD-Q4_K_XL.gguf \\
    --mmproj unsloth/Qwen3.5-35B-A3B-GGUF/mmproj-F16.gguf \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.00 \\
    --top-k 20

Qwen3.5 Petite série (0.8B • 2B • 4B • 9B)

Pour Qwen3.5 0.8B, 2B, 4B et 9B, le raisonnement est désactivé par défaut. Pour l’activer, utilisez : --chat-template-kwargs '{"enable_thinking":true}'

Sous Windows, utilisez : --chat-template-kwargs "{\"enable_thinking\":true}"

Pour la série Qwen3.5 Small, comme elle est très petite, tout ce que vous avez à faire est de changer le nom du modèle dans les scripts pour la variante souhaitée. Pour ce guide précis, nous utiliserons la variante à 9 milliards de paramètres. Pour les exécuter toutes en précision quasi complète, vous n’aurez besoin que d’un appareil avec 12 Go de RAM / VRAM / mémoire unifiée. GGUF :

Qwen3.5-0,8B	Qwen3.5-2B	Qwen3.5-4B	Qwen3.5-9B

1

Obtenez la version la plus récente llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_XL) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp à enregistrer dans un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes spécifiques ci-dessous, selon votre cas d’usage :

Pour utiliser une autre variante que 9B, vous pouvez remplacer '9B' par : 0.8B, 2B ou 4B, etc.

Mode réflexion (désactivé par défaut)

Les modèles Qwen3.5 Small désactivent la réflexion par défaut. Utilisez llama-server pour l’activer.

export LLAMA_CACHE="unsloth/Qwen3.5-9B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-9B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --alias "unsloth/Qwen3.5-9B-GGUF" \\
    --port 8001 \\
    --chat-template-kwargs '{"enable_thinking":true}'

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-9B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-9B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --alias "unsloth/Qwen3.5-9B-GGUF" \\
    --port 8001 \\
    --chat-template-kwargs '{"enable_thinking":true}'

Pour utiliser une autre variante que 9B, vous pouvez remplacer '9B' par : 0.8B, 2B ou 4B, etc.

Le mode sans réflexion est déjà activé par défaut

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-9B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-9B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.7 \\
    --top-p 0.8 \\
    --top-k 20 \\
    --min-p 0.00

Tâches de raisonnement :

export LLAMA_CACHE="unsloth/Qwen3.5-9B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-9B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir Q4_K_M ou d’autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer la taille et la précision. Si les téléchargements se bloquent, voir : Hugging Face Hub, débogage XET

hf download unsloth/Qwen3.5-9B-GGUF \\
    --local-dir unsloth/Qwen3.5-9B-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits

4

Puis exécutez le modèle en mode conversation :

./llama.cpp/llama-cli \\
    --model unsloth/Qwen3.5-9B-GGUF/Qwen3.5-9B-UD-Q4_K_XL.gguf \\
    --mmproj unsloth/Qwen3.5-9B-GGUF/mmproj-F16.gguf \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.00 \\
    --top-k 20

Qwen3.5-27B

Pour ce guide, nous utiliserons Dynamic 4 bits, qui fonctionne très bien sur un appareil Mac / RAM de 18 Go pour une inférence rapide. GGUF : Qwen3.5-27B-GGUF

1

Obtenez la version la plus récente llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_M) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp à enregistrer dans un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes spécifiques ci-dessous, selon votre cas d’usage :

Mode réflexion :

Tâches de codage précises (par ex. WebDev) :

export LLAMA_CACHE="unsloth/Qwen3.5-27B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-27B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-27B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-27B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Mode sans réflexion :

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-27B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-27B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.7 \\
    --top-p 0.8 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

Tâches de raisonnement :

export LLAMA_CACHE="unsloth/Qwen3.5-27B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-27B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir MXFP4_MOE ou d’autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer la taille et la précision. Si les téléchargements se bloquent, voir : Hugging Face Hub, débogage XET

hf download unsloth/Qwen3.5-27B-GGUF \\
    --local-dir unsloth/Qwen3.5-27B-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits

4

Puis exécutez le modèle en mode conversation :

./llama.cpp/llama-cli \\
    --model unsloth/Qwen3.5-27B-GGUF/Qwen3.5-27B-UD-Q4_K_XL.gguf \\
    --mmproj unsloth/Qwen3.5-27B-GGUF/mmproj-F16.gguf \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.00 \\
    --top-k 20

Qwen3.5-122B-A10B

Pour ce guide, nous utiliserons Dynamic 4 bits, qui fonctionne très bien sur un appareil Mac / RAM de 70 Go pour une inférence rapide. GGUF : Qwen3.5-122B-A10B-GGUF

1

Obtenez la version la plus récente llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_M) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp à enregistrer dans un emplacement spécifique. Le modèle a une longueur de contexte maximale de 256K.

Suivez l’une des commandes spécifiques ci-dessous, selon votre cas d’usage :

Mode réflexion :

Tâches de codage précises (par ex. WebDev) :

export LLAMA_CACHE="unsloth/Qwen3.5-122B-A10B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-122B-A10B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-122B-A10B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-122B-A10B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Mode sans réflexion :

Tâches générales :

export LLAMA_CACHE="unsloth/Qwen3.5-122B-A10B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-122B-A10B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.7 \\
    --top-p 0.8 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

Tâches de raisonnement :

export LLAMA_CACHE="unsloth/Qwen3.5-122B-A10B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-122B-A10B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir MXFP4_MOE (4 bits dynamique) ou d’autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer la taille et la précision. Si les téléchargements se bloquent, voir : Hugging Face Hub, débogage XET

hf download unsloth/Qwen3.5-122B-A10B-GGUF \\
    --local-dir unsloth/Qwen3.5-122B-A10B-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q4_K_XL*" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits

4

Puis exécutez le modèle en mode conversation :

./llama.cpp/llama-cli \\
    --model unsloth/Qwen3.5-122B-A10B-GGUF/UD-Q4_K_XL/Qwen3.5-122B-A10B-UD-Q4_K_XL-00001-of-00003.gguf \\
    --mmproj unsloth/Qwen3.5-122B-A10B-GGUF/mmproj-F16.gguf \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Qwen3.5-397B-A17B

Qwen3.5-397B-A17B se situe dans la même catégorie de performances que Gemini 3 Pro, Claude Opus 4.5 et GPT-5.2. Le point de contrôle complet 397B fait ~807 Go sur disque, mais via les GGUF 397B d’Unsloth vous pouvez exécuter :

• 3 bits: tient sur 192 Go de RAM systèmes (par ex. un Mac de 192 Go)

• 4 bits (MXFP4): tient sur 256 Go de RAM. Unsloth 4 bits dynamique UD-Q4_K_XL est ~214 Go sur disque - se charge directement sur un M3 Ultra de 256 Go

• S’exécute sur un seul GPU de 24 Go + 256 Go de RAM système via déchargement MoE, atteignant plus de 25 jetons/s

• 8 bits nécessite ~512 Go de RAM/VRAM

Voir benchmarks de quantification 397B pour voir les performances des GGUF Unsloth.

1

Obtenez la version la plus récente llama.cpp sur GitHub ici. Vous pouvez aussi suivre les instructions de compilation ci-dessous. Remplacez -DGGML_CUDA=ON par -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \\
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

2

Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:Q4_K_M) est le type de quantification. Vous pouvez aussi télécharger via Hugging Face (point 3). C’est similaire à ollama run . Utilisez export LLAMA_CACHE="folder" pour forcer llama.cpp pour enregistrer dans un emplacement spécifique. N’oubliez pas que le modèle a une longueur de contexte maximale de seulement 256K.

Suivez ceci pour le un mode de réflexion mode :

export LLAMA_CACHE="unsloth/Qwen3.5-397B-A17B-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3.5-397B-A17B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

Suivez ceci pour le sans réflexion mode :

export LLAMA_CACHE="unsloth/Qwen3.5-397B-A17B-GGUF"
./llama.cpp/llama-server \\
    -hf unsloth/Qwen3.5-397B-A17B-GGUF:UD-Q4_K_XL \\
    --ctx-size 16384 \\
    --temp 0.7 \\
    --top-p 0.8 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --chat-template-kwargs '{"enable_thinking":false}'

3

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir MXFP4_MOE (4 bits dynamique) ou d’autres versions quantifiées comme UD-Q4_K_XL . Nous recommandons d’utiliser au moins une quantification dynamique 2 bits UD-Q2_K_XL pour équilibrer la taille et la précision. Si les téléchargements se bloquent, voir : Hugging Face Hub, débogage XET

hf download unsloth/Qwen3.5-397B-A17B-GGUF \\
    --local-dir unsloth/Qwen3.5-397B-A17B-GGUF \\
    --include "*mmproj-F16*" \\
    --include "*UD-Q4_K_XL" # Utilisez "*UD-Q2_K_XL*" pour Dynamic 2 bits

4

Vous pouvez modifier --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur du contexte, --n-gpu-layers 2 pour le déchargement GPU sur le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n’utilisez qu’une inférence CPU.

./llama.cpp/llama-cli \\
    --model unsloth/Qwen3.5-397B-A17B-GGUF/UD-Q4_K_XL/Qwen3.5-397B-A17B-UD-Q4_K_XL-00001-of-00006.gguf \\
    --mmproj unsloth/Qwen3.5-397B-A17B-GGUF/mmproj-F16.gguf \\
    --ctx-size 16384 \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --top-k 20 \\
    --min-p 0.00

👾 Guide LM Studio

Pour ce guide, nous utiliserons LM Studio, une interface unifiée pour exécuter des LLM. Le commutateur « 💡Thinking » et « Non-thinking » peut ne pas apparaître par défaut, donc nous aurons besoin de quelques étapes supplémentaires pour le faire fonctionner.

1

Téléchargez LM Studio pour votre appareil. Puis ouvrez Model Search, recherchez 'unsloth/qwen3.5', et téléchargez le GGUF (quant) souhaité.

2

Instructions du commutateur Thinking : Après le téléchargement, ouvrez votre Terminal / PowerShell et essayez : lms --help. Puis, si LM Studio s’affiche normalement avec de nombreuses commandes, exécutez :

lms get unsloth/qwen3.5-4b

Cela récupérera un fichier yaml qui permet à votre GGUF d’afficher les commutateurs '💡Thinking' et 'Non-thinking'. Vous pouvez changer 4b par la quantification souhaitée.

Sinon, vous pouvez aller sur notre page LM Studio et télécharger le fichier yaml spécifique.

3

Redémarrez LM Studio, puis chargez votre modèle téléchargé (avec le commutateur thinking spécifique que vous avez téléchargé). Vous devriez maintenant voir le commutateur Thinking activé. N’oubliez pas de définir les paramètres corrects.

🦙 Guide de diffusion llama-server et bibliothèque de complétion d’OpenAI

Pour déployer Qwen3.5-397B-A17B en production, nous utilisons llama-server Dans un nouveau terminal, par exemple via tmux, déployez le modèle via :

./llama.cpp/llama-server \\
--model unsloth/Qwen3.5-35B-A3B-GGUF/Qwen3.5-35B-A3B-UD-Q4_K_XL.gguf \\
    --mmproj unsloth/Qwen3.5-35B-A3B-GGUF/mmproj-F16.gguf \\
    --alias "unsloth/Qwen3.5-35B-A3B" \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --ctx-size 16384 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --port 8001

Puis, dans un nouveau terminal, après avoir fait pip install openai, faites :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Qwen3.5-397B-A17B",
    messages = [{"role": "user", "content": "Create a Snake game."},],
)
print(completion.choices[0].message.content)

🤔 Comment activer ou désactiver le raisonnement et la réflexion

Pour les commandes ci-dessous, vous pouvez utiliser 'true' et 'false' indifféremment.

Unsloth Studio a automatiquement un commutateur « Think » pour les modèles de réflexion.

Pour avoir le commutateur Think dans LM Studio, lisez notre guide.

Unsloth Studio a le commutateur Think par défaut

Pour désactiver la réflexion / le raisonnement, utilisez dans llama-server :

    --chat-template-kwargs '{"enable_thinking":false}'

Si vous êtes sous Windows ou Powershell, utilisez : --chat-template-kwargs "{\"enable_thinking\":false}"

Pour activer la réflexion / le raisonnement, utilisez dans llama-server :

    --chat-template-kwargs '{"enable_thinking":true}'

Si vous êtes sous Windows ou Powershell, utilisez : --chat-template-kwargs "{\"enable_thinking\":true}"

Pour Qwen3.5 0.8B, 2B, 4B et 9B, le raisonnement est désactivé par défaut. Pour l’activer, utilisez : --chat-template-kwargs '{"enable_thinking":true}'

Et sous Windows ou Powershell : --chat-template-kwargs "{\"enable_thinking\":true}"

À titre d’exemple pour Qwen3.5-9B afin d’activer la réflexion (désactivée par défaut) :

./llama.cpp/llama-server \\
    --model unsloth/Qwen3.5-9B-GGUF/Qwen3.5-9B-BF16.gguf \\
    --alias "unsloth/Qwen3.5-9B-GGUF" \\
    --temp 0.6 \\
    --top-p 0.95 \\
    --ctx-size 16384 \\
    --top-k 20 \\
    --min-p 0.00 \\
    --port 8001 \\
    --chat-template-kwargs '{"enable_thinking":true}'

Puis en Python :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Qwen3.5-9B-GGUF",
    messages = [{"role": "user", "content": "Combien font 2+2 ?"},],
)
print(completion.choices[0].message.content)
print(completion.choices[0].message.reasoning_content)

👨‍💻 OpenAI Codex et Claude Code

Pour exécuter le modèle via des charges de travail agentiques de codage local, vous pouvez suivre notre guide. Changez simplement le nom du modèle pour la variante 'Qwen3.5' souhaitée et assurez-vous de suivre les paramètres et instructions d'utilisation corrects de Qwen3.5. Utilisez le llama-server que nous venons de configurer à l'instant.

Claude Code

OpenAI Codex

Après avoir suivi les instructions pour Claude Code par exemple, vous verrez :

Nous pouvons alors demander par exemple Créer un jeu d'échecs en Python :

🔨Appel d'outils avec Qwen3.5

Voir Tool Calling Guide pour plus de détails sur la façon de faire des appels d'outils. Dans un nouveau terminal (si vous utilisez tmux, utilisez CTRL+B+D), nous créons quelques outils comme additionner 2 nombres, exécuter du code Python, exécuter des fonctions Linux et bien plus encore :

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def substract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "Il y a longtemps dans une galaxie lointaine, très lointaine...",
        "Il y avait 2 amis qui adoraient les paresseux et le code...",
        "Le monde touchait à sa fin parce que tous les paresseux avaient évolué pour avoir une intelligence surhumaine...",
        "À l'insu de l'un des amis, l'autre avait accidentellement codé un programme pour faire évoluer les paresseux...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "Impossible d'exécuter les commandes 'rm, sudo, dd, chmod' car elles sont dangereuses"
        print(msg); return msg
    print(f"Exécution de la commande terminal `{command}`")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"Échec de la commande : {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "substract_number": substract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "Additionne deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "Multiplie deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "substract_number",
            "description": "Soustrait deux nombres.",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "Le premier nombre.",
                    },
                    "b": {
                        "type": "string",
                        "description": "Le deuxième nombre.",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "Écrit une histoire aléatoire.",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "Effectuer des opérations depuis le terminal.",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "La commande que vous souhaitez lancer, par ex. `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "Appeler un interpréteur Python avec du code Python qui sera exécuté.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "Le code Python à exécuter",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

Nous utilisons ensuite les fonctions ci-dessous (copiez-collez et exécutez) qui analyseront automatiquement les appels de fonction et appelleront le point de terminaison OpenAI pour n'importe quel modèle :

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 0.6,
    top_p = 0.95,
    top_k = 20,
    min_p = 0.00,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"Utilisation du modèle = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Messages actuels = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages

Après avoir lancé Qwen3.5 via llama-server comme dans Qwen3.5 ou voir Tool Calling Guide pour plus de détails, nous pouvons alors faire quelques appels d'outils.

📊 Benchmarks

Benchmarks Unsloth GGUF

Nous avons mis à jour les quantifications dynamiques Unsloth de Qwen3.5-35B étant SOTA sur presque tous les bits. Nous avons effectué plus de 150 benchmarks de divergence KL, au total 9 To de GGUF. Nous avons téléversé tous les artefacts de recherche. Nous avons également corrigé un appel d’outils modèle de chat bug (affecte tous les téléverseurs de quantification)

• Tous les GGUF sont désormais mis à jour avec un algorithme de quantification amélioré .

• Tous utilisent nos nouvelles données imatrix. Voir certaines améliorations dans les cas d’usage de chat, de codage, de long contexte et d’appel d’outils.

• Les GGUF Qwen3.5-35B-A3B sont mis à jour pour utiliser les nouveaux correctifs (112B, 27B encore en conversion, retéléchargez-les une fois qu'ils sont mis à jour)

• 99,9 % de divergence KL montre un SOTA sur la frontière de Pareto pour UD-Q4_K_XL, IQ3_XXS et plus encore.

• Abandon de MXFP4 de toutes les quantifications GGUF : Q2_K_XL, Q3_K_XL et Q4_K_XL, sauf pour le pur MXFP4_MOE.

35B-A3B - benchmarks KLD (plus bas est meilleur)

122B-A10B - benchmarks KLD (plus bas est meilleur)

LISEZ NOTRE ANALYSE DÉTAILLÉE DE QWEN3.5 + BENCHMARKS ICI :

Benchmarks Qwen3.5 GGUF

Benchmarks Qwen3.5-397B-A17B

Benjamin Marie (tiers) a benchmarké Qwen3.5-397B-A17B en utilisant des GGUF Unsloth sur une suite mixte de 750 prompts (LiveCodeBench v6, MMLU Pro, GPQA, Math500), en rapportant à la fois précision globale et augmentation relative de l'erreur (à quel point le modèle quantifié fait plus souvent des erreurs par rapport à l'original).

Résultats clés (précision ; changement par rapport à l'original ; augmentation relative de l'erreur) :

• Poids d'origine : 81.3%

• UD-Q4_K_XL : 80.5% (-0,8 point ; +4,3 % d'augmentation relative de l'erreur)

• UD-Q3_K_XL : 80.7% (-0,6 point ; +3,5 % d'augmentation relative de l'erreur)

UD-Q4_K_XL et UD-Q3_K_XL reste extrêmement proche de l'original, bien en dessous d'une baisse de précision de 1 point sur cette suite, ce qui laisse entendre, selon Ben, que vous pouvez réduire fortement l'empreinte mémoire (~500 Go de moins) avec peu ou pas de perte pratique sur les tâches testées.

Comment choisir : Le fait que Q3 obtienne ici un score légèrement supérieur à Q4 est tout à fait plausible comme une variance normale d'une exécution à l'autre à cette échelle, donc considérez Q3 et Q4 comme de qualité effectivement similaire dans ce benchmark :

• Choisissez Q3 si vous voulez la plus petite empreinte / les meilleures économies de mémoire

• Choisissez Q4 si vous voulez une légèrement plus conservatrice option avec des similaires résultats

Toutes les quantifications listées utilisent notre méthodologie dynamique. Même UD-IQ2_M utilise la même méthodologie dynamique, cependant le processus de conversion est différent de UD-Q2-K-XL où K-XL est généralement plus rapide que UD-IQ2_M même s'il est plus gros, c'est pourquoi UD-IQ2_M peut être plus performant que UD-Q2-K-XL.

Benchmarks officiels de Qwen

Benchmarks Qwen3.5-35B-A3B, 27B et 122B-A10B

Benchmarks Qwen3.5-4B et 9B

Benchmarks Qwen3.5-397B-A17B