> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/modeles/tutorials/qwq-32b-how-to-run-effectively.md).

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

Comment exécuter QwQ-32B efficacement avec nos corrections de bugs et sans générations infinies + GGUF.

Qwen a publié QwQ-32B - un modèle de raisonnement aux performances comparables à celles de DeepSeek-R1 sur de nombreux [benchmarks](https://qwenlm.github.io/blog/qwq-32b/). Cependant, des personnes 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 aidera à déboguer et à résoudre la plupart des problèmes !

{% hint style="info" %}
Nos téléversements de modèles 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 notre [les instructions ici](#tutorial-how-to-run-qwq-32b) pour corriger les générations sans fin.
{% endhint %}

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

| [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 conversation : `<|im_start|>user\nCré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 et être une couleur sombre.\n5. Placez en bas un sol coloré en marron foncé ou en 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é, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez 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`

{% 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 personnes utilisent un `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. 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é que son utilisation est utile pour pénaliser les générations sans fin.

Pour l'utiliser, nous avons constaté qu'il faut aussi 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. 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éordonnons 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 le`--repeat-penalty 1.0 à 1.2 ou 1.3.`

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

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

Nous avons examiné 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, surtout pour le codage**. Si vous rencontrez encore des problèmes, vous pouvez augmenter le`la pénalité dry à 0.8.`

Utiliser notre ordre d'échantillonnage inversé peut aussi aider si vous décidez d'utiliser `la pénalité dry`.

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

1. Installez `ollama` si ce n'est pas déjà fait !

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

2. Exécutez 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éversement 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. Modifiez `-DGGML_CUDA=ON` à `-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 la précision complète BF16). Plus de versions ici : <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 GPU de combien de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le aussi si vous faites une inférence uniquement 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é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 et être une couleur sombre.\n5. Placez en bas un sol coloré en marron foncé ou en 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é, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez 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> blog 1,58 bit 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 d'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 de couleur marron foncé ou jaune choisi aléatoirement.
6. Affichez un score en haut à droite. Augmentez-le si vous passez les tuyaux sans les heurter.
7. Créez des tuyaux espacés aléatoirement avec suffisamment d'espace. Coloriez-les aléatoirement en vert foncé, marron clair ou dans une nuance de gris foncé.
8. Quand 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 se fait en appuyant à 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()
### Suite

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

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 au départ
    land_color = random.choice(land_colors)
    bird = Bird()

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

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

        # Dessin
        ### Suite
        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  # Suivre 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 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  # Vitesse initiale vers le haut

        if not game_over:
            # Mettre à jour l'oiseau et les 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()
        # 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('Partie terminée !', True, (255, 0, 0))
            best_text = font.render(f'Meilleur : {best_score}', True, (255, 0, 0))
            restart_text = font.render('Appuyez sur ESPACE 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, on obtient un jeu jouable !

<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 ! 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é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 et être une couleur sombre.\n5. Placez en bas un sol coloré en marron foncé ou en 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é, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez 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 un peu de bouclage, mais **une syntaxe Python problématiquement incorrecte** et bien d'autres problèmes. Par exemple, ce qui suit a l'air correct, mais est faux ! C.-à-d. ligne 39 `pipes.clear() ### <<< NameError : le nom 'pipes' n'est pas défini. Avez-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 : le nom 'pipes' n'est pas défini. Avez-vous oublié d'importer 'pipes' ?
```

{% endcode %}

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

```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
   # le mettre à zéro et dans d'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é. Par manque 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'est-à-dire la précision complète, devrait fonctionner correctement, n'est-ce pas ? Incorrect - les sorties échouent à nouveau si nous n'utilisons pas notre correctif de -`-samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"` lorsqu'on utilise 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é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 et être une couleur sombre.\n5. Placez en bas un sol coloré en marron foncé ou en 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é, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez 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é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 et être une couleur sombre.\n5. Placez en bas un sol coloré en marron foncé ou en 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é, marron clair ou gris foncé.\n8. Lorsque vous perdez, affichez le meilleur score. Mettez 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, parce que \<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 %}

à un autre en supprimant le `<think>\n` à la fin. Le modèle devra désormais 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 de raisonnement.

Donc, modifiez `{%- if add_generation_prompt %} {{- '<|im_start|>assistant\n<think>\n' }} {%- endif %}` à `{%- if add_generation_prompt %} {{- '<|im_start|>assistant\n' }} {%- endif %}`

c.-à-d. supprimer `<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é que 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>, on voit :

```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 de normalisation RMS était incorrect - non 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 également 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 vérifié si les ID du tokenizer correspondaient entre llama.cpp et Transformers normal, grâce à [@kalomaze](https://x.com/kalomaze/status/1897875332230779138). Ils correspondaient, donc ce n'était pas la cause.

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

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

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

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

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

## :pencil2: Corrections de bugs du tokenizer

* Nous avons également trouvé quelques problèmes affectant spécifiquement le fine-tuning ! Le jeton EOS est correct, mais le jeton 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 en 4 bits

Nous avons également téléversé des quantifications dynamiques en 4 bits qui améliorent la précision par rapport aux quantifications naïves en 4 bits ! Nous joignons l'analyse du graphique des erreurs de quantification de QwQ pour les erreurs de quantification des activations et des 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 quantifications dynamiques en 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 quantifications dynamiques 4 bits d'Unsloth !

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/modeles/tutorials/qwq-32b-how-to-run-effectively.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.