🌠QwQ-32B: Wie man effektiv ausführt

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

Qwen hat QwQ-32B veröffentlicht - ein Reasoning-Modell mit einer auf vielen Benchmarks. Allerdings erleben Leute 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 Bugfixes funktionieren großartig 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 Bugfixes:

GGUF	Dynamisch 4-Bit	BnB 4-Bit	16-Bit

⚙️ Offizielle empfohlene Einstellungen

Laut Qwen, dies sind die empfohlenen Einstellungen für das Inferenzieren:

• Temperatur von 0,6

• Top_K von 40 (oder 20 bis 40)

• Min_P von 0,00 (optional, aber 0,01 funktioniert gut, der llama.cpp-Standard 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. Erzwinge 0.0.

👍 Empfohlene Einstellungen für llama.cpp

Wir bemerkten, dass viele Leute einen Repetition Penalty größer als 1.0 verwenden. Zum Beispiel 1.1 bis 1.5. Das stört tatsächlich die Sampling-Mechanismen von llama.cpp. Das Ziel einer Repetition Penalty ist es, wiederholte Generierungen zu bestrafen, aber wir haben festgestellt, dass das nicht wie erwartet funktioniert.

Das Deaktivieren von Repetition Penalty funktioniert auch (z. B. Einstellung auf 1.0), aber wir fanden es nützlich, es zu verwenden, um endlose Generierungen zu bestrafen.

Um es zu verwenden, stellten wir fest, dass Sie außerdem die Reihenfolge der Sampler in llama.cpp bearbeiten müssen, sodass sie vor der Anwendung von Repetition Penaltysteht, andernfalls wird es endlose Generierungen geben. Also fügen Sie 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 verschieben 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 immer noch auf Probleme stoßen, können Sie die--repeat-penalty 1.0 auf 1.2 oder 1.3 erhöhen.

Dank an @krist486 für den Hinweis auf die llama.cpp-Sampling-Richtungen.

☀️ 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 unter Verwendung eines Wertes von 0.8, aber wir fanden heraus, dass dies eher Syntaxprobleme verursacht, insbesondere beim Codieren. Wenn Sie weiterhin Probleme haben, können Sie diedry penalty auf 0.8 erhöhen.

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

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

1. In Ollama ausführen Installieren Sie falls Sie es noch nicht getan haben!

apt-get update
siehe hier
apt-get install pciutils -y

1. Führen Sie das Modell aus! Beachten Sie, dass Sie Führen Sie das Modell aus! Beachten Sie, dass Siein einem anderen Terminal aufrufen können, wenn es fehlschlägt! Wir fügen alle unsere Fixes und vorgeschlagenen Parameter (temperature, min_p etc.) in param params

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

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

1. Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den Build-Anweisungen unten folgen. Ändere -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn du keine GPU hast oder nur CPU-Inferenz möchtest. Für Apple Mac / Metal-Geräte, setze -DGGML_CUDA=OFF dann wie gewohnt fort - Metal-Unterstützung ist standardmäßig aktiviert.

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. Laden Sie das Modell herunter (nach der Installation pip install huggingface_hub hf_transfer ). Sie können Q4_K_M wählen oder andere quantisierte Versionen (wie BF16 Vollprä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 Sie können --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 --n-gpu-layers 99 --n-gpu-layers 2

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 diese Dinge enthalten:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Ton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken von SPACE 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, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Mache eine Punktzahl, die oben rechts angezeigt wird. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.\n7. Mache zufällig platzierte Rohre mit genug Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Durch Drücken von q oder Esc wird das Spiel beendet. Neustarten durch erneutes Drücken von SPACE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python sein. Prü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 einbeziehen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt sein und einen hellen Ton haben. Beginne mit einer hellblauen Farbe.
3. Mehrmaliges Drücken der LEERTASTE beschleunigt den Vogel.
4. 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.
5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.
7. Erzeuge zufällig platzierte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl. Mache den Text innerhalb des Bildschirms. Das Drücken von q oder Esc beendet das Spiel. Neustarten erfolgt durch erneutes Drücken der LEERTASTE.
Das finale Spiel sollte in einem Markdown-Abschnitt in Python sein. Prü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 Entfernen der Denk-Teile:

import pygame
import random
import sys

pygame.init()
### Fortsetzung

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

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

    # Anfangskonfiguration
    background_color = (173, 216, 230)  # Zunächst 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()

Vollständige 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

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  # 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 erstes Spiel

    # Anfangskonfiguration
    background_color = (173, 216, 230)  # Zunächst 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:
                        # Lasse den Vogel springen
                        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 das Rohr aus dem Bildschirm ist
                if pipe['rect_top'].right < 0:
                    remove_pipes.append(pipe)
            # Entferne Rohre, die aus dem Bildschirm sind
            for p in remove_pipes:
                pipes.remove(p)

            # Erzeuge ein 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 oben
            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('Drücke SPACE zum Neustart', 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 ausführbares Spiel!

1. Versuchen Sie nun dasselbe ohne unsere Fixes! Entfernen Sie also --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" Dies wird die Ausgabe speichern 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 diese Dinge enthalten:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Ton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken von SPACE 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, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Mache eine Punktzahl, die oben rechts angezeigt wird. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.\n7. Mache zufällig platzierte Rohre mit genug Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Durch Drücken von q oder Esc wird das Spiel beendet. Neustarten durch erneutes Drücken von SPACE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python sein. Prü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 einige Schleifen erhalten, 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)]
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

    # Eigenschaften des Vogels
    bird_x = WIDTH * 0.3
    bird_y = HEIGHT // 2
    bird_vel = -5  # Anfangsauftrieb

    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  # Zum zufälligen Erzeugen 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.

# Hauptspiel-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ändig funktionierende Version weitere Implementierung.")

1. Sie fragen sich vielleicht, ist es vielleicht Q4_K_M? B16 also Vollpräzision sollte doch funktionieren, oder? Falsch - die Ausgaben scheitern erneut, wenn wir unseren Fix von --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" bei Verwendung einer Repetition Penalty.

🌄 Funktioniert 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 falls 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 diese Dinge enthalten:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Ton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken von SPACE 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, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Mache eine Punktzahl, die oben rechts angezeigt wird. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.\n7. Mache zufällig platzierte Rohre mit genug Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Durch Drücken von q oder Esc wird das Spiel beendet. Neustarten durch erneutes Drücken von SPACE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python sein. Prü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 diese Dinge enthalten:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Ton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken von SPACE 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, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Mache eine Punktzahl, die oben rechts angezeigt wird. Erhöhe sie, wenn du Rohre passiert und nicht getroffen hast.\n7. Mache zufällig platzierte Rohre mit genug Abstand. Färbe sie zufällig dunkelgrün oder hellbraun oder in einem dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl. Platziere den Text im Bildschirm. Durch Drücken von q oder Esc wird das Spiel beendet. Neustarten durch erneutes Drücken von SPACE.\nDas finale Spiel sollte in einem Markdown-Abschnitt in Python sein. Prü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 Denkspuren nicht korrekt ausgeben. Sie müssen die Jinja-Vorlage manuell bearbeiten von:

zu einer anderen, 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 so bearbeitet, dass standardmäßig ein <think> Token hinzugefügt wird, um das Modell in den Reasoning-Modus zu zwingen.

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

d. h. entfernen Sie <think>\n

Vollständige Jinja-Vorlage mit entfernter <think>\n-Teil

Zusätzliche Hinweise

Wir dachten zunächst vielleicht:

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

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

Wir versuchten, llama.cpps YaRN-Handhabung zu überschreiben, aber nichts änderte sich.

--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 steht. 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 Tokenizer-IDs zwischen llama.cpp und normalen Transformers übereinstimmen, dank @kalomaze. Sie stimmten überein, also war das nicht die Ursache.

Wir stellen unsere experimentellen Ergebnisse unten zur Verfügung:

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

• Wir fanden einige Probleme, die speziell das Fine-Tuning betreffen! 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 auch dynamische 4-Bit-Quants hochgeladen, die die Genauigkeit gegenüber naiven 4-Bit-Quantisierungen erhöhen! Wir fügen die QwQ-Quantisierungsfehler-Analyseplots sowohl für Aktivierungs- als auch für Gewichtsquantisierungsfehler 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 bei https://huggingface.co/unsloth/QwQ-32B-GGUF!