🌠QwQ-32B : Comment 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 dont les performances sont comparables à DeepSeek-R1 sur de nombreux benchmarks. 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 !

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 pour corriger les générations sans fin.

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

GGUF	4 bits dynamiques	BnB 4 bits	16 bits

⚙️ Paramètres officiels recommandés

Selon Qwen, 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

llama.cpp utilise min_p = 0.1par défaut, ce qui peut causer des problèmes. Forcez-le à 0.0.

👍 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 :

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

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

--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 :

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 pour avoir attiré mon attention sur les directions d'échantillonnage de llama.cpp.

☀️ 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 lapénalité dry à 0,8.

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

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

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

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

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

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. 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.

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

1. 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

# !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
)

1. Exécutez le test Flappy Bird d'Unsloth, qui enregistrera la sortie dans Q4_K_M_yes_samplers.txt

2. 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.

3. Nous utilisons --repeat-penalty 1.1 et --dry-multiplier 0.5 que vous pouvez ajuster.

./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 :

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()

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

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()

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

1. 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

./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' ?

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' ?

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

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.")

1. 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.

🌄 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 !

./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!

./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"

🤔 <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 :

à 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

Template Jinja complet avec la partie <think> supprimée\n

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 :

{
  ...,
  "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é.

--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 \

1. Nous avons aussi pensé que l'epsilon du RMS Layernorm était incorrect - pas 1e-5 mais peut-être 1e-6. Par exemple cela a rms_norm_eps=1e-06, tandis que cela a rms_norm_eps=1e-05 . Nous l'avons aussi remplacé, mais cela n'a pas fonctionné :

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

1. Nous avons également testé si les IDs du tokenizer correspondaient entre llama.cpp et les Transformers classiques grâce à @kalomaze. Ils correspondaient, donc ce n'était pas la cause.

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

61KB

file_BF16_no_samplers.txt

Ouvrir

BF16 pleine précision sans correction d'échantillonnage

55KB

file_BF16_yes_samplers.txt

Ouvrir

BF16 pleine précision avec correction d'échantillonnage

71KB

final_Q4_K_M_no_samplers.txt

Ouvrir

Précision Q4_K_M sans correction d'échantillonnage

65KB

final_Q4_K_M_yes_samplers.txt

Ouvrir

Précision Q4_K_M avec correction d'échantillonnage

✏️ 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|>",

🛠️ 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 :

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!