🐋DeepSeek-R1-0528 : Comment exécuter localement

Un guide sur la façon d'exécuter DeepSeek-R1-0528 incluant Qwen3 sur votre propre appareil local !

DeepSeek-R1-0528 est la nouvelle mise à jour du modèle de raisonnement R1 de DeepSeek. Le modèle complet de 671 milliards de paramètres nécessite 715 Go d'espace disque. La version quantifiée dynamique 1,66 bits utilise 162 Go (-80 % de réduction de taille). GGUF : DeepSeek-R1-0528-GGUF

DeepSeek a également publié une version distillée R1-0528 en ajustant finement Qwen3 (8B). La distillation atteint des performances similaires à Qwen3 (235B). Vous pouvez aussi affiner Qwen3 Distill avec Unsloth. Qwen3 GGUF : DeepSeek-R1-0528-Qwen3-8B-GGUF

Tous les téléversements utilisent Unsloth Dynamic 2.0 pour des performances SOTA sur MMLU 5-shot et la divergence KL, ce qui signifie que vous pouvez exécuter et affiner des LLMs DeepSeek quantifiés avec une perte d'exactitude minimale.

Navigation des tutoriels :

Exécuter dans llama.cppExécuter dans Ollama/Open WebUIFine-tuning de R1-0528

NOUVEAU : Améliorations majeures de l'appel d'outils et corrections des modèles de chat. Nouveau quant dynamique TQ1_0 1,66 bits - 162 Go de taille. Idéal pour 192 Go de RAM (y compris Mac) et les utilisateurs Ollama. Essayez : ollama run hf.co/unsloth/DeepSeek-R1-0528-GGUF:TQ1_0

⚙️ Paramètres recommandés

Pour DeepSeek-R1-0528-Qwen3-8B, le modèle peut quasiment tenir sur n'importe quelle configuration, même celles avec seulement 20 Go de RAM. Il n'y a pas besoin de préparation préalable. Cependant, pour le modèle R1-0528 complet qui fait 715 Go, vous aurez besoin d'une préparation supplémentaire. La quantification 1,78 bits (IQ1_S) tiendra sur un GPU 1x 24 Go (avec toutes les couches déchargées). Attendez-vous à environ 5 tokens/s avec cette configuration si vous disposez aussi de 128 Go de RAM supplémentaires.

Il est recommandé d'avoir au moins 64 Go de RAM pour exécuter cette quantification (vous obtiendrez 1 token/s sans GPU). Pour des performances optimales, vous aurez besoin d'au moins 180 Go de mémoire unifiée ou 180 Go de RAM+VRAM combinés pour 5+ tokens/s.

Nous suggérons d'utiliser notre quantification 2,7 bits (Q2_K_XL) ou 2,4 bits (IQ2_XXS) pour équilibrer taille et précision ! La version 2,4 bits fonctionne également bien.

Bien que non nécessaire, pour de meilleures performances, faites en sorte que votre VRAM + RAM combinées = taille de la quantification que vous téléchargez.

🐳 Paramètres officiels recommandés :

Selon DeepSeek, ce sont les paramètres recommandés pour l'inférence R1 (R1-0528 et la distillation Qwen3 doivent utiliser les mêmes paramètres) :

• Réglez la température 0.6 pour réduire les répétitions et l'incohérence.

• Réglez top_p à 0,95 (recommandé)

• Effectuez plusieurs tests et faites la moyenne des résultats pour une évaluation fiable.

🔢 Format du template de chat / prompt

R1-0528 utilise le même modèle de chat que le modèle R1 original. Vous n'avez pas besoin de forcer <think>\n , mais vous pouvez toujours l'ajouter !

<｜begin▁of▁sentence｜><｜User｜>What is 1+1?<｜Assistant｜>It's 2.<｜end▁of▁sentence｜><｜User｜>Explain more!<｜Assistant｜>

Un BOS est ajouté de force, et un EOS sépare chaque interaction. Pour éviter les doubles jetons BOS lors de l'inférence, vous ne devriez appeler que tokenizer.encode(..., add_special_tokens = False) puisque le modèle de chat ajoute automatiquement un token BOS également. Pour l'inférence llama.cpp / GGUF, vous devez sauter le BOS car il l'ajoutera automatiquement :

<｜User｜>What is 1+1?<｜Assistant｜>

Le <think> et </think> les tokens obtiennent leurs propres tokens désignés.

Téléversements de modèles

TOUS nos téléversements - y compris ceux qui ne sont pas basés sur imatrix ou dynamiques, utilisent notre jeu de données de calibration, qui est spécialement optimisé pour les tâches conversationnelles, de codage et de langage.

• Distillation Qwen3 (8B) : DeepSeek-R1-0528-Qwen3-8B-GGUF

• Téléversements du modèle DeepSeek-R1-0528 complet ci-dessous :

Nous avons également téléchargé IQ4_NL et Q4_1 des quants qui s'exécutent spécifiquement plus rapidement pour les appareils ARM et Apple respectivement.

Bits MoE	Type + Lien	Taille sur disque	Détails
1,66 bit	TQ1_0	162 Go	1,92/1,56 bit
1,78 bit	IQ1_S	185 Go	2,06/1,56 bit
1,93 bit	IQ1_M	200 Go	2.5/2.06/1.56
2,42 bit	IQ2_XXS	216 Go	2,5/2,06 bit
2,71 bit	Q2_K_XL	251 Go	3,5/2,5 bit
3,12 bit	IQ3_XXS	273 Go	3,5/2,06 bit
3,5 bit	Q3_K_XL	296 Go	4,5/3,5 bit
4,5 bit	Q4_K_XL	384 Go	5,5/4,5 bit
5,5 bit	Q5_K_XL	481 Go	6,5/5,5 bit

Nous avons également téléversé des versions en format BF16, et l'original format FP8 (float8).

Exécuter les tutoriels DeepSeek-R1-0528 :

🦙 Exécuter dans Ollama/Open WebUI

1. Installez ollama si vous ne l'avez pas encore fait ! Vous ne pouvez exécuter que des modèles jusqu'à 32B. Pour exécuter le modèle R1-0528 complet de 720 Go, voir ici.

apt-get update
apt-get install pciutils -y
curl -fsSL https://ollama.com/install.sh | sh

1. Exécutez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal s'il échoue ! Nous incluons toutes nos corrections et paramètres suggérés (température, etc.) dans params dans notre téléversement Hugging Face !

ollama run hf.co/unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF:Q4_K_XL

1. (NOUVEAU) Pour exécuter le R1-0528 complet sur Ollama, vous pouvez utiliser notre TQ1_0 (quant de 162 Go) :

OLLAMA_MODELS=unsloth_downloaded_models ollama serve &

ollama run hf.co/unsloth/DeepSeek-R1-0528-GGUF:TQ1_0

🦙 Exécuter le R1-0528 complet sur Ollama/Open WebUI

Open WebUI a réalisé un tutoriel étape par étape sur la façon d'exécuter R1 ici et pour R1-0528, vous aurez juste besoin de remplacer R1 par la nouvelle quantification 0528 : docs.openwebui.com/tutorials/integrations/deepseekr1-dynamic/

(NOUVEAU) Pour exécuter le R1-0528 complet sur Ollama, vous pouvez utiliser notre TQ1_0 (quant de 162 Go) :

OLLAMA_MODELS=unsloth_downloaded_models ollama serve &

ollama run hf.co/unsloth/DeepSeek-R1-0528-GGUF:TQ1_0

Si vous voulez utiliser des quantifications plus grandes que TQ1_0 (162 Go) sur Ollama, vous devez d'abord fusionner les 3 fichiers GGUF divisés en 1 comme le code ci-dessous. Ensuite, vous devrez exécuter le modèle localement.

./llama.cpp/llama-gguf-split --merge \
  DeepSeek-R1-0528-GGUF/DeepSeek-R1-0528-UD-IQ1_S/DeepSeek-R1-0528-UD-IQ1_S-00001-of-00003.gguf \
	merged_file.gguf

✨ Exécuter R1 distillé Qwen3 dans llama.cpp

1. Pour exécuter le modèle R1-0528 complet de 720 Go, voir ici. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -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 -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

1. Puis utilisez directement llama.cpp pour télécharger le modèle :

./llama.cpp/llama-cli -hf unsloth/DeepSeek-R1-0528-Qwen3-8B-GGUF:Q4_K_XL --jinja

✨ Exécuter le R1-0528 complet sur llama.cpp

1. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -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/ggerganov/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp

1. Si vous voulez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:IQ1_S) 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 à un emplacement spécifique.

Veuillez essayer -ot ".ffn_.*_exps.=CPU" pour décharger toutes les couches MoE vers le CPU ! Cela vous permet effectivement de faire tenir toutes les couches non-MoE sur 1 GPU, améliorant les vitesses de génération. Vous pouvez personnaliser l'expression regex pour décharger plus de couches si vous disposez de plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez -ot ".ffn_(up|down)_exps.=CPU" Cela décharge les couches MoE de projection up et down.

Essayez -ot ".ffn_(up)_exps.=CPU" si vous avez encore plus de mémoire GPU. Cela ne décharge que les couches MoE de projection up.

Et enfin déchargez toutes les couches via -ot ".ffn_.*_exps.=CPU" Ceci utilise le moins de VRAM.

Vous pouvez aussi personnaliser le regex, par exemple -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" signifie décharger les couches MoE gate, up et down mais seulement à partir de la 6e couche.

export LLAMA_CACHE="unsloth/DeepSeek-R1-0528-GGUF"
./llama.cpp/llama-cli \
    -hf unsloth/DeepSeek-R1-0528-GGUF:IQ1_S \
    --cache-type-k q4_0 \
    --threads -1 \
    --n-gpu-layers 99 \
    --prio 3 \
    --temp 0.6 \
    --top-p 0.95 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU"

1. Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-IQ1_S(quant dynamique 1,78bit) ou d'autres versions quantifiées comme Q4_K_M . Nous recommandons d'utiliser notre quant dynamique 2,7 bits UD-Q2_K_XL pour équilibrer taille et précision. Plus de versions sur : https://huggingface.co/unsloth/DeepSeek-R1-0528-GGUF

# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois limiter les requêtes, donc mettez à 0 pour désactiver
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/DeepSeek-R1-0528-GGUF",
    local_dir = "unsloth/DeepSeek-R1-0528-GGUF",
    allow_patterns = ["*UD-IQ1_S*"], # Dynamique 1bit (168GB) Utilisez "*UD-Q2_K_XL*" pour Dynamique 2bit (251GB)
)

1. Exécutez le test Flappy Bird d'Unsloth comme décrit dans notre quantification dynamique 1,58 bit pour DeepSeek R1.

2. éditer --threads 32 pour le nombre de threads CPU, --ctx-size 16384 pour la longueur de 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'avez qu'une inférence CPU.

./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-R1-0528-GGUF/UD-IQ1_S/DeepSeek-R1-0528-UD-IQ1_S-00001-of-00004.gguf \
    --cache-type-k q4_0 \
    --threads -1 \
    --n-gpu-layers 99 \
    --prio 3 \
    --temp 0.6 \
    --top-p 0.95 \
    --min-p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU" \
    -no-cnv \
    --prompt "<｜User｜>Créez un jeu Flappy Bird en Python. Vous devez inclure les éléments suivants:\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez par un bleu clair.\n3. Appuyer plusieurs fois sur ESPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement parmi un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs foncées.\n5. Placez en bas un terrain coloré aléatoirement en marron foncé ou jaune.\n6. Affichez un score en haut à droite. Incrémentez-le si vous passez les tuyaux sans les toucher.\n7. Créez des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé, marron clair ou en une teinte gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Faites apparaître le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant de nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section finale en markdown.<｜Assistant｜>"

🎱 Test Heptagone

Vous pouvez également tester nos quantifications dynamiques via r/Localllama qui teste le modèle sur la création d'un moteur physique de base pour simuler des balles tournant dans une forme heptagonale fermée en rotation.

L'objectif est de faire tourner l'heptagone, et les balles dans l'heptagone doivent bouger.

Invite complète pour exécuter le modèle

./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-R1-0528-GGUF/UD-IQ1_S/DeepSeek-R1-0528-UD-IQ1_S-00001-of-00004.gguf \
    --cache-type-k q4_0 \
    --threads -1 \
    --n-gpu-layers 99 \
    --prio 3 \
    --temp 0.6 \
    --top_p 0.95 \
    --min_p 0.01 \
    --ctx-size 16384 \
    --seed 3407 \
    -ot ".ffn_.*_exps.=CPU" \
    -no-cnv \
    --prompt "<｜User｜>Écrivez un programme Python qui affiche 20 balles rebondissant à l'intérieur d'un heptagone en rotation :\n- Toutes les balles ont le même rayon.\n- Toutes les balles portent un numéro de 1 à 20.\n- Toutes les balles tombent du centre de l'heptagone au démarrage.\n- Les couleurs sont : #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- Les balles doivent être affectées par la gravité et la friction, et elles doivent rebondir de manière réaliste sur les parois tournantes. Il doit aussi y avoir des collisions entre les balles.\n- Le matériau de toutes les balles fait que la hauteur de rebond à l'impact ne dépassera pas le rayon de l'heptagone, mais sera supérieure au rayon de la balle.\n- Toutes les balles tournent avec friction, les numéros sur les balles peuvent être utilisés pour indiquer la rotation de la balle.\n- L'heptagone tourne autour de son centre, et la vitesse de rotation est de 360 degrés toutes les 5 secondes.\n- La taille de l'heptagone doit être suffisamment grande pour contenir toutes les balles.\n- N'utilisez pas la bibliothèque pygame ; implémentez vous-même les algorithmes de détection de collision et la réponse aux collisions, etc. Les bibliothèques Python suivantes sont autorisées : tkinter, math, numpy, dataclasses, typing, sys.\n- Tous les codes doivent être placés dans un seul fichier Python.<｜Assistant｜>"

🦥 Fine-tuning de DeepSeek-R1-0528 avec Unsloth

Pour affiner DeepSeek-R1-0528-Qwen3-8B en utilisant Unsloth, nous avons créé un nouveau notebook GRPO comportant une fonction de récompense personnalisée conçue pour améliorer significativement la production multilingue - augmentant spécifiquement le taux de réponses dans la langue souhaitée (dans notre exemple nous utilisons l'indonésien mais vous pouvez utiliser n'importe quelle langue) de plus de 40 %.

• notebook DeepSeek-R1-0528-Qwen3-8B - nouveau

Alors que de nombreux LLM de raisonnement ont des capacités multilingues, ils produisent souvent des sorties mixtes dans leurs traces de raisonnement, combinant l'anglais avec la langue cible. Notre fonction de récompense atténue efficacement ce problème en encourageant fortement les sorties dans la langue désirée, ce qui conduit à une amélioration substantielle de la cohérence linguistique.

Cette fonction de récompense est également entièrement personnalisable, vous permettant de l'adapter à d'autres langues ou d'affiner pour des domaines ou cas d'utilisation spécifiques.

Le meilleur dans tout ça est que vous N'AVEZ PAS besoin d'un jeu de données linguistique pour forcer votre modèle à apprendre une langue spécifique. Le notebook n'a aucun jeu de données indonésien.

Unsloth rend l'affinage distillé R1-Qwen3 2× plus rapide, utilise 70 % de VRAM en moins et prend en charge des longueurs de contexte 8× plus longues.