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

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

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

**Téléchargements Unsloth de QwQ-32B avec nos correctifs :**

| [format GGUF](https://huggingface.co/unsloth/QwQ-32B-GGUF) | [4 bits dynamique](https://huggingface.co/unsloth/QwQ-32B-unsloth-bnb-4bit) | [4 bits BnB](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 (facultatif, 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 poser des problèmes. Forcez-le à 0.0.
{% endhint %}

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

Nous avons remarqué que beaucoup de personnes utilisent un `pénalité de répétition` supérieure à 1.0. Par exemple 1.1 à 1.5. Cela interfère en fait avec les mécanismes d'échantillonnage de llama.cpp. Le but 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 aussi (c.-à-d. le régler à 1.0), mais nous avons trouvé son utilisation utile pour pénaliser les générations infinies.

Pour l'utiliser, nous avons constaté 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 infinies. Ajoutez donc 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éorganisons essentiellement temperature et dry, et déplaçons min\_p vers l'avant. 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 encore des problèmes, vous pouvez augmenter`--repeat-penalty 1.0 à 1.2 ou 1.3.`

Avec l'aimable autorisation de [@krist486](https://x.com/krist486/status/1897885598196654180) pour avoir attiré mon attention sur les directives d'échantillonnage de llama.cpp.

## :sunny: Pénalité de répétition Dry

Nous avons étudié l'utilisation de `la pénalité dry` 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 fait constaté que cela **provoquait plutôt des problèmes de syntaxe, en particulier pour le code**. Si vous rencontrez encore 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 `la pénalité dry`.

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

1. Installez `ollama` si vous ne l’avez pas déjà 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 si cela échoue ! Nous incluons tous nos correctifs et paramètres suggérés (temperature, min\_p, etc.) dans `param` dans notre téléchargement 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 version `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez également 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 souhaitez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez comme d'habitude - la prise en charge de Metal est activée 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 précision complète). 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 du contexte, `--n-gpu-layers 99` pour le déchargement GPU, selon le nombre 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.
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 avec 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 comme une couleur sombre.\n5. Placez en bas un sol de couleur marron foncé ou jaune, choisi aléatoirement.\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. Coloriez-les aléatoirement en vert foncé, brun clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l'intérieur de l'écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer consiste à appuyer à nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter 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> article de blog 1.58bit est :

```
<|im_start|>user
Créez un jeu Flappy Bird en Python. Vous devez inclure les éléments suivants :
1. Vous devez utiliser pygame.
2. La couleur de fond doit être choisie aléatoirement et être une teinte claire. Commencez avec une couleur 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 un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs sombres.
5. Placez en bas un sol coloré en brun foncé ou en jaune, choisi aléatoirement.
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. Coloriez-les aléatoirement en vert foncé, marron clair ou 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 Échap quittera le jeu. Pour recommencer, appuyez à nouveau sur ESPACE.
Le jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter 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 finale Python 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  # Suivi de la première partie

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

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

        if not game_over:
            # Mise à jour de l'oiseau et des tuyaux
            bird.update()
            ### Continue

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

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

<details>

<summary>Sortie Python finale 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  # Suivi de la première partie

    # Configuration initiale
    background_color = (173, 216, 230)  # Bleu clair au départ
    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 le premier game over
                            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  # Vitesse initiale vers le haut

        if not game_over:
            # Mise à jour de l'oiseau et des tuyaux
            bird.update()

            # Faire défiler 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 dé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 le sol
        pygame.draw.rect(screen, land_color, (0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT))
        # Dessiner l'oiseau
        bird.draw()
        # Afficher 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('Press SPACE to restart', 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. Lorsque nous l'exécutons, nous obtenons un jeu jouable !

<figure><img src="/files/6f7783a1e1978995b5f5f0900de51df9a2e5679a" alt=""><figcaption></figcaption></figure>

7. Maintenant essayez la même chose sans nos correctifs ! Supprimez donc `--samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"` Cela 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 avec 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 comme une couleur sombre.\n5. Placez en bas un sol de couleur marron foncé ou jaune, choisi aléatoirement.\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. Coloriez-les aléatoirement en vert foncé, brun clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l'intérieur de l'écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer consiste à appuyer à nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter 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 quelques boucles, mais **une syntaxe Python problématiquement incorrecte** et bien d'autres problèmes. Par exemple, ce qui suit semble correct, mais est faux ! C.-à-d. ligne 39 `pipes.clear() ### <<< NameError: name 'pipes' is not defined. Did you forget to import '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: name 'pipes' is not defined. Did you forget to import 'pipes' ?
```

{% endcode %}

8. Si vous utilisez `--repeat-penalty 1.5`, c'est encore pire et plus évident, avec une syntaxe totalement incorrecte en fait.

```python
import pygame
from random import randint  # Pour générer aléatoirement des couleurs/formes/positions 
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
   # mis à 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é. Faute de temps, la version complète 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 à nouveau si nous n'utilisons pas notre correctif -`-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: Ça ne marche toujours pas ? 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 diversifiées, 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 avec 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 comme une couleur sombre.\n5. Placez en bas un sol de couleur marron foncé ou jaune, choisi aléatoirement.\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. Coloriez-les aléatoirement en vert foncé, brun clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l'intérieur de l'écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer consiste à appuyer à nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter 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 avec 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 comme une couleur sombre.\n5. Placez en bas un sol de couleur marron foncé ou jaune, choisi aléatoirement.\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. Coloriez-les aléatoirement en vert foncé, brun clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Placez le texte à l'intérieur de l'écran. Appuyer sur q ou Échap quittera le jeu. Redémarrer consiste à appuyer à nouveau sur ESPACE.\nLe jeu final doit se trouver dans une section markdown en Python. Vérifiez votre code pour détecter les erreurs et corrigez-les avant la section markdown finale.<|im_end|>\n<|im_start|>assistant\n<think>\n"
```

## :thinking: le token \<think> n'est pas affiché ?

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

{% code overflow="wrap" %}

```
```

{% endcode %}

vers 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 afin de forcer le modèle à passer en mode raisonnement.

Alors 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>Modèle jinja complet avec la partie &#x3C;think>\n supprimée</summary>

{% code overflow="wrap" %}

```
```

{% endcode %}

</details>

## Notes supplémentaires

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

1. La longueur de contexte de QwQ n'était pas nativement de 128K, mais plutôt de 32K avec l'extension YaRN. Par exemple, dans le fichier readme de <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 remplacer 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 peut-être l'epsilon de la couche RMS Layernorm était गलत - pas 1e-5 mais peut-être 1e-6. Par exemple [ceci](https://huggingface.co/Qwen/Qwen2.5-32B-Instruct/blob/main/config.json) a `rms_norm_eps=1e-06`, tandis que [ceci](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 identifiants du tokenizer correspondaient entre llama.cpp et les Transformers normaux, avec l'aimable autorisation de [@kalomaze](https://x.com/kalomaze/status/1897875332230779138). Ils correspondaient, donc ce n'était pas le coupable.

Nous présentons nos résultats expérimentaux ci-dessous :

{% file src="/files/ab8e19ccab9fb8e1dc425eb8905a58e34e8e64ba" %}
Précision BF16 complète sans correction d'échantillonnage
{% endfile %}

{% file src="/files/c5489dfaa0d56442e751674faccf6e817af42d4c" %}
Précision BF16 complète avec correction d'échantillonnage
{% endfile %}

{% file src="/files/7700fd5023a4a535ca8615fc5b324be0883adffc" %}
Précision Q4\_K\_M sans correction d'échantillonnage
{% endfile %}

{% file src="/files/c9271f0a4f06a134bb3e6103ffab71d21f070b9e" %}
Précision Q4\_K\_M avec correction d'échantillonnage
{% endfile %}

## :pencil2: Correctifs de bug du tokenizer

* Nous avons également trouvé quelques problèmes qui affectaient 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: Quantifications dynamiques 4 bits

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

<figure><img src="/files/a0ec56a79b00277f99dea921c4fb7086881a6a43" alt=""><figcaption></figcaption></figure>

Nous avons téléchargé des quantifications dynamiques 4 bits vers : <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 quantifications dynamiques 4 bits d'Unsloth !

Tous nos GGUF se trouvent à <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.