# QwQ-32B : comment l'exécuter efficacement

Qwen a publié QwQ-32B - un modèle de raisonnement dont les performances sont comparables à DeepSeek-R1 sur de nombreux [benchmarks](https://qwenlm.github.io/blog/qwq-32b/). Cependant, les gens ont rencontré **générations infinies**, **nombreuses répétitions**, des problèmes de token \<think> et des problèmes de fine-tuning. Nous espérons que ce guide aidera à déboguer et à corriger la plupart des problèmes !

{% hint style="info" %}
Nos uploads de modèle avec nos corrections de bugs fonctionnent très bien pour le fine-tuning, vLLM et Transformers. Si vous utilisez llama.cpp et des moteurs qui utilisent llama.cpp en backend, suivez nos [instructions ici](#tutorial-how-to-run-qwq-32b) pour corriger les générations sans fin.
{% endhint %}

**Unsloth QwQ-32B téléversements avec nos correctifs :**

| [GGUF](https://huggingface.co/unsloth/QwQ-32B-GGUF) | [4 bits dynamiques](https://huggingface.co/unsloth/QwQ-32B-unsloth-bnb-4bit) | [BnB 4 bits](https://huggingface.co/unsloth/QwQ-32B-bnb-4bit) | [16 bits](https://huggingface.co/unsloth/QwQ-32B) |
| --------------------------------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------- | ------------------------------------------------- |

## :gear: Paramètres officiels recommandés

Selon [Qwen](https://huggingface.co/Qwen/QwQ-32B), voici les paramètres recommandés pour l'inférence :

* Température de 0,6
* Top\_K de 40 (ou 20 à 40)
* Min\_P de 0,00 (optionnel, mais 0,01 fonctionne bien, la valeur par défaut de llama.cpp est 0,1)
* Top\_P de 0,95
* Pénalité de répétition de 1,0. (1,0 signifie désactivé dans llama.cpp et transformers)
* Modèle de chat : `<|im_start|>user\nCréer un jeu Flappy Bird en Python.<|im_end|>\n<|im_start|>assistant\n<think>\n`

{% hint style="warning" %}
`llama.cpp` utilise `min_p = 0.1`par défaut, ce qui peut causer des problèmes. Forcez-le à 0.0.
{% endhint %}

## :thumbsup: Paramètres recommandés pour llama.cpp

Nous avons remarqué que beaucoup de gens utilisent une `pénalité de répétition` supérieure à 1,0. Par exemple 1,1 à 1,5. Cela interfère en réalité avec les mécanismes d'échantillonnage de llama.cpp. L'objectif d'une pénalité de répétition est de pénaliser les générations répétées, mais nous avons constaté que cela ne fonctionne pas comme prévu.

Désactiver `pénalité de répétition` fonctionne également (c.-à-d. le régler à 1,0), mais nous avons trouvé utile de l'utiliser pour pénaliser les générations sans fin.

Pour l'utiliser, nous avons découvert que vous devez également modifier l'ordre des échantillonneurs dans llama.cpp avant d'appliquer `pénalité de répétition`, sinon il y aura des générations sans fin. Donc ajoutez ceci :

```bash
--samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"
```

Par défaut, llama.cpp utilise cet ordre :

```bash
--samplers "dry;top_k;typ_p;top_p;min_p;xtc;temperature"
```

Nous réordonnons essentiellement temperature et dry, et avançons min\_p. Cela signifie que nous appliquons les échantillonneurs dans cet ordre :

```bash
top_k=40
top_p=0,95
min_p=0,0
temperature=0,6
dry
typ_p
xtc
```

Si vous rencontrez toujours des problèmes, vous pouvez augmenter la`--repeat-penalty 1.0 à 1.2 ou 1.3.`

Crédit à [@krist486](https://x.com/krist486/status/1897885598196654180) pour avoir attiré mon attention sur les directions d'échantillonnage de llama.cpp.

## :sunny: Dry Repetition Penalty

Nous avons étudié l'utilisation de `dry penalty` comme suggéré dans <https://github.com/ggml-org/llama.cpp/blob/master/examples/main/README.md> en utilisant une valeur de 0,8, mais nous avons en réalité constaté que cela **provoque plutôt des problèmes de syntaxe surtout pour le code**. Si vous rencontrez toujours des problèmes, vous pouvez augmenter la`pénalité dry à 0,8.`

Utiliser notre ordre d'échantillonnage inversé peut également aider si vous décidez d'utiliser `dry penalty`.

## :llama: Tutoriel : Comment exécuter QwQ-32B dans Ollama

1. Installer `ollama` si vous ne l’avez pas encore fait !

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

2. Lancez le modèle ! Notez que vous pouvez appeler `ollama serve`dans un autre terminal s'il échoue ! Nous incluons toutes nos corrections et paramètres suggérés (temperature, min\_p etc.) dans `param` dans notre upload Hugging Face !

```bash
ollama run hf.co/unsloth/QwQ-32B-GGUF:Q4_K_M
```

## 📖 Tutoriel : Comment exécuter QwQ-32B dans llama.cpp

1. Obtenez la dernière `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez aussi suivre les instructions de compilation ci-dessous. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez simplement de l'inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - le support Metal est activé par défaut.

```bash
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=ON -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. 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 BF16 en pleine précision). Plus de versions sur : <https://huggingface.co/unsloth/QwQ-32B-GGUF>

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/QwQ-32B-GGUF",
    local_dir = "unsloth-QwQ-32B-GGUF",
    allow_patterns = ["*Q4_K_M*"], # Pour Q4_K_M
)
```

3. Exécutez le test Flappy Bird d'Unsloth, qui enregistrera la sortie dans `Q4_K_M_yes_samplers.txt`
4. Modifier `--threads 32` pour le nombre de threads CPU, `--ctx-size 16384` pour la longueur de contexte, `--n-gpu-layers 99` pour le déchargement sur GPU du nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous avez uniquement une inférence CPU.
5. Nous utilisons `--repeat-penalty 1.1` et `--dry-multiplier 0.5` que vous pouvez ajuster.

```bash
./llama.cpp/llama-cli \
    --model unsloth-QwQ-32B-GGUF/QwQ-32B-Q4_K_M.gguf \
    --threads 32 \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.6 \
    --repeat-penalty 1.1 \
    --dry-multiplier 0.5 \
    --min-p 0.01 \
    --top-k 40 \
    --top-p 0.95 \
    -no-cnv \
    --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" \
    --prompt "<|im_start|>user\nCréer un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez par une couleur bleu clair.\n3. Appuyer plusieurs fois sur SPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement comme un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement comme une couleur sombre.\n5. Placez en bas une zone de terre colorée en brun foncé ou jaune choisie aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez si vous dépassez les tuyaux et ne les heurtez pas.\n7. Faites des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé ou brun clair ou en une teinte gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant à nouveau sur SPACE.\nLe jeu final doit être à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<|im_end|>\n<|im_start|>assistant\n<think>\n"  \
        2>&1 | tee Q4_K_M_yes_samplers.txt
```

L'entrée complète de notre <https://unsloth.ai/blog/deepseekr1-dynamic> blog 1.58bit est :

```
<|im_start|>user
Créez un jeu Flappy Bird en Python. Vous devez inclure ces éléments :
1. Vous devez utiliser pygame.
2. La couleur de fond doit être choisie au hasard et être une teinte claire. Commencez avec un bleu clair.
3. Appuyer plusieurs fois sur ESPACE accélérera l'oiseau.
4. La forme de l'oiseau doit être choisie aléatoirement parmi carré, cercle ou triangle. La couleur doit être choisie aléatoirement et être sombre.
5. Placez en bas un morceau de terrain coloré en brun foncé ou jaune choisi au hasard.
6. Affichez un score en haut à droite. Incrémentez-le si vous passez les tuyaux sans les toucher.
7. Créez des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé, marron clair ou une teinte gris foncé.
8. 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.
Le jeu final doit être à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<|im_end|>
<|im_start|>assistant
<think>
```

Le début et la fin de la sortie Python finale après suppression des parties de réflexion :

```python
import pygame
import random
import sys

pygame.init()
### Continue

class Bird :
    def __init__(self) :
        ### Continue

def main() :
    best_score = 0
    current_score = 0
    game_over = False
    pipes = []
    first_time = True  # Suivre la première partie

    # Configuration initiale
    background_color = (173, 216, 230)  # Bleu clair initialement
    land_color = random.choice(land_colors)
    bird = Bird()

    while True :
        for event in pygame.event.get() :
            ### Continue

        if not game_over :
            # Mettre à jour l'oiseau et les tuyaux
            bird.update()
            ### Continue

        # Dessin
        ### Continue
        pygame.display.flip()
        clock.tick(60)

if __name__ == "__main__":
    main()
```

<details>

<summary>Sortie finale Python complète (parties de réflexion supprimées) :</summary>

{% code fullWidth="false" %}

```python
import pygame
import random
import sys

pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Flappy Bird Clone")
clock = pygame.time.Clock()

# Couleurs
pipe_colors = [(0, 100, 0), (210, 180, 140), (50, 50, 50)]
land_colors = [(139, 69, 19), (255, 255, 0)]

# Constantes du jeu
GRAVITY = 0.5
PIPE_SPEED = 5
BIRD_SIZE = 30
LAND_HEIGHT = 50
PIPE_WIDTH = 50
PIPE_GAP = 150

class Bird :
    def __init__(self) :
        self.x = WIDTH // 2
        self.y = HEIGHT // 2
        self.velocity = 0
        self.shape = random.choice(['square', 'circle', 'triangle'])
        self.color = (random.randint(0, 100), random.randint(0, 100), random.randint(0, 100))
        self.rect = pygame.Rect(self.x - BIRD_SIZE//2, self.y - BIRD_SIZE//2, BIRD_SIZE, BIRD_SIZE)
    
    def update(self):
        self.velocity += GRAVITY
        self.y += self.velocity
        self.rect.y = self.y - BIRD_SIZE//2
        self.rect.x = self.x - BIRD_SIZE//2  # Garder x centré
    
    def draw(self):
        if self.shape == 'square' :
            pygame.draw.rect(screen, self.color, self.rect)
        elif self.shape == 'circle' :
            pygame.draw.circle(screen, self.color, (self.rect.centerx, self.rect.centery), BIRD_SIZE//2)
        elif self.shape == 'triangle' :
            points = [
                (self.rect.centerx, self.rect.top),
                (self.rect.left, self.rect.bottom),
                (self.rect.right, self.rect.bottom)
            ]
            pygame.draw.polygon(screen, self.color, points)

def spawn_pipe() :
    pipe_x = WIDTH
    top_height = random.randint(50, HEIGHT - PIPE_GAP - LAND_HEIGHT)
    rect_top = pygame.Rect(pipe_x, 0, PIPE_WIDTH, top_height)
    bottom_y = top_height + PIPE_GAP
    bottom_height = (HEIGHT - LAND_HEIGHT) - bottom_y
    rect_bottom = pygame.Rect(pipe_x, bottom_y, PIPE_WIDTH, bottom_height)
    color = random.choice(pipe_colors)
    return {
        'rect_top': rect_top,
        'rect_bottom': rect_bottom,
        'color': color,
        'scored': False
    }

def main() :
    best_score = 0
    current_score = 0
    game_over = False
    pipes = []
    first_time = True  # Suivre la première partie

    # Configuration initiale
    background_color = (173, 216, 230)  # Bleu clair initialement
    land_color = random.choice(land_colors)
    bird = Bird()

    while True :
        for event in pygame.event.get() :
            if event.type == pygame.QUIT :
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN :
                if event.key == pygame.K_ESCAPE or event.key == pygame.K_q :
                    pygame.quit()
                    sys.exit()
                if event.key == pygame.K_SPACE :
                    if game_over :
                        # Réinitialiser le jeu
                        bird = Bird()
                        pipes.clear()
                        current_score = 0
                        if first_time :
                            # Premier redémarrage après la première fin de partie
                            background_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))
                            first_time = False
                        else:
                            background_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))
                        land_color = random.choice(land_colors)
                        game_over = False
                    else:
                        # Faire sauter l'oiseau
                        bird.velocity = -15  # Vélocité initiale vers le haut

        if not game_over :
            # Mettre à jour l'oiseau et les tuyaux
            bird.update()

            # Déplacer les tuyaux vers la gauche
            remove_pipes = []
            for pipe in pipes :
                pipe['rect_top'].x -= PIPE_SPEED
                pipe['rect_bottom'].x -= PIPE_SPEED
                # Vérifier si l'oiseau a passé le tuyau
                if not pipe['scored'] and bird.rect.x > pipe['rect_top'].right :
                    current_score += 1
                    pipe['scored'] = True
                # Vérifier si le tuyau est hors écran
                if pipe['rect_top'].right < 0 :
                    remove_pipes.append(pipe)
            # Supprimer les tuyaux hors écran
            for p in remove_pipes :
                pipes.remove(p)

            # Générer un nouveau tuyau si nécessaire
            if not pipes or pipes[-1]['rect_top'].x < WIDTH - 200 :
                pipes.append(spawn_pipe())

            # Vérifier les collisions
            land_rect = pygame.Rect(0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT)
            bird_rect = bird.rect
            # Vérifier les tuyaux
            for pipe in pipes :
                if bird_rect.colliderect(pipe['rect_top']) or bird_rect.colliderect(pipe['rect_bottom']) :
                    game_over = True
                    break
            # Vérifier le sol et le haut
            if bird_rect.bottom >= land_rect.top or bird_rect.top <= 0 :
                game_over = True

            if game_over :
                if current_score > best_score :
                    best_score = current_score

        # Dessin
        screen.fill(background_color)
        # Dessiner les tuyaux
        for pipe in pipes :
            pygame.draw.rect(screen, pipe['color'], pipe['rect_top'])
            pygame.draw.rect(screen, pipe['color'], pipe['rect_bottom'])
        # Dessiner la terre
        pygame.draw.rect(screen, land_color, (0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT))
        # Dessiner l'oiseau
        bird.draw()
        # Dessiner le score
        font = pygame.font.SysFont(None, 36)
        score_text = font.render(f'Score: {current_score}', True, (0, 0, 0))
        screen.blit(score_text, (WIDTH - 150, 10))
        # Écran de fin de partie
        if game_over :
            over_text = font.render('Game Over!', True, (255, 0, 0))
            best_text = font.render(f'Best: {best_score}', True, (255, 0, 0))
            restart_text = font.render('Appuyez sur SPACE pour redémarrer', True, (255, 0, 0))
            screen.blit(over_text, (WIDTH//2 - 70, HEIGHT//2 - 30))
            screen.blit(best_text, (WIDTH//2 - 50, HEIGHT//2 + 10))
            screen.blit(restart_text, (WIDTH//2 - 100, HEIGHT//2 + 50))
        
        pygame.display.flip()
        clock.tick(60)

if __name__ == "__main__":
    main()
```

{% endcode %}

</details>

6. En l'exécutant, nous obtenons un jeu exécutable !

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-1740ecd246c7f62c363bc0ba1e0f1099b2f9b2a4%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>

7. Essayez maintenant la même chose sans nos correctifs ! Donc supprimez `--samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"` Ceci enregistrera la sortie dans `Q4_K_M_no_samplers.txt`

```bash
./llama.cpp/llama-cli \
    --model unsloth-QwQ-32B-GGUF/QwQ-32B-Q4_K_M.gguf \
    --threads 32 \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    --seed 3407 \
    --prio 2 \
    --temp 0.6 \
    --repeat-penalty 1.1 \
    --dry-multiplier 0.5 \
    --min-p 0.01 \
    --top-k 40 \
    --top-p 0.95 \
    -no-cnv \
    --prompt "<|im_start|>user\nCréer un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez par une couleur bleu clair.\n3. Appuyer plusieurs fois sur SPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement comme un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement comme une couleur sombre.\n5. Placez en bas une zone de terre colorée en brun foncé ou jaune choisie aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez si vous dépassez les tuyaux et ne les heurtez pas.\n7. Faites des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé ou brun clair ou en une teinte gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant à nouveau sur SPACE.\nLe jeu final doit être à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<|im_end|>\n<|im_start|>assistant\n<think>\n"  \
        2>&1 | tee Q4_K_M_no_samplers.txt
```

Vous obtiendrez des boucles, mais **une syntaxe Python problématiquement incorrecte** et de nombreux autres problèmes. Par exemple, ce qui suit semble correct, mais est faux ! C.-à-d. la ligne 39 `pipes.clear() ### <<< NameError : nom 'pipes' non défini. Auriez-vous oublié d'importer 'pipes' ?`

{% code overflow="wrap" lineNumbers="true" %}

```python
import pygame
import random

pygame.init()

# Constantes
WIDTH, HEIGHT = 800, 600
GROUND_HEIGHT = 20
GRAVITY = 0,7
PIPE_SPEED = -3
BIRD_SIZE = 45
MIN_GAP = 130
MAX_GAP = 200
PIPE_COLORS = [(0, 96, 0), (205, 133, 63), (89, 97, 107)]
DARK_BROWN = (94, 72, 4)
YELLOW = (252, 228, 6)

screen = pygame.display.set_mode((WIDTH, HEIGHT))
clock = pygame.time.Clock()

def random_light_color() :
    return (
        random.randint(180, 230),
        random.randint(190, 300),
        random.randint(250, 255)
    )

def reset_game() :
    global bird_x, bird_y
    global pipes, score
    global background_color, land_color
    global bird_shape, bird_color

    # Propriétés de l'oiseau
    bird_x = WIDTH * 0.3
    bird_y = HEIGHT // 2
    bird_vel = -5  # Poussée initiale vers le haut

    pipes.clear() ### <<< NameError : nom 'pipes' non défini. Auriez-vous oublié d'importer 'pipes' ?
```

{% endcode %}

8. Si vous utilisez `--repeat-penalty 1.5`, ça devient encore pire et plus évident, avec une syntaxe en réalité totalement incorrecte.

```python
import pygame
from random import randint  # Pour générer des couleurs/formes/positions aléatoirement 
pygame.init()

# Constantes :
WIDTH, HEIGHT =456 ,702   #
BACKGROUND_COLOR_LIGHTS=['lightskyblue']
GAP_SIZE=189           #

BIRD_RADIUS=3.  
PIPE_SPEED=- ( )    ? 
class Game() :
def __init__(self) :
        self.screen_size=( )

def reset_game_vars() :
    global current_scor e
   # régler à zéro et autres états initiaux.

# Boucle principale du jeu :
while running :
     for event in pygame.event.get() : 
        if quit ... etc

pygame.quit()
print("Le code est simplifié. En raison des contraintes de temps, une version entièrement fonctionnelle nécessite une implémentation supplémentaire.")
```

9. Vous vous demandez peut-être si c'est Q4\_K\_M ? B16 c.-à-d. la pleine précision devrait bien fonctionner, non ? Incorrect - les sorties échouent encore si nous n'utilisons pas notre correctif de -`-samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"` lors de l'utilisation d'une pénalité de répétition.

## :sunrise\_over\_mountains: Toujours pas fonctionnel ? Essayez Min\_p = 0,1, Temperature = 1,5

Selon l'article sur Min\_p <https://arxiv.org/pdf/2407.01082>, pour des sorties plus créatives et diverses, et si vous voyez encore des répétitions, essayez de désactiver top\_p et top\_k !

```bash
./llama.cpp/llama-cli --model unsloth-QwQ-32B-GGUF/QwQ-32B-Q4_K_M.gguf \
    --threads 32 --n-gpu-layers 99 \
    --ctx-size 16384 \
    --temp 1.5 \
    --min-p 0.1 \
    --top-k 0 \
    --top-p 1.0 \
    -no-cnv \
    --prompt "<|im_start|>user\nCréer un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez par une couleur bleu clair.\n3. Appuyer plusieurs fois sur SPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement comme un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement comme une couleur sombre.\n5. Placez en bas une zone de terre colorée en brun foncé ou jaune choisie aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez si vous passez les tuyaux et ne les heurtez pas.\n7. Faites des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé ou brun clair ou en une teinte gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant à nouveau sur SPACE.\nLe jeu final doit être à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<|im_end|>\n<|im_start|>assistant\n<think>\n"
```

Une autre approche consiste à désactiver `min_p` directement, puisque llama.cpp utilise par défaut `min_p = 0.1`!

```bash
./llama.cpp/llama-cli --model unsloth-QwQ-32B-GGUF/QwQ-32B-Q4_K_M.gguf \
    --threads 32 --n-gpu-layers 99 \
    --ctx-size 16384 \
    --temp 0.6 \
    --min-p 0.0 \
    --top-k 40 \
    --top-p 0.95 \
    -no-cnv \
    --prompt "<|im_start|>user\nCréer un jeu Flappy Bird en Python. Vous devez inclure ces éléments :\n1. Vous devez utiliser pygame.\n2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez par une couleur bleu clair.\n3. Appuyer plusieurs fois sur SPACE accélérera l'oiseau.\n4. La forme de l'oiseau doit être choisie aléatoirement comme un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement comme une couleur sombre.\n5. Placez en bas une zone de terre colorée en brun foncé ou jaune choisie aléatoirement.\n6. Affichez un score en haut à droite. Incrémentez si vous passez les tuyaux et ne les heurtez pas.\n7. Faites des tuyaux espacés aléatoirement avec suffisamment d'espace. Colorez-les aléatoirement en vert foncé ou brun clair ou en une teinte gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez le texte à l'intérieur de l'écran. Appuyer sur q ou Esc quittera le jeu. Redémarrer se fait en appuyant à nouveau sur SPACE.\nLe jeu final doit être à l'intérieur d'une section markdown en Python. Vérifiez votre code pour les erreurs et corrigez-les avant la section markdown finale.<|im_end|>\n<|im_start|>assistant\n<think>\n"
```

## :thinking: \<think> token non affiché ?

Certaines personnes signalent que parce que \<think> est ajouté par défaut dans le template de chat, certains systèmes n'affichent pas correctement les traces de réflexion. Vous devrez modifier manuellement le template Jinja de :

{% code overflow="wrap" %}

```
```

{% endcode %}

à un autre en supprimant le `<think>\n` à la fin. Le modèle devra maintenant ajouter manuellement `<think>\n` pendant l'inférence, ce qui peut ne pas toujours réussir. DeepSeek a également modifié tous les modèles pour ajouter par défaut un `<think>` token pour forcer le modèle à entrer en mode raisonnement.

Donc changez `{%- if add_generation_prompt %} {{- '<|im_start|>assistant\n<think>\n' }} {%- endif %}` en `{%- if add_generation_prompt %} {{- '<|im_start|>assistant\n' }} {%- endif %}`

c.-à-d. supprimez `<think>\n`

<details>

<summary>Template Jinja complet avec la partie &#x3C;think> supprimée\n</summary>

{% code overflow="wrap" %}

```
```

{% endcode %}

</details>

## Notes supplémentaires

Nous avons d'abord pensé peut-être :

1. Le contexte de QwQ n'était pas nativement 128K, mais plutôt 32K avec l'extension YaRN. Par exemple dans le fichier readme pour <https://huggingface.co/Qwen/QwQ-32B>, nous voyons :

```json
{
  ...,
  "rope_scaling": {
    "factor": 4.0,
    "original_max_position_embeddings": 32768,
    "type": "yarn"
  }
}
```

Nous avons essayé de substituer la gestion YaRN de llama.cpp, mais rien n'a changé.

{% code overflow="wrap" %}

```bash
--override-kv qwen2.context_length=int:131072 \
--override-kv qwen2.rope.scaling.type=str:yarn \
--override-kv qwen2.rope.scaling.factor=float:4 \
--override-kv qwen2.rope.scaling.original_context_length=int:32768 \
--override-kv qwen2.rope.scaling.attn_factor=float:1.13862943649292 \
```

{% endcode %}

2. Nous avons aussi pensé que l'epsilon du RMS Layernorm était incorrect - pas 1e-5 mais peut-être 1e-6. Par exemple [cela](https://huggingface.co/Qwen/Qwen2.5-32B-Instruct/blob/main/config.json) a `rms_norm_eps=1e-06`, tandis que [cela](https://huggingface.co/Qwen/Qwen2.5-32B/blob/main/config.json) a `rms_norm_eps=1e-05` . Nous l'avons aussi remplacé, mais cela n'a pas fonctionné :

{% code overflow="wrap" %}

```bash
--override-kv qwen2.attention.layer_norm_rms_epsilon=float:0.000001 \
```

{% endcode %}

3. Nous avons également testé si les IDs du tokenizer correspondaient entre llama.cpp et les Transformers classiques grâce à [@kalomaze](https://x.com/kalomaze/status/1897875332230779138). Ils correspondaient, donc ce n'était pas la cause.

Nous fournissons nos résultats expérimentaux ci-dessous :

{% file src="<https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-daa99953e0628c36fd53745a4b786206907e7d9a%2Ffile_BF16_no_samplers.txt?alt=media>" %}
BF16 pleine précision sans correction d'échantillonnage
{% endfile %}

{% file src="<https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-52f35bdaa5b1d7c9c19e943f224f049de2f0555f%2Ffile_BF16_yes_samplers.txt?alt=media>" %}
BF16 pleine précision avec correction d'échantillonnage
{% endfile %}

{% file src="<https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-276ff61d8749856abacdd33f38e73f9782a516fd%2Ffinal_Q4_K_M_no_samplers.txt?alt=media>" %}
Précision Q4\_K\_M sans correction d'échantillonnage
{% endfile %}

{% file src="<https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-ea3905fe9ce08d0fdf291ee2a32eaa6958759547%2Ffinal_Q4_K_M_yes_samplers.txt?alt=media>" %}
Précision Q4\_K\_M avec correction d'échantillonnage
{% endfile %}

## :pencil2: Corrections de bugs du tokenizer

* Nous avons trouvé quelques problèmes impactant spécifiquement le fine-tuning ! Le token EOS est correct, mais le token PAD devrait probablement plutôt être `"<|vision_pad|>`" Nous l'avons mis à jour dans : <https://huggingface.co/unsloth/QwQ-32B/blob/main/tokenizer_config.json>

```
"eos_token": "<|im_end|>",
"pad_token": "<|endoftext|>",
```

## :tools: Quantisations dynamiques 4 bits

Nous avons également téléversé des quantisations dynamiques 4 bits qui augmentent la précision par rapport aux quantisations 4 bits naïves ! Nous joignons l'analyse du graphique d'erreur de quantification QwQ pour les erreurs de quantification d'activation et de poids :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-16157f53eff143c179be571a43f8b55000d94290%2FQwQ%20quantization%20errors.png?alt=media" alt=""><figcaption></figcaption></figure>

Nous avons téléversé des quantisations dynamiques 4 bits sur : <https://huggingface.co/unsloth/QwQ-32B-unsloth-bnb-4bit>

Depuis vLLM 0.7.3 (20 février 2025) <https://github.com/vllm-project/vllm/releases/tag/v0.7.3>, vLLM prend désormais en charge le chargement des quantisations dynamiques 4 bits d'Unsloth !

Tous nos GGUF sont sur <https://huggingface.co/unsloth/QwQ-32B-GGUF>!


---

# 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/fr/modeles/tutorials/qwq-32b-how-to-run-effectively.md?ask=<question>
```

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.