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

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

Qwen a publié QwQ-32B - un modèle de raisonnement avec des performances comparables à DeepSeek-R1 sur de nombreux benchmarks. 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 !

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

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

⚙️ 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 (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

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

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

--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éorganisons essentiellement temperature et dry, et déplaçons min_p vers l'avant. 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 encore des problèmes, vous pouvez augmenter--repeat-penalty 1.0 à 1.2 ou 1.3.

Avec l'aimable autorisation de @krist486 pour avoir attiré mon attention sur les directives d'échantillonnage de llama.cpp.

☀️ 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 augmenterla pénalité dry à 0.8.

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

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

Installez ollama si vous ne l’avez pas déjà fait !

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

Lancez le modèle ! Notez que vous pouvez appeler ollama servedans un autre terminal si cela échoue ! Nous incluons tous nos correctifs et paramètres suggérés (temperature, min_p, etc.) dans param dans notre téléchargement Hugging Face !

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

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

Obtenez la dernière version llama.cpp sur GitHub ici. 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.

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

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

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

Exécutez le test Flappy Bird d'Unsloth, qui enregistrera la sortie dans Q4_K_M_yes_samplers.txt
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.
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 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 :

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

Sortie Python finale 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  # 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()

Lorsque nous l'exécutons, nous obtenons un jeu jouable !

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

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

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

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

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

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.

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

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

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

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

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

Modèle jinja complet avec la partie <think>\n supprimée

Notes supplémentaires

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

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 :

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

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

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 a rms_norm_eps=1e-06, tandis que ceci 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 \

Nous avons également testé si les identifiants du tokenizer correspondaient entre llama.cpp et les Transformers normaux, avec l'aimable autorisation de @kalomaze. Ils correspondaient, donc ce n'était pas le coupable.

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

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

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

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!

PrécédentPhi-4 Reasoning SuivantInférence et déploiement

Mis à jour il y a 2 mois

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