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

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

Qwen hat QwQ-32B veröffentlicht - ein Reasoning-Modell mit vergleichbarer Leistung wie DeepSeek-R1 bei vielen Benchmarks. Allerdings erleben die Leute endlose Generierungen, viele Wiederholungen, <think>-Token-Probleme und Fine-Tuning-Probleme. Wir hoffen, dass dieser Leitfaden hilft, die meisten Probleme zu debuggen und zu beheben!

Unsere Modell-Uploads mit unseren Fehlerbehebungen eignen sich hervorragend für Fine-Tuning, vLLM und Transformers. Wenn du llama.cpp und Engines verwendest, die llama.cpp als Backend nutzen, befolge unsere Anweisungen hier um endlose Generierungen zu beheben.

Unsloths QwQ-32B-Uploads mit unseren Fehlerbehebungen:

deutliche Leistungsverbesserungen: Es benötigt bis zu 75 % weniger Speicherplatz, reduziert den VRAM-Verbrauch um 50 %, beschleunigt das Zusammenführen um das 5-10-Fache und ermöglicht eine deutlich schnellere Konvertierung in das

Dynamisch 4-Bit

BnB 4-Bit

16-Bit

⚙️ Offizielle empfohlene Einstellungen

Laut Qwen, dies 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 Standardwert von llama.cpp ist 0,1)
Top_P von 0.95
Wiederholungsstrafe 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 könnte. Erzwinge es auf 0.0.

👍 Empfohlene Einstellungen für llama.cpp

Wir haben bemerkt, dass viele Leute einen Wiederholungsstrafe 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 Wiederholungsstrafe ist es, wiederholte Generierungen zu bestrafen, aber wir haben festgestellt, dass das nicht wie erwartet funktioniert.

Ausschalten von Wiederholungsstrafe funktioniert ebenfalls (also es auf 1.0 setzen), aber wir fanden es nützlich, damit endlose Generierungen zu bestrafen.

Um es zu verwenden, haben wir festgestellt, dass du auch die Reihenfolge der Sampler in llama.cpp vor dem Anwenden bearbeiten musst von Wiederholungsstrafe, andernfalls wird es endlose Generierungen geben. Also füge 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 ordnen im Wesentlichen temperature und dry um und verschieben min_p nach vorne. Das bedeutet, wir wenden Sampler in dieser Reihenfolge an:

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

Wenn weiterhin Probleme auftreten, kannst du die--repeat-penalty von 1.0 auf 1.2 oder 1.3 erhöhen.

Mit freundlicher Genehmigung von @krist486 dafür, dass er mich auf die Sampling-Richtlinien von llama.cpp aufmerksam gemacht hat.

☀️ Dry-Wiederholungsstrafe

Wir haben die Verwendung von dry penalty untersucht, wie in https://github.com/ggml-org/llama.cpp/blob/master/examples/main/README.md mit einem Wert von 0.8 vorgeschlagen, aber wir haben tatsächlich festgestellt, dass dies eher Syntaxprobleme verursacht, insbesondere beim Programmieren. Wenn weiterhin Probleme auftreten, kannst du diedry penalty auf 0.8 erhöhen.

Die Nutzung unserer vertauschten Sampling-Reihenfolge kann auch helfen, wenn du dich entscheidest, dry penalty.

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

Installieren Sie ollama falls Sie das noch nicht getan haben!

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

Führe das Modell aus! Beachte, dass du ollama servein einem anderen Terminal aufrufen kannst, falls es fehlschlägt! Wir enthalten alle unsere Fixes und vorgeschlagenen Parameter (temperature, min_p usw.) in param in unserem Hugging-Face-Upload!

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

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

Hole dir die neueste llama.cpp auf GitHub hier. Du kannst auch den untenstehenden Build-Anweisungen 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 und fahre 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

Lade das Modell herunter über (nach der Installation von pip install huggingface_hub hf_transfer ). Sie können Q4_K_M oder andere quantisierte Versionen wählen (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
)

Führe Unsloths Flappy-Bird-Test aus, der die Ausgabe speichert in Q4_K_M_yes_samplers.txt
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 GPU-Offloading, also für wie viele Layer. Versuchen Sie, dies anzupassen, wenn Ihrem GPU-Speicher der Platz ausgeht. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.
Wir verwenden --repeat-penalty 1.1 und --dry-multiplier 0.5 die du anpassen kannst.

./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 einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton 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 in dunkelbraun oder gelb gefärbt ist.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du an Rohren vorbeikommst und sie nicht berührst.\n7. Erzeuge Rohre mit zufälligem Abstand und genug Platz. Färbe sie zufällig als dunkles Grün oder hellbraun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl an. Platziere den Text innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Ein erneuter Start erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfe deinen Code auf Fehler und behebe sie vor dem endgültigen 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 lautet:

<|im_start|>user
Erstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einschließen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.
3. Mehrfaches 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 oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeikommst, ohne sie zu berühren.
7. Erstelle zufällig verteilte Rohre mit genügend Abstand. Färbe sie zufällig dunkelgrün, hellbraun oder in einem dunklen Grauton.
8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Mit q oder Esc beendest du das Spiel. Ein Neustart erfolgt durch erneutes Drücken der LEERTASTE.
Das endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<|im_end|>
<|im_start|>assistant
<think>

Der Anfang und das Ende der endgültigen Python-Ausgabe nach dem Entfernen der Denkabschnitte:

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  # Erstes Spielen verfolgen

    # Anfangseinrichtung
    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:
            # Vogel und Rohre aktualisieren
            bird.update()
            ### Fortsetzung

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

if __name__ == "__main__":
    main()

Vollständige endgültige Python-Ausgabe (Denkabschnitte 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  # x zentriert halten
    
    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  # Erstes Spielen verfolgen

    # Anfangseinrichtung
    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:
                        # Das Spiel zurücksetzen
                        bird = Bird()
                        pipes.clear()
                        current_score = 0
                        if first_time:
                            # Erster Neustart nach dem ersten 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:
                        # Vogel springen lassen
                        bird.velocity = -15  # Anfangs-Aufwärtsgeschwindigkeit

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

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

            # Bei Bedarf neues Rohr erzeugen
            if not pipes or pipes[-1]['rect_top'].x < WIDTH - 200:
                pipes.append(spawn_pipe())

            # Kollisionen prüfen
            land_rect = pygame.Rect(0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT)
            bird_rect = bird.rect
            # Rohre prüfen
            for pipe in pipes:
                if bird_rect.colliderect(pipe['rect_top']) or bird_rect.colliderect(pipe['rect_bottom']):
                    game_over = True
                    break
            # Boden und Oberseite prüfen
            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)
        # Rohre zeichnen
        for pipe in pipes:
            pygame.draw.rect(screen, pipe['color'], pipe['rect_top'])
            pygame.draw.rect(screen, pipe['color'], pipe['rect_bottom'])
        # Land zeichnen
        pygame.draw.rect(screen, land_color, (0, HEIGHT - LAND_HEIGHT, WIDTH, LAND_HEIGHT))
        # Vogel zeichnen
        bird.draw()
        # Punktzahl anzeigen
        font = pygame.font.SysFont(None, 36)
        score_text = font.render(f'Punktzahl: {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()

Wenn es ausgeführt wird, erhalten wir ein lauffähiges Spiel!

Versuche jetzt dasselbe ohne unsere Fixes! Entferne also --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" Dies 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 diese Dinge einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton 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 in dunkelbraun oder gelb gefärbt ist.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du an Rohren vorbeikommst und sie nicht berührst.\n7. Erzeuge Rohre mit zufälligem Abstand und genug Platz. Färbe sie zufällig als dunkles Grün oder hellbraun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl an. Platziere den Text innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Ein erneuter Start erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"  \\
        2>&1 | tee Q4_K_M_no_samplers.txt

Du wirst einiges an Schleifen erhalten, aber problematisch falsche Python-Syntax und viele andere Probleme. Zum Beispiel sieht das Folgende korrekt aus, ist aber falsch! Also Zeile 39 pipes.clear() ### <<< NameError: name 'pipes' is not defined. Hast du 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

    # Vogeleigenschaften
    bird_x = WIDTH * 0.3
    bird_y = HEIGHT // 2
    bird_vel = -5  # Anfangs-Aufwärtsschub

    pipes.clear() ### <<< NameError: name 'pipes' is not defined. Hast du vergessen, 'pipes' zu importieren?

Wenn du --repeat-penalty 1.5verwendest, 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.

# Hauptspielschleife:
while running :
     for event in pygame.event.get() : 
        if quit ... etc

pygame.quit()
print("Code ist vereinfacht. Aufgrund von Zeitbeschränkungen erfordert die vollständige funktionsfähige Version weitere Implementierung.")

Du fragst dich vielleicht, ob es an Q4_K_M liegt? B16 also volle Präzision sollte doch gut funktionieren, oder? Falsch - die Ausgaben scheitern erneut, wenn wir unseren Fix nicht verwenden --samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc" wenn eine Wiederholungsstrafe verwendet wird.

🌄 Funktioniert immer noch nicht? Probiere 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 du immer noch Wiederholungen siehst, versuche 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 einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton 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 in dunkelbraun oder gelb gefärbt ist.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du an Rohren vorbeikommst und sie nicht berührst.\n7. Erzeuge Rohre mit zufälligem Abstand und genug Platz. Färbe sie zufällig als dunkles Grün oder hellbraun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl an. Platziere den Text innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Ein erneuter Start erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfe deinen Code auf Fehler und behebe sie vor dem endgültigen 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 einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton 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 in dunkelbraun oder gelb gefärbt ist.\n6. Zeige eine Punktzahl oben rechts an. Erhöhe sie, wenn du an Rohren vorbeikommst und sie nicht berührst.\n7. Erzeuge Rohre mit zufälligem Abstand und genug Platz. Färbe sie zufällig als dunkles Grün oder hellbraun oder einen dunklen Grauton.\n8. Wenn du verlierst, zeige die beste Punktzahl an. Platziere den Text innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Ein erneuter Start erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfe deinen Code auf Fehler und behebe sie vor dem endgültigen 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. Du musst die Jinja-Vorlage manuell ändern von:

zu einer anderen, indem du das <think>\n am Ende entfernst. Das Modell muss nun während der Inferenz manuell <think>\n hinzufügen, was möglicherweise nicht immer gelingt. DeepSeek hat außerdem alle Modelle so bearbeitet, dass standardmäßig ein <think> Token hinzugefügt wird, 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 %}

also entferne <think>\n

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

Zusätzliche Hinweise

Wir dachten zuerst vielleicht:

QwQs Kontextlänge war 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 haben versucht, llama.cpps YaRN-Behandlung 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 \

Wir dachten auch, vielleicht sei das RMS-Layernorm-Epsilon falsch - nicht 1e-5, sondern vielleicht 1e-6. Zum Beispiel dieses hat rms_norm_eps=1e-06, während dieses hat rms_norm_eps=1e-05 . Wir haben es ebenfalls überschrieben, aber es hat nicht funktioniert:

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

Wir haben auch getestet, ob die Tokenizer-IDs zwischen llama.cpp und normalem Transformers übereinstimmen, mit freundlicher Genehmigung von @kalomaze. Sie stimmten überein, also war das nicht der Verursacher.

Wir präsentieren unten unsere experimentellen Ergebnisse:

✏️ Tokenizer-Fehlerbehebungen

Wir haben auch einige Probleme gefunden, die insbesondere das Fine-Tuning beeinträchtigen! Das EOS-Token ist korrekt, aber das PAD-Token sollte wahrscheinlich eher "<|vision_pad|>" sein. Wir haben es aktualisiert 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 im Vergleich zu naiven 4-Bit-Quantisierungen erhöhen! Wir fügen die Analyse des QwQ-Quantisierungsfehlerdiagramms sowohl für Aktivierungs- als auch für Gewichtsquantisierungsfehler bei:

Wir haben dynamische 4-Bit-Quants hochgeladen auf: 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 Unsloths dynamischen 4-Bit-Quants!

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

Zuletzt aktualisiert vor 2 Monaten

War das hilfreich?