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

Qwen hat QwQ-32B veröffentlicht - ein Reasoning-Modell mit vergleichbarer Leistung wie DeepSeek-R1 bei vielen [Benchmarks](https://qwenlm.github.io/blog/qwq-32b/). 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!

{% hint style="info" %}
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](#tutorial-how-to-run-qwq-32b) um endlose Generierungen zu beheben.
{% endhint %}

**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](https://huggingface.co/unsloth/QwQ-32B-GGUF) | [Dynamisch 4-Bit](https://huggingface.co/unsloth/QwQ-32B-unsloth-bnb-4bit) | [BnB 4-Bit](https://huggingface.co/unsloth/QwQ-32B-bnb-4bit) | [16-Bit](https://huggingface.co/unsloth/QwQ-32B) |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------ |

## :gear: Offizielle empfohlene Einstellungen

Laut [Qwen](https://huggingface.co/Qwen/QwQ-32B), 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`

{% hint style="warning" %}
`llama.cpp` verwendet `min_p = 0.1`standardmäßig, was Probleme verursachen könnte. Erzwinge es auf 0.0.
{% endhint %}

## :thumbsup: 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:

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

Standardmäßig verwendet llama.cpp diese Reihenfolge:

```bash
--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:

```bash
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](https://x.com/krist486/status/1897885598196654180) dafür, dass er mich auf die Sampling-Richtlinien von llama.cpp aufmerksam gemacht hat.

## :sunny: 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 die`dry penalty auf 0.8 erhöhen.`

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

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

1. Installieren Sie `ollama` falls Sie das noch nicht getan haben!

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

2. Führe das Modell aus! Beachte, dass du `ollama serve`in 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!

```bash
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](https://github.com/ggml-org/llama.cpp). 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.

```bash
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
```

2. 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>

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

3. Führe Unsloths Flappy-Bird-Test aus, der die Ausgabe speichert in `Q4_K_M_yes_samplers.txt`
4. 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.
5. Wir verwenden `--repeat-penalty 1.1` und `--dry-multiplier 0.5` die du anpassen kannst.

```bash
./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:

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

<details>

<summary>Vollständige endgültige Python-Ausgabe (Denkabschnitte entfernt):</summary>

{% code fullWidth="false" %}

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

{% endcode %}

</details>

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

<figure><img src="/files/4fe5950f205987a4a3360be3cc160b363b3f6b8e" alt=""><figcaption></figcaption></figure>

7. 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`

```bash
./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?`

{% code overflow="wrap" lineNumbers="true" %}

```python
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?
```

{% endcode %}

8. Wenn du `--repeat-penalty 1.5`verwendest, wird es noch schlimmer und offensichtlicher, mit tatsächlich völlig falscher Syntax.

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

9. 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.

## :sunrise\_over\_mountains: 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!

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

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

## :thinking: \<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:

{% code overflow="wrap" %}

```
```

{% endcode %}

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`

<details>

<summary>Vollständige Jinja-Vorlage mit entferntem &#x3C;think>\n-Teil</summary>

{% code overflow="wrap" %}

```
```

{% endcode %}

</details>

## Zusätzliche Hinweise

Wir dachten zuerst vielleicht:

1. 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:

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

{% code overflow="wrap" %}

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

{% endcode %}

2. Wir dachten auch, vielleicht sei das RMS-Layernorm-Epsilon falsch - nicht 1e-5, sondern vielleicht 1e-6. Zum Beispiel [dieses](https://huggingface.co/Qwen/Qwen2.5-32B-Instruct/blob/main/config.json) hat `rms_norm_eps=1e-06`, während [dieses](https://huggingface.co/Qwen/Qwen2.5-32B/blob/main/config.json) hat `rms_norm_eps=1e-05` . Wir haben es ebenfalls überschrieben, aber es hat nicht funktioniert:

{% code overflow="wrap" %}

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

{% endcode %}

3. Wir haben auch getestet, ob die Tokenizer-IDs zwischen llama.cpp und normalem Transformers übereinstimmen, mit freundlicher Genehmigung von [@kalomaze](https://x.com/kalomaze/status/1897875332230779138). Sie stimmten überein, also war das nicht der Verursacher.

Wir präsentieren unten unsere experimentellen Ergebnisse:

{% file src="/files/60ed1634c7ea092f988dc0d8e799eb83fc0411a9" %}
BF16 volle Präzision ohne Sampling-Fix
{% endfile %}

{% file src="/files/e50374e58d68de343ea162e1cc23f805fbbb424b" %}
BF16 volle Präzision mit Sampling-Fix
{% endfile %}

{% file src="/files/6827d7cb8f05ab50567adb49454f5a88bb957883" %}
Q4\_K\_M-Präzision ohne Sampling-Fix
{% endfile %}

{% file src="/files/705bfc934ecc261cfea93b0c10eedbb798dd6b89" %}
Q4\_K\_M-Präzision mit Sampling-Fix
{% endfile %}

## :pencil2: 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|>",
```

## :tools: 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:

<figure><img src="/files/1176657f3d9f4d14dca17ad0a7084ab9f2575a10" alt=""><figcaption></figcaption></figure>

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/de/modelle/tutorials/qwq-32b-how-to-run-effectively.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.