🌠QwQ-32B: Effektiv Ausführen

Wie man QwQ-32B effektiv mit unseren Bugfixes und ohne endlose Generierungen + GGUFs ausführt.

Qwen veröffentlichte QwQ-32B – ein Reasoning-Modell mit vergleichbarer Leistung wie DeepSeek-R1 bei vielen Benchmarks. Allerdings haben Nutzer erlebt unendliche Generierungen, viele Wiederholungen, <think>-Token-Probleme und Feinabstimmungsprobleme. Wir hoffen, dass dieser Leitfaden beim Debuggen und Beheben der meisten Probleme hilft!

Unsere Modell-Uploads mit unseren Fehlerbehebungen funktionieren hervorragend für Fine-Tuning, vLLM und Transformers. Wenn Sie llama.cpp und Engines verwenden, die llama.cpp als Backend nutzen, folgen Sie unseren Anweisungen hier um endlose Generierungen zu beheben.

Unsloth QwQ-32B-Uploads mit unseren Fehlerbehebungen:

GGUF	Dynamisches 4-Bit	BnB 4-Bit	16-Bit

⚙️ Offiziell empfohlene Einstellungen

Laut QwenDies sind die empfohlenen Einstellungen für die Inferenz:

• Temperatur von 0,6

• Top_K von 40 (oder 20 bis 40)

• Min_P von 0,00 (optional, aber 0,01 funktioniert gut, der Standard in llama.cpp ist 0,1)

• Top_P von 0.95

• Repetition Penalty von 1.0. (1.0 bedeutet deaktiviert in llama.cpp und transformers)

• Chat-Vorlage: <|im_start|>user\nErstelle ein Flappy-Bird-Spiel in Python.<|im_end|>\n<|im_start|>assistant\n<think>\n

llama.cpp verwendet min_p = 0.1standardmäßig, was Probleme verursachen kann. Setze es zwingend auf 0.0.

👍 Empfohlene Einstellungen für llama.cpp

Wir haben bemerkt, dass viele Leute einen Wiederholungs-Bestrafungswert größer als 1.0 verwenden. Zum Beispiel 1.1 bis 1.5. Das beeinträchtigt tatsächlich die Sampling-Mechanismen von llama.cpp. Ziel einer Wiederholungsbestrafung ist es, wiederholte Generierungen zu bestrafen, aber wir haben festgestellt, dass dies nicht wie erwartet funktioniert.

Ausschalten von Wiederholungs-Bestrafungswert funktioniert auch (d. h. auf 1.0 setzen), aber wir fanden es nützlich, es zu verwenden, um endlose Generierungen zu bestrafen.

Um es zu verwenden, haben wir festgestellt, dass Sie auch die Reihenfolge der Sampler in llama.cpp bearbeiten müssen, sodass sie vor dem Anwenden von Wiederholungs-Bestrafungswertstehen, andernfalls wird es endlose Generierungen geben. Fügen Sie also dies hinzu:

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

Standardmäßig verwendet llama.cpp diese Reihenfolge:

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

Wir vertauschen im Wesentlichen temperature und dry und rücken min_p nach vorne. Das bedeutet, wir wenden die Sampler in dieser Reihenfolge an:

top_k=40
top_p=0.95
min_p=0.0
temperature=0.6
dry
typ_p
xtc

Wenn Sie weiterhin auf Probleme stoßen, können Sie die--repeat-penalty 1.0 auf 1.2 oder 1.3 erhöhen.

Dank an @krist486 dafür, dass er mich auf die llama.cpp-Sampling-Richtungen aufmerksam gemacht hat.

☀️ Dry-Repetition-Penalty

Wir untersuchten die Verwendung von dry penalty wie in https://github.com/ggml-org/llama.cpp/blob/master/examples/main/README.md mit einem Wert von 0.8, aber wir stellten tatsächlich fest, dass dies eher Syntaxprobleme verursacht, besonders beim Programmieren. Wenn Sie weiterhin Probleme haben, können Sie diedry penalty auf 0.8 erhöhen.

Die Nutzung unserer getauschten Sampling-Reihenfolge kann ebenfalls helfen, wenn Sie sich entscheiden, dry penalty.

🦙 Tutorial: Wie man QwQ-32B in Ollama ausführt

1. Installieren Sie ollama falls du es noch nicht getan hast!

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

1. Starten Sie das Modell! Beachten Sie, dass Sie ollama servein einem anderen Terminal aufrufen können, wenn es fehlschlägt! Wir fügen alle unsere Fixes und empfohlenen Parameter (temperature, min_p usw.) in param in unserem Hugging Face-Upload hinzu!

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

📖 Tutorial: Wie man QwQ-32B in llama.cpp ausführt

1. Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch den unten stehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen.

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. Laden Sie das Modell herunter über (nach Installation von pip install huggingface_hub hf_transfer ). Du kannst Q4_K_M wählen oder andere quantisierte Versionen (wie BF16 in voller Präzision). Weitere Versionen unter: 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*"], # Für Q4_K_M
)

1. Führen Sie Unsloths Flappy-Bird-Test aus, der die Ausgabe speichert in Q4_K_M_yes_samplers.txt

2. Bearbeiten --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 99 für das GPU-Offloading für wie viele Schichten. Versuchen Sie, es anzupassen, wenn Ihre GPU nicht mehr genügend Speicher hat. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.

3. Wir verwenden --repeat-penalty 1.1 und --dry-multiplier 0.5 die Sie anpassen können.

./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\nErstelle ein Flappy-Bird-Spiel in Python. Du musst Folgendes einschließen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt und ein heller Farbton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, gefärbt als dunkelbraun oder gelb, zufällig ausgewählt.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohrabschnitte passiert und nicht getroffen hast.\n7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig als dunkles Grün, helles Braun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python stehen. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"  \
        2>&1 | tee Q4_K_M_yes_samplers.txt

Die vollständige Eingabe aus unserem https://unsloth.ai/blog/deepseekr1-dynamic 1.58bit Blog ist:

<|im_start|>user
Erstelle ein Flappy-Bird-Spiel in Python. Du musst Folgendes einschließen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und einen hellen Ton haben. Beginne mit einem hellen Blauton.
3. Das mehrfache Drücken von SPACE wird den Vogel beschleunigen.
4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als eine dunkle Farbe gewählt werden.
5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige eine Punktzahl oben rechts an. Erhöhe die Punktzahl, wenn du Rohre passiert und nicht getroffen wirst.
7. Erzeuge zufällig verteilte Rohre mit genügend Platz. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Das Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken von SPACE.
Das finale Spiel sollte in einem Markdown-Abschnitt in Python stehen. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<|im_end|>
<|im_start|>assistant
<think>

Der Anfang und das Ende der finalen Python-Ausgabe nach Entfernung der Denk-Teile:

import pygame
import random
import sys

pygame.init()
### Fortsetzung

Klasse Bird:
    def __init__(self):
        ### Fortsetzung

def main():
    best_score = 0
    current_score = 0
    game_over = False
    pipes = []
    first_time = True  # Verfolge das erste Spiel

    # Initiale Einstellungen
    background_color = (173, 216, 230)  # Anfangs hellblau
    land_color = random.choice(land_colors)
    bird = Bird()

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

        if not game_over:
            # Aktualisiere Vogel und Rohre
            bird.update()
            ### Fortsetzung

        # Zeichnen
        ### Fortsetzung
        pygame.display.flip()
        clock.tick(60)

if __name__ == "__main__":
    main()

Volle finale Python-Ausgabe (Denk-Teile entfernt):

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

# Farben
pipe_colors = [(0, 100, 0), (210, 180, 140), (50, 50, 50)]
land_colors = [(139, 69, 19), (255, 255, 0)]

# Spielkonstanten
GRAVITY = 0.5
PIPE_SPEED = 5
BIRD_SIZE = 30
LAND_HEIGHT = 50
PIPE_WIDTH = 50
PIPE_GAP = 150

Klasse 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  # Halte x zentriert
    
    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  # Verfolge das erste Spiel

    # Initiale Einstellungen
    background_color = (173, 216, 230)  # Anfangs hellblau
    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:
                        # Setze das Spiel zurück
                        bird = Bird()
                        pipes.clear()
                        current_score = 0
                        if first_time:
                            # Erster Neustart nach dem anfänglichen 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:
                        # Springe den Vogel
                        bird.velocity = -15  # Anfangsaufwärtsgeschwindigkeit

        if not game_over:
            # Aktualisiere Vogel und Rohre
            bird.update()

            # Bewege Rohre nach links
            remove_pipes = []
            for pipe in pipes:
                pipe['rect_top'].x -= PIPE_SPEED
                pipe['rect_bottom'].x -= PIPE_SPEED
                # Prüfe, ob der Vogel das Rohr passiert hat
                if not pipe['scored'] and bird.rect.x > pipe['rect_top'].right:
                    current_score += 1
                    pipe['scored'] = True
                # Prüfe, ob Rohr außerhalb des Bildschirms ist
                if pipe['rect_top'].right < 0:
                    remove_pipes.append(pipe)
            # Entferne Rohre außerhalb des Bildschirms
            for p in remove_pipes:
                pipes.remove(p)

            # Erzeuge neues Rohr falls nötig
            if not pipes or pipes[-1]['rect_top'].x < WIDTH - 200:
                pipes.append(spawn_pipe())

            # Prüfe Kollisionen
            land_rect = pygame.Rect(0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT)
            bird_rect = bird.rect
            # Prüfe Rohre
            for pipe in pipes:
                if bird_rect.colliderect(pipe['rect_top']) or bird_rect.colliderect(pipe['rect_bottom']):
                    game_over = True
                    break
            # Prüfe Land und obere Begrenzung
            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

        # Zeichnen
        screen.fill(background_color)
        # Zeichne Rohre
        for pipe in pipes:
            pygame.draw.rect(screen, pipe['color'], pipe['rect_top'])
            pygame.draw.rect(screen, pipe['color'], pipe['rect_bottom'])
        # Zeichne Land
        pygame.draw.rect(screen, land_color, (0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT))
        # Zeichne Vogel
        bird.draw()
        # Zeichne Punktestand
        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))
        # Game-Over-Bildschirm
        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. Beim Ausführen erhalten wir ein lauffähiges Spiel!

1. Versuchen Sie nun dasselbe ohne unsere Fixes! Entfernen Sie also --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" Das speichert die Ausgabe in 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\nErstelle ein Flappy-Bird-Spiel in Python. Du musst Folgendes einschließen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt und ein heller Farbton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, gefärbt als dunkelbraun oder gelb, zufällig ausgewählt.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohrabschnitte passiert und nicht getroffen hast.\n7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig als dunkles Grün, helles Braun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python stehen. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"  \
        2>&1 | tee Q4_K_M_no_samplers.txt

Sie werden etwas Schleifenbildung bekommen, aber problematisch falsche Python-Syntax und viele andere Probleme. Zum Beispiel sieht das Folgende korrekt aus, ist aber falsch! Z. B. Zeile 39 pipes.clear() ### <<< NameError: name 'pipes' ist nicht definiert. Haben Sie vergessen, 'pipes' zu importieren?

import pygame
import random

pygame.init()

# Konstanten
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)]
DUNKELBRAUN = (94, 72, 4)
GELB = (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

    # Vogel-Eigenschaften
    bird_x = WIDTH * 0.3
    bird_y = HEIGHT // 2
    bird_vel = -5  # Anfangsschub nach oben

    pipes.clear() ### <<< NameError: name 'pipes' ist nicht definiert. Haben Sie vergessen, 'pipes' zu importieren?

1. Wenn Sie --repeat-penalty 1.5, verwenden, wird es noch schlimmer und offensichtlicher, mit tatsächlich völlig falscher Syntax.

import pygame
from random import randint  # Zur zufälligen Erzeugung von Farben/Formen/Positionen 
pygame.init()

# Konstanten:
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
   # auf null setzen und andere Anfangszustände.

# Haupt-Spiel-Schleife:
while running :
     for event in pygame.event.get() : 
        if quit ... etc

pygame.quit()
print("Der Code ist vereinfacht. Aus Zeitgründen erfordert eine vollständige lauffähige Version weitere Implementierung.")

1. Vielleicht fragen Sie sich, ob es Q4_K_M ist? B16, also volle Genauigkeit, sollte doch funktionieren, oder? Falsch – die Ausgaben scheitern erneut, wenn wir nicht unseren Fix von --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" bei Verwendung einer Wiederholungsbestrafung.

🌄 Funktioniert es immer noch nicht? Versuchen Sie Min_p = 0.1, Temperature = 1.5

Laut dem Min_p-Paper https://arxiv.org/pdf/2407.01082, für kreativere und vielfältigere Ausgaben, und wenn Sie weiterhin Wiederholungen sehen, versuchen Sie, top_p und top_k zu deaktivieren!

./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\nErstelle ein Flappy-Bird-Spiel in Python. Du musst Folgendes einschließen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt und ein heller Farbton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, gefärbt als dunkelbraun oder gelb, zufällig ausgewählt.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohrabschnitte passiert und nicht getroffen hast.\n7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig als dunkles Grün, helles Braun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python stehen. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"

Ein anderer Ansatz ist, min_p direkt zu deaktivieren, da llama.cpp standardmäßig 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\nErstelle ein Flappy-Bird-Spiel in Python. Du musst Folgendes einschließen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt und ein heller Farbton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken der LEERTASTE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, gefärbt als dunkelbraun oder gelb, zufällig ausgewählt.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohrabschnitte passiert und nicht getroffen hast.\n7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig als dunkles Grün, helles Braun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python stehen. Überprüfe deinen Code auf Fehler und behebe sie vor dem finalen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"

🤔 <think>-Token nicht angezeigt?

Einige Leute berichten, dass, weil <think> standardmäßig in der Chat-Vorlage hinzugefügt wird, einige Systeme die Denktraces nicht korrekt ausgeben. Sie müssen die Jinja-Vorlage manuell von:

zu einer anderen ändern, indem Sie das <think>\n am Ende entfernen. Das Modell muss nun während der Inferenz manuell <think>\n hinzufügen, was nicht immer gelingt. DeepSeek hat ebenfalls alle Modelle bearbeitet, um standardmäßig ein <think> Token hinzuzufügen, um das Modell in den Reasoning-Modus zu zwingen.

Also ändere {%- if add_generation_prompt %} {{- '<|im_start|>assistant\n<think>\n' }} {%- endif %} zu {%- if add_generation_prompt %} {{- '<|im_start|>assistant\n' }} {%- endif %}

d. h. entferne <think>\n

Volle Jinja-Vorlage mit entferntem <think>\n-Teil

Zusätzliche Hinweise

Zuerst dachten wir vielleicht:

1. QwQs Kontextlänge wäre nicht nativ 128K, sondern eher 32K mit YaRN-Erweiterung. Zum Beispiel sehen wir in der Readme-Datei für https://huggingface.co/Qwen/QwQ-32B, folgendes:

{
  ...,
  "rope_scaling": {
    "factor": 4.0,
    "original_max_position_embeddings": 32768,
    "type": "yarn"
  }
}

Wir haben versucht, die YaRN-Handhabung von llama.cpp zu überschreiben, aber es änderte sich nichts.

--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. Wir dachten auch, dass das RMS-Layernorm-Epsilon falsch sein könnte – nicht 1e-5, sondern vielleicht 1e-6. Zum Beispiel dies hat rms_norm_eps=1e-06, während dies hat rms_norm_eps=1e-05 ist. Wir haben es ebenfalls überschrieben, aber es funktionierte nicht:

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

1. Wir haben auch getestet, ob die Tokenizer-IDs zwischen llama.cpp und normalen Transformers übereinstimmen dank @kalomaze. Sie stimmten überein, daher war dies nicht die Ursache.

Wir liefern unsere experimentellen Ergebnisse unten:

61KB

file_BF16_no_samplers.txt

Öffnen

BF16 Vollpräzision ohne Sampling-Fix

55KB

file_BF16_yes_samplers.txt

Öffnen

BF16 Vollpräzision mit Sampling-Fix

71KB

final_Q4_K_M_no_samplers.txt

Öffnen

Q4_K_M Präzision ohne Sampling-Fix

65KB

final_Q4_K_M_yes_samplers.txt

Öffnen

Q4_K_M Präzision mit Sampling-Fix

✏️ Tokenizer-Fehlerbehebungen

• Wir fanden einige Probleme, die speziell das Fine-Tuning beeinflussen! Das EOS-Token ist korrekt, aber das PAD-Token sollte wahrscheinlich eher "<|vision_pad|>" sein. Wir aktualisierten es in: https://huggingface.co/unsloth/QwQ-32B/blob/main/tokenizer_config.json

"eos_token": "<|im_end|>",
"pad_token": "<|endoftext|>",

🛠️ Dynamische 4-Bit-Quants

Wir haben außerdem dynamische 4-Bit-Quants hochgeladen, die die Genauigkeit gegenüber naiven 4-Bit-Quantisierungen erhöhen! Wir fügen die QwQ-Quantisierungsfehler-Plot-Analyse sowohl für Aktivierungs- als auch für Gewicht-Quantisierungsfehler bei:

Wir haben dynamische 4-Bit-Quants hochgeladen nach: https://huggingface.co/unsloth/QwQ-32B-unsloth-bnb-4bit

Seit vLLM 0.7.3 (20. Februar 2025) https://github.com/vllm-project/vllm/releases/tag/v0.7.3, unterstützt vLLM jetzt das Laden von Unsloth dynamischen 4-Bit-Quants!

Alle unsere GGUFs sind auf https://huggingface.co/unsloth/QwQ-32B-GGUF!