🐋DeepSeek-R1-0528 : comment l'exécuter localement

Un guide pour exécuter DeepSeek-R1-0528, y compris Qwen3, sur votre propre appareil local !

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

DeepSeek a également publié une version distillée de R1-0528 en affinant Qwen3 (8B). La distillation obtient 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 en MMLU à 5 shots et en divergence KL, ce qui signifie que vous pouvez exécuter et affiner des LLM DeepSeek quantifiés avec une perte d’exactitude minimale.

Navigation des tutoriels :

Exécuter dans llama.cpp Exécuter dans Ollama/Open WebUI Affinage de R1-0528

NOUVEAU : énormes améliorations du recours aux outils et corrections du format de chat. Nouveau quantification dynamique TQ1_0 1,66 bit - taille de 162 Go. Idéal pour 192 Go de RAM (Mac inclus) et les utilisateurs d’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 pratiquement s’intégrer dans n’importe quelle configuration, même avec seulement 20 Go de RAM. Aucune préparation préalable n’est nécessaire. Cependant, pour le modèle complet R1-0528, dont la taille est de 715 Go, une préparation supplémentaire sera nécessaire. La quantification 1,78 bit (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 également 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 combinés de RAM+VRAM 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 très bien.

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

🐳 Paramètres officiels recommandés :

Selon DeepSeek, voici les paramètres recommandés pour l’inférence de R1 (R1-0528 et le distill Qwen3 devraient 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é)
Exécutez plusieurs tests et faites la moyenne des résultats pour une évaluation fiable.

🔢 Format du modèle 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 quand même l’ajouter !

<｜begin▁of▁sentence｜><｜User｜>Que vaut 1+1 ?<｜Assistant｜>C’est 2.<｜end▁of▁sentence｜><｜User｜>Explique davantage !<｜Assistant｜>

Un BOS est ajouté de force, et un EOS sépare chaque interaction. Pour contrer les doubles tokens BOS lors de l’inférence, vous ne devez appeler que tokenizer.encode(..., add_special_tokens = False) puisque le modèle de chat ajoute automatiquement aussi un token BOS. Pour l’inférence llama.cpp / GGUF, vous devez ignorer le BOS puisqu’il sera ajouté automatiquement :

<｜User｜>Que vaut 1+1 ?<｜Assistant｜>

Les <think> et </think> tokens disposent de leurs propres tokens dédiés.

Téléversements du modèle

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, spécialement optimisé pour les tâches conversationnelles, de codage et de langue.

Distill Qwen3 (8B) : DeepSeek-R1-0528-Qwen3-8B-GGUF
Téléversements complets du modèle DeepSeek-R1-0528 ci-dessous :

Nous avons également téléversé IQ4_NL et Q4_1 des quantifications qui s’exécutent spécifiquement plus vite sur 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 au format BF16, ainsi que le format original FP8 (float8).

Exécuter les tutoriels DeepSeek-R1-0528 :

🦙 Exécuter dans Ollama/Open WebUI

Installer ollama si ce n’est pas déjà fait ! Vous ne pouvez exécuter que des modèles jusqu’à 32B de taille. Pour exécuter le modèle complet R1-0528 de 720 Go, voir ici.

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

Lancez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal si cela échoue ! Nous incluons tous nos correctifs 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

(NOUVEAU) Pour exécuter le modèle complet R1-0528 dans Ollama, vous pouvez utiliser notre TQ1_0 (quantification de 162 Go) :

OLLAMA_MODELS=unsloth_downloaded_models ollama serve &

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

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

Open WebUI a créé un tutoriel étape par étape sur la façon d’exécuter R1 ici et pour R1-0528, il vous suffira de remplacer R1 par la nouvelle quantification 0528 : https://docs.openwebui.com/tutorials/integrations/llm-providers/deepseekr1-dynamic

(NOUVEAU) Pour exécuter le modèle complet R1-0528 dans Ollama, vous pouvez utiliser notre TQ1_0 (quantification de 162 Go) :

OLLAMA_MODELS=unsloth_downloaded_models ollama serve &

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

Si vous souhaitez utiliser l’une des quantifications plus grandes que TQ1_0 (162 Go) sur Ollama, vous devez d’abord fusionner les 3 fichiers GGUF découpés en 1, comme dans 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

Pour exécuter le modèle complet R1-0528 de 720 Go, voir ici. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis poursuivez comme d’habitude - 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 -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

Ensuite, 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 R1-0528 complet dans llama.cpp

Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez également suivre les instructions de compilation ci-dessous. Modifiez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. Pour les appareils Apple Mac / Metal, définissez -DGGML_CUDA=OFF puis poursuivez comme d’habitude - 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 -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

Si vous souhaitez utiliser llama.cpp directement pour charger des modèles, vous pouvez faire ce qui suit : (:IQ1_S) est le type de quantification. Vous pouvez également 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.

Veuillez essayer -ot ".ffn_.*_exps.=CPU" pour décharger toutes les couches MoE vers le CPU ! Cela permet en pratique de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l’expression regex pour décharger davantage de couches si vous avez 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 ascendante et descendante.

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

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

Vous pouvez aussi personnaliser la 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 uniquement à 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"

Téléchargez le modèle via (après avoir installé pip install huggingface_hub hf_transfer ). Vous pouvez choisir UD-IQ1_S(quantification dynamique 1,78 bit) ou d’autres versions quantifiées comme Q4_K_M . Nous recommandons d’utiliser notre quantification 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 déclencher une limitation de débit, donc définissez à 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*"], # Quantification dynamique 1 bit (168 Go) Utilisez "*UD-Q2_K_XL*" pour la quantification dynamique 2 bits (251 Go)
)

Exécutez le test Flappy Bird d’Unsloth comme décrit dans notre quantification dynamique 1,58 bit pour DeepSeek R1.
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, indiquant combien de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le aussi 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 avec une couleur 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 une couleur sombre.\n5. Placez en bas un sol coloré en brun foncé ou jaune, choisi aléatoirement.\n6. Affichez un score en haut à droite. Augmentez-le si vous passez les tuyaux sans les heurter.\n7. Créez des tuyaux espacés aléatoirement avec suffisamment d’espace. Coloriez-les aléatoirement en vert foncé, brun clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Faites en sorte que le texte soit à l’intérieur de l’écran. Appuyer sur q ou Esc quittera le jeu. Le redémarrage se fait en appuyant à nouveau sur ESPACE.\nLe jeu final doit être placé dans une section markdown en Python. Vérifiez votre code pour détecter les erreurs et corrigez-les avant la section markdown finale.<｜Assistant｜>"

🎱 Test de l’heptagone

Vous pouvez aussi 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 d’heptagone fermée en mouvement.

Prompt complet 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 montre 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 depuis le 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 en rotation. Il doit aussi y avoir des collisions entre les balles.\n- Le matériau de toutes les balles détermine que la hauteur de rebond de leur 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 la balle 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 en 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 de réponse aux collisions, etc. Les bibliothèques Python suivantes sont autorisées : tkinter, math, numpy, dataclasses, typing, sys.\n- Tout le code doit être placé dans un seul fichier Python.<｜Assistant｜>"

🦥 Affinage de DeepSeek-R1-0528 avec Unsloth

Pour affiner DeepSeek-R1-0528-Qwen3-8B avec Unsloth, nous avons তৈরি un nouveau notebook GRPO avec une fonction de récompense personnalisée conçue pour améliorer considérablement la sortie multilingue - en 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

Bien que de nombreux LLM de raisonnement aient des capacités multilingues, ils produisent souvent des sorties mêlant plusieurs langues dans leurs traces de raisonnement, en 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 souhaitée, ce qui conduit à une amélioration substantielle de la cohérence linguistique.

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

Le meilleur dans cette fonction de récompense et ce notebook, c’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 ne contient aucun jeu de données indonésien.

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

Mis à jour il y a 4 mois

Ce contenu vous a-t-il été utile ?