> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/tutorials/qwq-32b-how-to-run-effectively.md).

# QwQ-32B: Wie man 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 einer Leistung, die auf vielen [Benchmarks](https://qwenlm.github.io/blog/qwq-32b/). Allerdings haben 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 Bugfixes funktionieren großartig für Fine-Tuning, vLLM und Transformers. Wenn du llama.cpp und Engines verwendest, die llama.cpp als Backend nutzen, folge unseren [die Anweisungen hier](#tutorial-how-to-run-qwq-32b) um endlose Generierungen zu beheben.
{% endhint %}

**Unsloth QwQ-32B-Uploads mit unseren Bugfixes:**

| [GGUF](https://huggingface.co/unsloth/QwQ-32B-GGUF) | [Dynamisches 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: Offiziell 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 Standard von llama.cpp ist 0,1)
* Top\_P von 0.95
* Wiederholungsstrafe von 1.0. (1.0 bedeutet in llama.cpp und transformers deaktiviert)
* 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 ihn auf 0.0.
{% endhint %}

## :thumbsup: Empfohlene Einstellungen für llama.cpp

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

Das Abschalten `Wiederholungs-Penalty` funktioniert auch (also das Setzen auf 1.0), aber wir fanden, dass es nützlich ist, um endlose Generierungen zu bestrafen.

Um es zu verwenden, mussten wir außerdem die Reihenfolge der Sampler in llama.cpp so ändern, dass sie vor dem Anwenden von `Wiederholungs-Penalty`, andernfalls gibt es endlose Generierungen. Füge also 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 neu an und verschieben min\_p nach vorne. Das bedeutet, wir wenden die 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 du weiterhin Probleme hast, kannst du den`--repeat-penalty von 1.0 auf 1.2 oder 1.3 erhöhen.`

Mit freundlicher Genehmigung von [@krist486](https://x.com/krist486/status/1897885598196654180) für den Hinweis auf die Sampling-Richtungen von llama.cpp.

## :sunny: Dry-Wiederholungsstrafe

Wir haben 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 untersucht, aber wir fanden tatsächlich, dass dies **eher Syntaxprobleme verursacht, insbesondere beim Programmieren**. Wenn du weiterhin Probleme hast, 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: So führst du QwQ-32B in Ollama aus

1. Installieren `ollama` falls du das noch nicht getan hast!

```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 ausführen kannst, falls es fehlschlägt! Wir haben 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: So führst du QwQ-32B in llama.cpp aus

1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie 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 über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Sie können Q4\_K\_M oder andere quantisierte Versionen (wie BF16-Vollpräzision) wählen. 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, `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für GPU-Offloading auf wie viele Layer. Versuche, ihn anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne ihn auch, wenn du nur CPU-Inferenz hast.
5. Wir verwenden `--repeat-penalty 1.1` und `--dry-multiplier 0.5` das 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 sein und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.\n3. Mehrmaliges 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 in dunkelbraun oder gelb, zufällig gewählt.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeifliegst und sie nicht triffst.\n7. Erzeuge Rohre mit zufälligem Abstand und genügend Platz. 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 innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prü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,58-Bit-Blog lautet:

```
<|im_start|>user
Erstelle ein Flappy-Bird-Spiel in Python. Du musst die folgenden Dinge einbauen:
1. Du musst pygame verwenden.
2. Die Hintergrundfarbe sollte zufällig gewählt werden und hell sein. Beginne mit einer hellblauen Farbe.
3. Wenn du die LEERTASTE mehrfach drückst, beschleunigt sich der 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 am unteren Rand etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.
6. Zeige oben rechts einen Punktestand an. Erhöhe ihn, wenn du an Rohren vorbeikommst und sie nicht berührst.
7. Erzeuge 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 den Bestwert an. Der Text soll sich innerhalb des Bildschirms befinden. Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken der LEERTASTE.
Das endgültige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prü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 Denk-Teile:

```python
import pygame
import random
import sys

pygame.init()
### Wird fortgesetzt

class Bird:
    def __init__(self):
        ### Wird fortgesetzt

def main():
    best_score = 0
    current_score = 0
    game_over = False
    pipes = []
    first_time = True  # Erstes gespieltes Spiel verfolgen

    # Erste Einrichtung
    background_color = (173, 216, 230)  # Anfangs Hellblau
    land_color = random.choice(land_colors)
    bird = Bird()

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

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

        # Zeichnen
        ### Wird fortgesetzt
        pygame.display.flip()
        clock.tick(60)

if __name__ == "__main__":
    main()
```

<details>

<summary>Vollständige endgültige Python-Ausgabe (Denk-Teile 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-Klon")
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 gespieltes Spiel verfolgen

    # Erste Einrichtung
    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:
                        # 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)

            # Neues Rohr erzeugen, falls nötig
            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
            # Land und Oberkante 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 zeichnen
        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('Spiel beendet!', True, (255, 0, 0))
            best_text = font.render(f'Bestwert: {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 man es ausführt, erhält man ein lauffähiges Spiel!

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-1740ecd246c7f62c363bc0ba1e0f1099b2f9b2a4%2Fimage.png?alt=media" 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"` Dadurch wird die Ausgabe gespeichert 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 sein und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.\n3. Mehrmaliges 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 in dunkelbraun oder gelb, zufällig gewählt.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeifliegst und sie nicht triffst.\n7. Erzeuge Rohre mit zufälligem Abstand und genügend Platz. 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 innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prü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 etwas Schleifen bekommen, 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`, 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 und andere Anfangszustände setzen.

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

pygame.quit()
Der Code ist vereinfacht. Aufgrund von Zeitbeschränkungen erfordert die voll funktionsfähige Version weitere Implementierung.
```

9. Du fragst dich vielleicht: Vielleicht ist es Q4\_K\_M? B16, also volle Präzision, sollte doch funktionieren, oder? Falsch – die Ausgaben schlagen erneut fehl, wenn wir unseren Fix nicht verwenden -`-samplers "top_k;top_p;min_p;temperature;dry;typ_p;xtc"` wenn du eine Wiederholungsstrafe verwendest.

## :sunrise\_over\_mountains: Funktioniert immer noch nicht? Versuche Min\_p = 0.1, Temperature = 1.5

Laut dem Min\_p-Papier <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 sein und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.\n3. Mehrmaliges 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 in dunkelbraun oder gelb, zufällig gewählt.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeifliegst und sie nicht triffst.\n7. Erzeuge Rohre mit zufälligem Abstand und genügend Platz. 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 innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n<think>\n"
```

Ein weiterer Ansatz ist es, zu deaktivieren `min_p` direkt, 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 sein und ein heller Farbton sein. Beginne mit einem hellblauen Farbton.\n3. Mehrmaliges 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 in dunkelbraun oder gelb, zufällig gewählt.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeifliegst und sie nicht triffst.\n7. Erzeuge Rohre mit zufälligem Abstand und genügend Platz. 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 innerhalb des Bildschirms. Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken von SPACE.\nDas endgültige Spiel sollte in einem Markdown-Abschnitt in Python stehen. Prü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 wird 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 `<think>\n` während der Inferenz manuell hinzufügen, was nicht immer gelingen könnte. DeepSeek hat auch alle Modelle so bearbeitet, dass standardmäßig ein `<think>` Token hinzugefügt wird, um das Modell zu zwingen, in den Reasoning-Modus zu wechseln.

Ändere also `{%- 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, das YaRN-Handling von llama.cpp 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, dass das RMS-LayerNorm-Epsilon falsch war – nicht 1e-5, sondern vielleicht 1e-6. Zum Beispiel [dies](https://huggingface.co/Qwen/Qwen2.5-32B-Instruct/blob/main/config.json) hat `rms_norm_eps=1e-06`, während [dies](https://huggingface.co/Qwen/Qwen2.5-32B/blob/main/config.json) hat `rms_norm_eps=1e-05` . Wir haben es auch ü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 normalen Transformers übereinstimmen, dank [@kalomaze](https://x.com/kalomaze/status/1897875332230779138). Sie stimmten überein, also war das nicht der Übeltäter.

Wir stellen unsere experimentellen Ergebnisse unten vor:

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

{% file src="/files/e50374e58d68de343ea162e1cc23f805fbbb424b" %}
BF16-Vollprä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: Fehlerbehebungen beim Tokenizer

* Wir haben auch einige Probleme gefunden, die insbesondere das Fine-Tuning beeinträchtigen! Das EOS-Token ist korrekt, aber das PAD-Token sollte vermutlich eher `"<|vision_pad|>`" 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-Quantisierungen

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

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-16157f53eff143c179be571a43f8b55000d94290%2FQwQ%20quantization%20errors.png?alt=media" alt=""><figcaption></figcaption></figure>

Wir haben dynamische 4-Bit-Quantisierungen 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 nun das Laden von Unsloth-dynamischen 4-Bit-Quantisierungen!

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.