🌠QwQ-32B : Comment exécuter efficacement

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

Qwen a publié QwQ-32B - un modèle de raisonnement dont les performances sont comparables à DeepSeek-R1 sur de nombreux benchmarks. Cependant, des utilisateurs ont rencontré générations infinies, de nombreuses répétitions, des problèmes avec le 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 modèles téléversés avec nos corrections de bogues 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 sans fin.

Les uploads Unsloth QwQ-32B avec nos correctifs :

GGUF	4 bits dynamique	BnB 4 bits	16 bits

⚙️ Paramètres recommandés officiels

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\nCreate a Flappy Bird game in Python.<|im_end|>\n<|im_start|>assistant\n<think>\n

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

👍 Paramètres recommandés pour llama.cpp

Nous avons remarqué que beaucoup de gens 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. 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 aussi (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 constaté que vous devez 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. 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
temperature=0.6
min_p=0.0
par défaut ceci est désactivé, mais pour réduire les répétitions, vous pouvez l'utiliser ; toutefois, utiliser une valeur plus élevée peut entraîner une légère diminution des performances
dry
typ_p
xtc

Si vous rencontrez encore 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.

☀️ Pénalité de répétition Dry

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 encore des problèmes, vous pouvez augmenter ladry penalty à 0.8.

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

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

1. Installez 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. Exécutez 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 téléversement Hugging Face !

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

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

1. Obtenez le dernier llama.cpp sur GitHub ici. Vous pouvez suivre les instructions de compilation ci-dessous également. Changez -DGGML_CUDA=ON en -DGGML_CUDA=OFF si vous n'avez pas de GPU ou si vous voulez simplement une inférence CPU.

apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggerganov/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 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. éditer --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 sur le nombre de couches. Essayez de l'ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n'avez qu'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\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<|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 aléatoirement et être une teinte claire. Commencez par 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 un carré, un cercle ou un triangle. La couleur doit être choisie aléatoirement parmi des couleurs foncées.
5. Placez en bas un terrain coloré aléatoirement en marron foncé ou jaune.
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 en 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 des 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

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

classe 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:
                            # Première relance après le game over initial
                            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()

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

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

1. Maintenant essayez la même chose sans nos correctifs ! Donc retirez --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\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<|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 incorrecte problématique 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. Avez-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: name 'pipes' is not defined. Avez-vous oublié d'importer 'pipes' ?

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

import pygame
from random import randint  # Pour générer 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
   # mettre à 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 de contraintes de temps, une version complète et fonctionnelle nécessite une mise en œuvre 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 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\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<|im_end|>\n<|im_start|>assistant\n<think>\n"

Une autre approche consiste à désactiver min_p directement, puisque llama.cpp par défaut utilise 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\nCreate a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<|im_end|>\n<|im_start|>assistant\n<think>\n"

🤔 Le token <think> n'est pas affiché ?

Certaines personnes rapportent 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 éditer manuellement le template Jinja de :

à un autre en retirant 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 aussi édité tous les modèles pour ajouter par défaut un <think> token pour forcer le modèle à passer en modèle de 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. retirez <think>\n

Template jinja complet avec la partie <think> retiré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 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 \

1. Nous avons aussi pensé que l'epsilon du RMS Layernorm était incorrect - 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 \

1. Nous avons aussi testé si les IDs du tokenizer correspondaient entre llama.cpp et les Transformers normaux 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 bogues 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|>",

🛠️ Quantifications dynamiques 4 bits

Nous avons aussi téléversé des quantifications 4 bits dynamiques qui augmentent 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 d'activation et de poids :

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

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