🐳DeepSeek-V3-0324: Anleitung zum lokalen Betrieb

Wie man DeepSeek-V3-0324 lokal mit unseren Dynamic-Quants ausführt, die die Genauigkeit wiederherstellen

Siehe bitte https://docs.unsloth.ai/basics/deepseek-r1-0528-how-to-run-locally (Update vom 28. Mai 2025) um zu erfahren, wie man DeepSeek schneller und effizienter ausführt!

DeepSeek ist wieder aktiv! Nachdem V3, R1 Zero und R1 im Dezember 2024 bzw. Januar 2025 veröffentlicht wurden, hat DeepSeek ihre Checkpoints/Modelle für V3 aktualisiert und ein März-Update veröffentlicht!

Laut DeepSeek sprang MMLU-Pro um +5,3% auf 81,2%. GPQA +9,3 Prozentpunkte. AIME +19,8% und LiveCodeBench +10,0%! Sie stellten eine Grafik bereit, die zeigt, wie sie im Vergleich zum vorherigen V3-Checkpoint und anderen Modellen wie GPT 4.5 und Claude Sonnet 3.7 abschneiden. Aber wie führen wir ein Modell mit 671 Milliarden Parametern lokal aus?

MoE Bits	Typ	Platzbedarf auf Datenträger	Genauigkeit	Link	Details
1,78bit	IQ1_S	173GB	Ok	Link	2,06/1,56bit
1,93bit	IQ1_M	183GB	Fair	Link	2.5/2.06/1.56
2,42bit	IQ2_XXS	203GB	Vorgeschlagen	Link	2,5/2,06bit
2,71bit	Q2_K_XL	231GB	Vorgeschlagen	Link	3,5/2,5bit
3,5bit	Q3_K_XL	320GB	Großartig	Link	4,5/3,5bit
4,5bit	Q4_K_XL	406GB	Am besten	Link	5,5/4,5bit

Der ursprüngliche Upload von DeepSeek V3 liegt in float8 vor und benötigt 715GB. Mit Q4_K_M halbiert sich die Dateigröße auf etwa 404GB, und unsere dynamische 1,78-Bit-Quantisierung passt in etwa in 151GB. Wir empfehlen die Verwendung unserer 2,7-Bit-Quantisierung, um Größe und Genauigkeit auszubalancieren! Die 2,4-Bit-Variante funktioniert ebenfalls gut!

⚙️ Offizielle empfohlene Einstellungen

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

• Temperatur von 0,3 (Vielleicht 0,0 für Programmierung wie hier zu sehen)

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

• Chat-Vorlage: <｜User｜>Erstelle ein einfaches spielbares Flappy Bird Spiel in Python. Platziere das fertige Spiel innerhalb eines Markdown-Abschnitts.<｜Assistant｜>

• Ein BOS-Token von <｜begin▁of▁sentence｜> wird während der Tokenisierung automatisch hinzugefügt (nicht manuell hinzufügen!)

• DeepSeek erwähnte die Verwendung eines Systemprompts ebenfalls (optional) - es ist auf Chinesisch: 该助手为DeepSeek Chat，由深度求索公司创造。\n今天是3月24日，星期一。 was übersetzt heißt: Der Assistent ist DeepSeek Chat, erstellt von DeepSeek.\nHeute ist Montag, der 24. März.

• Für die Quantisierung des KV-Cache verwenden Sie 8bit, NICHT 4bit - wir stellten fest, dass 4bit deutlich schlechter abschneidet.

📖 Tutorial: Wie man DeepSeek-V3 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.

HINWEIS Verwendung von -DGGML_CUDA=ON für GPUs kann 5 Minuten zum Kompilieren dauern. Nur CPU dauert 1 Minute zum Kompilieren. Möglicherweise interessieren Sie sich für die vorkompilierten Binärdateien von llama.cpp.

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=OFF -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 wählen UD-IQ1_S(dynamischer 1,78bit-Quant) oder andere quantisierte Versionen wie Q4_K_M . Ich empfehle die Verwendung unserer dynamischen 2,7-Bit-Quantisierung empfehlen die Verwendung unseres 2,7-Bit Dynamic Quant UD-Q2_K_XL. Mehr Versionen unter: https://huggingface.co/unsloth/DeepSeek-V3-0324-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/DeepSeek-V3-0324-GGUF-UD",
    local_dir = "unsloth/DeepSeek-V3-0324-GGUF-UD",
    allow_patterns = ["*UD-Q2_K_XL*"], # Dynamisch 2,7-Bit (230GB) Verwenden Sie "*UD-IQ_S*" für Dynamisch 1,78-Bit (151GB)
)

1. Führen Sie Unsloths Flappy-Bird-Test wie in unserer Anleitung zur dynamischen 1,58-Bit-Quantisierung für DeepSeek R1 beschrieben aus.

2. Bearbeiten Sie können --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für Kontextlänge, --n-gpu-layers 2

./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-V3-0324-GGUF-UD/blob/main/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \
    --cache-type-k q8_0 \
    --threads 20 \
    für Kontextlänge, \
    -no-cnv \
    --prio 3 \
    --temp 0.3 \
    --min-p 0.01 \
    --ctx-size 4096 \
    --seed 3407 \
    --prompt "<｜User｜>Create a Flappy Bird game in Python. You must include these things:\n1. You must use pygame.\n2. The background color should be randomly chosen and is a light shade. Start with a light blue color.\n3. Pressing SPACE multiple times will accelerate the bird.\n4. The bird's shape should be randomly chosen as a square, circle or triangle. The color should be randomly chosen as a dark color.\n5. Place on the bottom some land colored as dark brown or yellow chosen randomly.\n6. Make a score shown on the top right side. Increment if you pass pipes and don't hit them.\n7. Make randomly spaced pipes with enough space. Color them randomly as dark green or light brown or a dark gray shade.\n8. When you lose, show the best score. Make the text inside the screen. Pressing q or Esc will quit the game. Restarting is pressing SPACE again.\nThe final game should be inside a markdown section in Python. Check your code for errors and fix them before the final markdown section.<｜Assistant｜>"

Wenn wir das Obige ausführen, erhalten wir zwei sehr unterschiedliche Ergebnisse. Standardmäßige 2-Bit-Version: Klicken, um Ergebnis anzuzeigen (Warnung vor Anfällen!) Dynamische 2-Bit-Version: Siehe das Ergebnis unten:

Standard 2-Bit. Scheitert bei Hintergrund, scheitert bei Kollision

Dynamisch 2-Bit. Schafft es, ein spielbares Spiel zu erstellen.

1. Wie DeepSeek-R1 hat V3 61 Schichten. Zum Beispiel können Sie bei einer 24GB-GPU oder 80GB-GPU damit rechnen, nach dem Abrunden auszulagern (um 1 reduzieren, wenn es zu Out-of-Memory kommt):

Quant	Dateigröße	24GB GPU	80GB GPU	2x80GB GPU
1.73bit	173GB	5	25	56
2.22bit	183GB	4	22	49
2.51bit	212GB	2	19	32

Ausführung auf Mac / Apple-Geräten

Für Apple Metal-Geräte seien Sie vorsichtig mit --n-gpu-layers. Wenn Sie feststellen, dass die Maschine den Speicher überschreitet, reduzieren Sie diesen Wert. Bei einer Maschine mit 128GB Unified Memory sollten Sie in der Lage sein, etwa 59 Schichten auszulagern.

./llama.cpp/llama-cli \
    --model DeepSeek-R1-GGUF/DeepSeek-V3-0324-UD-IQ1_S/DeepSeek-V3-0324-UD-IQ1_S-00001-of-00003.gguf \
    --cache-type-k q4_0 \
    --threads 16 \
    --prio 2 \
    --temp 0.6 \
    --ctx-size 8192 \
    --seed 3407 \
    --n-gpu-layers 59 \
    -no-cnv \
    --prompt "<｜User｜>Create a Flappy Bird game in Python.<｜Assistant｜>"

🎱 Heptagon-Test

Wir testen unsere dynamischen Quantisierungen auch über r/Localllama welches das Modell testet, indem es eine einfache Physik-Engine erstellt, um Kugeln in einem sich drehenden, eingeschlossenen Heptagon rotieren zu lassen.

Das Ziel ist, das Heptagon drehen zu lassen, und die Kugeln im Heptagon sollten sich bewegen.

./llama.cpp/llama-cli \
    --model unsloth/DeepSeek-V3-0324-GGUF-UD/blob/main/UD-Q2_K_XL/DeepSeek-V3-0324-UD-Q2_K_XL-00001-of-00006.gguf \
    --cache-type-k q8_0 \
    --threads 20 \
    --n-gpu-layers 2 \
    -no-cnv \
    --prio 3 \
    --temp 0.3 \
    --min_p 0.01 \
    --ctx-size 4096 \
    --seed 3407 \
    --prompt "<｜User｜>Schreibe ein Python-Programm, das 20 Kugeln zeigt, die in einem rotierenden Heptagon aufspringen:\n- Alle Kugeln haben denselben Radius.\n- Alle Kugeln haben eine Nummer von 1 bis 20.\n- Alle Kugeln fallen beim Start vom Zentrum des Heptagons.\n- Farben sind: #f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- Die Kugeln sollten von Schwerkraft und Reibung beeinflusst werden und realistisch von den rotierenden Wänden abprallen. Es sollte auch Kollisionen zwischen Kugeln geben.\n- Das Material aller Kugeln bestimmt, dass die Rückprallhöhe beim Aufprall nicht den Radius des Heptagons überschreitet, aber größer als der Kugelradius ist.\n- Alle Kugeln rotieren mit Reibung, die Nummern auf den Kugeln können verwendet werden, um die Rotation der Kugel anzuzeigen.\n- Das Heptagon dreht sich um sein Zentrum, und die Drehgeschwindigkeit beträgt 360 Grad pro 5 Sekunden.\n- Die Größe des Heptagons sollte groß genug sein, um alle Kugeln zu enthalten.\n- Verwenden Sie nicht die pygame-Bibliothek; implementieren Sie Algorithmen zur Kollisionsdetektion und Kollisionsantwort selbst. Die folgenden Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Alle Codes sollten in einer einzelnen Python-Datei abgelegt werden.<｜Assistant｜>"

Nicht-dynamisches 2-Bit. Scheitert - WARNUNG VOR ANFÄLLEN nochmals!

unsloth-q2_k_rotate.txt

Dynamisch 2-Bit. Löst das Heptagon-Rätsel tatsächlich korrekt!!

unsloth-q2_k_xl_rotate.txt

Ursprüngliches float8

fp8-heptagon.txt

Die dynamische 2,7-Bit-Quantisierung, die nur 230GB groß ist, schafft es tatsächlich, das Heptagon-Rätsel zu lösen! Die vollständige Ausgabe für alle 3 Versionen (einschließlich vollem fp8) ist unten:

Dynamischer 2-Bit Heptagon-Code

import tkinter as tk
import math
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple, Optional

# Konstanten
HEPTAGON_RADIUS = 300
BALL_RADIUS = 20
GRAVITY = 0.2
FRICTION = 0.99
BOUNCE_FACTOR = 0.8
ROTATION_SPEED = 360 / 5  # Grad pro Sekunde
SPIN_FRICTION = 0.98
BALL_COLORS = [
    "#f8b862", "#f6ad49", "#f39800", "#f08300", "#ec6d51",
    "#ee7948", "#ed6d3d", "#ec6800", "#ec6800", "#ee7800",
    "#eb6238", "#ea5506", "#ea5506", "#eb6101", "#e49e61",
    "#e45e32", "#e17b34", "#dd7a56", "#db8449", "#d66a35"
]

@dataclass
class Ball:
    x: float
    y: float
    vx: float
    vy: float
    number: int
    spin: float = 0.0
    color: str = "#000000"

@dataclass
class Wall:
    x1: float
    y1: float
    x2: float
    y2: float

class BouncingBalls:
    def __init__(self, root):
        self.root = root
        self.canvas = tk.Canvas(root, width=800, height=800, bg="white")
        self.canvas.pack()
        self.balls: List[Ball] = []
        self.walls: List[Wall] = []
        self.heptagon_angle = 0
        self.last_time = 0
        
        self.setup_balls()
        self.setup_heptagon()
        
        self.root.after(16, self.update)
        self.root.bind("<space>", self.reset_balls)
    
    def setup_balls(self):
        for i in range(20):
            ball = Ball(
                x=400,
                y=400,
                vx=np.random.uniform(-5, 5),
                vy=np.random.uniform(-5, 5),
                number=i+1,
                color=BALL_COLORS[i],
            )
            self.balls.append(ball)
    
    def setup_heptagon(self):
        # Erstelle anfängliche Heptagon-Wände
        self.update_heptagon_walls(0)
    
    def update_heptagon_walls(self, angle):
        self.walls = []
        center_x, center_y = 400, 400
        angle_rad = math.radians(angle)
        
        for i in range(7):
            angle1 = angle_rad + 2 * math.pi * i / 7
            angle2 = angle_rad + 2 * math.pi * (i + 1) / 7
            
            x1 = center_x + HEPTAGON_RADIUS * math.cos(angle1)
            y1 = center_y + HEPTAGON_RADIUS * math.sin(angle1)
            x2 = center_x + HEPTAGON_RADIUS * math.cos(angle2)
            y2 = center_y + HEPTAGON_RADIUS * math.sin(angle2)
            
            self.walls.append(Wall(x1, y1, x2, y2))
    
    def reset_balls(self, event=None):
        for ball in self.balls:
            ball.x = 400
            ball.y = 400
            ball.vx = np.random.uniform(-5, 5)
            ball.vy = np.random.uniform(-5, 5)
            ball.spin = np.random.uniform(-5, 5)
    
    def update(self):
        current_time = self.root.after_idle(self.root.after, 16, self.update)
        if self.last_time == 0:
            self.last_time = current_time
            return
        
        # Delta-Zeit berechnen (ungefähr)
        dt = 0.016  # Annahme ~60 FPS
        
        # Heptagon-Rotation aktualisieren
        self.heptagon_angle += ROTATION_SPEED * dt
        self.update_heptagon_walls(self.heptagon_angle)
        
        # Kugeln aktualisieren
        for ball in self.balls:
            # Schwerkraft anwenden
            ball.vy += GRAVITY
            
            # Reibung anwenden
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            ball.spin *= SPIN_FRICTION
            
            # Kugel bewegen
            ball.x += ball.vx
            ball.y += ball.vy
            
            # Kollisionen mit Wänden prüfen
            self.check_wall_collisions(ball)
            
            # Kollisionen mit anderen Kugeln prüfen
            for other in self.balls:
                if other.number != ball.number:
                    self.check_ball_collision(ball, other)
        
        # Alles zeichnen
        self.draw()
    
    def check_wall_collisions(self, ball):
        for wall in self.walls:
            # Finde den nächsten Punkt auf dem Wandsegment zur Kugel
            closest = self.closest_point_on_segment(
                wall.x1, wall.y1, wall.x2, wall.y2, ball.x, ball.y
            )
            
            # Abstand zur Wand berechnen
            dx = ball.x - closest[0]
            dy = ball.y - closest[1]
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < BALL_RADIUS:
                # Kollision erkannt
                # Normalenvektor berechnen
                nx = dx / distance
                ny = dy / distance
                
                # Relativgeschwindigkeit entlang der Normalen berechnen
                v_rel = ball.vx * nx + ball.vy * ny
                
                if v_rel < 0:  # Bewegt sich zur Wand hin
                    # Impuls berechnen
                    j = -(1 + BOUNCE_FACTOR) * v_rel
                    
                    # Impuls anwenden
                    ball.vx += j * nx
                    ball.vy += j * ny
                    
                    # Etwas Spin basierend auf der Kollision hinzufügen
                    ball.spin += (ball.vx * ny - ball.vy * nx) * 0.1
                    
                    # Kugel aus der Kollision bewegen
                    penetration = BALL_RADIUS - distance
                    ball.x += penetration * nx
                    ball.y += penetration * ny
    
    def check_ball_collision(self, ball1, ball2):
        dx = ball2.x - ball1.x
        dy = ball2.y - ball1.y
        distance = math.sqrt(dx*dx + dy*dy)
        
        if distance < 2 * BALL_RADIUS:
            # Kollision erkannt
            nx = dx / distance
            ny = dy / distance
            
            # Relativgeschwindigkeit berechnen
            v_rel_x = ball2.vx - ball1.vx
            v_rel_y = ball2.vy - ball1.vy
            v_rel = v_rel_x * nx + v_rel_y * ny
            
            if v_rel < 0:  # Aufeinander zu bewegend
                # Impuls berechnen
                j = -(1 + BOUNCE_FACTOR) * v_rel / 2
                
                # Impulse anwenden
                ball1.vx -= j * nx
                ball1.vy -= j * ny
                ball2.vx += j * nx
                ball2.vy += j * ny
                
                # Spin basierend auf der Kollision hinzufügen
                ball1.spin += (ball1.vx * ny - ball1.vy * nx) * 0.05
                ball2.spin += (ball2.vx * ny - ball2.vy * nx) * 0.05
                
                # Kugeln auseinander bewegen
                penetration = 2 * BALL_RADIUS - distance
                ball1.x -= penetration * nx * 0.5
                ball1.y -= penetration * ny * 0.5
                ball2.x += penetration * nx * 0.5
                ball2.y += penetration * ny * 0.5
    
    @staticmethod
    def closest_point_on_segment(x1, y1, x2, y2, x, y):
        # Vektor vom Punkt zum Segmentanfang
        dx = x - x1
        dy = y - y1
        
        # Segmentvektor
        sx = x2 - x1
        sy = y2 - y1
        
        # Projektion des Punktes auf das Segment
        dot = dx * sx + dy * sy
        len_sq = sx * sx + sy * sy
        param = dot / len_sq if len_sq != 0 else -1
        
        if param < 0:
            return x1, y1
        elif param > 1:
            return x2, y2
        else:
            return x1 + param * sx, y1 + param * sy
    
    def draw(self):
        self.canvas.delete("all")
        
        # Heptagon zeichnen
        points = []
        for wall in self.walls:
            points.extend([wall.x1, wall.y1])
        self.canvas.create_polygon(points, fill="", outline="black", width=2)
        
        # Kugeln zeichnen
        for ball in self.balls:
            # Kugel zeichnen
            self.canvas.create_oval(
                ball.x - BALL_RADIUS, ball.y - BALL_RADIUS,
                ball.x + BALL_RADIUS, ball.y + BALL_RADIUS,
                fill=ball.color, outline="black"
            )
            
            # Nummer mit Rotation basierend auf Spin zeichnen
            angle = ball.spin * 10  # Skaliere Spin für visuellen Effekt
            self.canvas.create_text(
                ball.x, ball.y,
                text=str(ball.number),
                font=("Arial", 12, "bold"),
                angle=angle
            )

if __name__ == "__main__":
    root = tk.Tk()
    root.title("Springende Kugeln in rotierendem Heptagon")
    app = BouncingBalls(root)
    root.mainloop()

Nicht-dynamischer 2-Bit Heptagon-Code

import tkinter as tk
import math
import random
from dataclasses import dataclass
from typing import List, Tuple, Optional
import sys

# Konstanten
WIDTH, HEIGHT = 800, 800
HEPTAGON_RADIUS = 300
BALL_RADIUS = 15
GRAVITY = 0.5
FRICTION = 0.999
ELASTICITY = 0.8
ROTATION_SPEED = 2 * math.pi / 5  # 360 Grad pro 5 Sekunden
SPIN_DECAY = 0.99

# Farben für die Kugeln
BALL_COLORS = [
    "#f8b862", "#f6ad49", "#f39800", "#f08300", "#ec6d51",
    "#ee7948", "#ed6d3d", "#ec6800", "#ec6800", "#ee7800",
    "#eb6238", "#ea5506", "#ea5506", "#eb6101", "#e49e61",
    "#e45e32", "#e17b34", "#dd7a56", "#db8449", "#d66a35"
]

@dataclass
class Ball:
    x: float
    y: float
    vx: float
    vy: float
    radius: float
    color: str
    number: int
    spin: float = 0.0

@dataclass
class Heptagon:
    center_x: float
    center_y: float
    radius: float
    angle: float = 0.0

class BouncingBalls:
    def __init__(self, root):
        self.root = root
        self.canvas = tk.Canvas(root, width=WIDTH, height=HEIGHT, bg="white")
        self.canvas.pack()
        
        self.heptagon = Heptagon(WIDTH//2, HEIGHT//2, HEPTAGON_RADIUS)
        self.balls = []
        self.setup_balls()
        
        self.root.after(0, self.update)
        self.root.mainloop()
    
    def setup_balls(self):
        center_x, center_y = WIDTH//2, HEIGHT//2
        for i in range(20):
            self.balls.append(Ball(
                x=center_x,
                y=center_y,
                vx=0,
                vy=0,
                radius=BALL_RADIUS,
                color=BALL_COLORS[i],
                number=i+1,
                spin=0
            ))
    
    def update(self):
        self.canvas.delete("all")
        
        # Heptagon-Winkel aktualisieren
        self.heptagon.angle += ROTATION_SPEED / 60  # Annahme 60 FPS
        
        # Heptagon zeichnen
        self.draw_heptagon()
        
        # Kugeln aktualisieren und zeichnen
        for ball in self.balls:
            # Schwerkraft anwenden
            ball.vy += GRAVITY
            
            # Position aktualisieren
            ball.x += ball.vx
            ball.y += ball.vy
            
            # Reibung anwenden
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            
            # Spin-Abklingung anwenden
            ball.spin *= SPIN_DECAY
            
            # Kollision mit Heptagon-Wänden prüfen
            self.check_heptagon_collision(ball)
            
            # Kollision mit anderen Kugeln prüfen
            for other in self.balls:
                if other != ball:
                    if self.check_ball_collision(ball, other):
                        self.resolve_ball_collision(ball, other)
            
            # Kugel zeichnen
            self.draw_ball(ball)
        
        self.root.after(16, self.update)  # ~60 FPS
    
    def draw_heptagon(self):
        center_x, center_y = self.heptagon.center_x, self.heptagon.center_y
        points = []
        for i in range(7):
            angle = self.heptagon.angle + i * 2 * math.pi / 7
            x = center_x + self.heptagon.radius * math.cos(angle)
            y = center_y + self.heptagon.radius * math.sin(angle)
            points.append((x, y))
        
        # Heptagon zeichnen
        self.canvas.create_polygon(
            [points[0], points[1], points[2], points[3], 
             points[4], points[5], points[6]],
            outline="black", fill="", width=2
        )
    
    def draw_ball(self, ball):
        self.canvas.create_oval(
            ball.x - ball.radius,
            ball.y - ball.radius,
            ball.x + ball.radius,
            ball.y + ball.radius,
            fill=ball.color,
            outline="black"
        )
        
        # Nummer zeichnen
        self.canvas.create_text(
            ball.x, ball.y,
            text=str(ball.number),
            fill="black"
        )
    
    def check_heptagon_collision(self, ball):
        center_x, center_y = WIDTH//2, HEIGHT//2
        
        # Abstand vom Zentrum prüfen
        dx = ball.x - center_x
        dy = ball.y - center_y
        dist = math.sqrt(dx**2 + dy**2)
        
        if dist + ball.radius > self.heptagon.radius:
            # Normalenvektor vom Zentrum zur Kugel finden
            angle = math.atan2(dy, dx)
            normal_x = math.cos(angle)
            normal_y = math.sin(angle)
            
            # Kugel zurück ins Heptagon bewegen
            overlap = (dist + ball.radius) - self.heptagon.radius
            ball.x -= overlap * normal_x
            ball.y -= overlap * normal_y
            
            # Geschwindigkeit reflektieren
            dot_product = ball.vx * normal_x + ball.vy * normal_y
            ball.vx -= 2 * dot_product * normal_x * ELASTICITY
            ball.vy -= 2 * dot_product * normal_y * ELASTICITY
    
    def check_ball_collision(self, ball1, ball2):
        dx = ball2.x - ball1.x
        dy = ball2.y - ball1.y
        distance = math.sqrt(dx**2 + dy**2)
        return distance < (ball1.radius + ball2.radius)
    
    def resolve_ball_collision(self, ball1, ball2):
        dx = ball2.x - ball1.x
        dy = ball2.y - ball1.y
        distance = math.sqrt(dx**2 + dy**2)
        
        # Normalenvektor
        nx = dx / distance
        ny = dy / distance
        
        # Relativgeschwindigkeit
        dvx = ball2.vx - ball1.vx
        dvy = ball2.vy - ball1.vy
        
        # Impuls berechnen
        impulse = 2 * (dvx * nx + dvy * ny) / 2
        impulse *= ELASTICITY
        
        # Impuls anwenden
        ball1.vx -= impulse * nx
        ball1.vy -= impulse * ny
        ball2.vx += impulse * nx
        ball2.vy += impulse * ny
        
        # Kugeln trennen, um Verklebungen zu verhindern
        overlap = (ball1.radius + ball2.radius) - distance
        ball1.x -= overlap * nx / 2
        ball1.y -= overlap * ny / 2
        ball2.x += overlap * nx / 2
        ball2.y += overlap * ny / 2
    
    def run(self):
        self.root.mainloop()

if __name__ == "__main__":
    root = tk.Tk()
    root.title("Springende Kugeln in einem rotierenden Heptagon")
    app = BouncingBalls(root)
    app.run()

Float8 Heptagon-Code

import tkinter as tk
import math
import numpy as np
from dataclasses import dataclass
from typing import List, Tuple, Optional

# Konstanten
WIDTH, HEIGHT = 800, 800
CENTER_X, CENTER_Y = WIDTH // 2, HEIGHT // 2
GRAVITY = 0.2
FRICTION = 0.99
BALL_RADIUS = 15
HEPTAGON_RADIUS = 300
ROTATION_SPEED = 360 / 5  # Grad pro Sekunde
ELASTICITY = 0.8
SPIN_FRICTION = 0.98

# Farben für die Kugeln
BALL_COLORS = [
    '#f8b862', '#f6ad49', '#f39800', '#f08300', '#ec6d51',
    '#ee7948', '#ed6d3d', '#ec6800', '#ec6800', '#ee7800',
    '#eb6238', '#ea5506', '#ea5506', '#eb6101', '#e49e61',
    '#e45e32', '#e17b34', '#dd7a56', '#db8449', '#d66a35'
]

@dataclass
class Ball:
    x: float
    y: float
    vx: float
    vy: float
    radius: float
    color: str
    number: int
    spin: float = 0.0

    def move(self):
        self.x += self.vx
        self.y += self.vy
        self.vy += GRAVITY
        self.vx *= FRICTION
        self.vy *= FRICTION
        self.spin *= SPIN_FRICTION

    def collide_with_ball(self, other: 'Ball'):
        dx = other.x - self.x
        dy = other.y - self.y
        distance = math.hypot(dx, dy)
        
        if distance < self.radius + other.radius:
            # Kollisionnormal berechnen
            nx = dx / distance
            ny = dy / distance
            
            # Relativgeschwindigkeit berechnen
            dvx = other.vx - self.vx
            dvy = other.vy - self.vy
            
            # Impuls berechnen
            impulse = 2 * (dvx * nx + dvy * ny) / (1/self.radius + 1/other.radius)
            
            # Impuls anwenden
            self.vx += impulse * nx / self.radius
            self.vy += impulse * ny / self.radius
            other.vx -= impulse * nx / other.radius
            other.vy -= impulse * ny / other.radius
            
            # Kugeln trennen, um Kleben zu verhindern
            overlap = (self.radius + other.radius - distance) / 2
            self.x -= overlap * nx
            self.y -= overlap * ny
            other.x += overlap * nx
            other.y += overlap * ny
            
            # Etwas Spin übertragen
            transfer = impulse * 0.01
            self.spin -= transfer
            other.spin += transfer

class HeptagonBounceSimulator:
    def __init__(self, root):
        self.root = root
        self.canvas = tk.Canvas(root, width=WIDTH, height=HEIGHT, bg='white')
        self.canvas.pack()
        
        self.balls = self.create_balls()
        self.heptagon_angle = 0
        self.last_time = 0
        self.running = True
        
        self.root.bind('<space>', self.toggle_pause)
        self.root.bind('<Escape>', lambda e: root.destroy())
        
        self.last_time = self.root.after(0, self.update)
    
    def create_balls(self) -> List[Ball]:
        balls = []
        for i in range(20):
            # Alle Kugeln in der Mitte mit kleiner zufälliger Geschwindigkeit starten
            angle = np.random.uniform(0, 2 * math.pi)
            speed = np.random.uniform(0.5, 2)
            vx = math.cos(angle) * speed
            vy = math.sin(angle) * speed
            
            balls.append(Ball(
                x=CENTER_X,
                y=CENTER_Y,
                vx=vx,
                vy=vy,
                radius=BALL_RADIUS,
                color=BALL_COLORS[i],
                number=i+1,
                spin=np.random.uniform(-2, 2)
            ))
        return balls
    
    def toggle_pause(self, event):
        self.running = not self.running
        if self.running:
            self.last_time = self.root.after(0, self.update)
    
    def get_heptagon_vertices(self) -> List[Tuple[float, float]]:
        vertices = []
        for i in range(7):
            angle = math.radians(self.heptagon_angle + i * 360 / 7)
            x = CENTER_X + HEPTAGON_RADIUS * math.cos(angle)
            y = CENTER_Y + HEPTAGON_RADIUS * math.sin(angle)
            vertices.append((x, y))
        return vertices
    
    def check_ball_heptagon_collision(self, ball: Ball):
        vertices = self.get_heptagon_vertices()
        closest_dist = float('inf')
        closest_normal = (0, 0)
        closest_edge = None
        
        # Kollision mit jeder Kante des Heptagons prüfen
        for i in range(len(vertices)):
            p1 = vertices[i]
            p2 = vertices[(i + 1) % len(vertices)]
            
            # Vektor von p1 zu p2
            edge_x = p2[0] - p1[0]
            edge_y = p2[1] - p1[1]
            edge_length = math.hypot(edge_x, edge_y)
            
            # Kantenvektor normalisieren
            edge_x /= edge_length
            edge_y /= edge_length
            
            # Normalenvektor (senkrecht zur Kante, nach innen zeigend)
            nx = -edge_y
            ny = edge_x
            
            # Vektor von p1 zur Kugel
            ball_to_p1_x = ball.x - p1[0]
            ball_to_p1_y = ball.y - p1[1]
            
            # Kugel auf Kantennormale projizieren
            projection = ball_to_p1_x * nx + ball_to_p1_y * ny
            
            # Wenn Projektion negativ ist, liegt die Kugel außerhalb des Heptagons
            if projection < ball.radius:
                # Nächsten Punkt auf der Kante zur Kugel finden
                edge_proj = ball_to_p1_x * edge_x + ball_to_p1_y * edge_y
                edge_proj = max(0, min(edge_length, edge_proj))
                closest_x = p1[0] + edge_proj * edge_x
                closest_y = p1[1] + edge_proj * edge_y
                
                # Abstand von der Kugel zum nächstgelegenen Punkt auf der Kante
                dist = math.hypot(ball.x - closest_x, ball.y - closest_y)
                
                if dist < closest_dist:
                    closest_dist = dist
                    closest_normal = (nx, ny)
                    closest_edge = (p1, p2)
        
        if closest_dist < ball.radius:
            # Abprallreaktion berechnen
            dot_product = ball.vx * closest_normal[0] + ball.vy * closest_normal[1]
            
            # Abprall mit Elastizität anwenden
            ball.vx -= (1 + ELASTICITY) * dot_product * closest_normal[0]
            ball.vy -= (1 + ELASTICITY) * dot_product * closest_normal[1]
            
            # Etwas Spin basierend auf dem Aufprall hinzufügen
            edge_vec = (closest_edge[1][0] - closest_edge[0][0], 
                        closest_edge[1][1] - closest_edge[0][1])
            edge_length = math.hypot(edge_vec[0], edge_vec[1])
            if edge_length > 0:
                edge_vec = (edge_vec[0]/edge_length, edge_vec[1]/edge_length)
                # Kreuzprodukt von Geschwindigkeit und Kantenrichtung
                spin_effect = (ball.vx * edge_vec[1] - ball.vy * edge_vec[0]) * 0.1
                ball.spin += spin_effect
            
            # Kugel außerhalb des Heptagons verschieben, um Kleben zu verhindern
            penetration = ball.radius - closest_dist
            ball.x += penetration * closest_normal[0]
            ball.y += penetration * closest_normal[1]
    
    def update(self):
        if not self.running:
            return
        
        # Leinwand löschen
        self.canvas.delete('all')
        
        # Heptagon-Rotation aktualisieren
        self.heptagon_angle += ROTATION_SPEED / 60  # Annahme ~60 FPS
        
        # Heptagon zeichnen
        vertices = self.get_heptagon_vertices()
        self.canvas.create_polygon(vertices, outline='black', fill='', width=2)
        
        # Kugeln aktualisieren und zeichnen
        for i, ball in enumerate(self.balls):
            # Kugel bewegen
            ball.move()
            
            # Kollisionen mit dem Heptagon prüfen
            self.check_ball_heptagon_collision(ball)
            
            # Kugel zeichnen
            self.canvas.create_oval(
                ball.x - ball.radius, ball.y - ball.radius,
                ball.x + ball.radius, ball.y + ball.radius,
                fill=ball.color, outline='black'
            )
            
            # Nummer mit Rotation basierend auf Spin zeichnen
            angle = ball.spin * 10  # Spin für sichtbare Rotation skalieren
            self.canvas.create_text(
                ball.x, ball.y,
                text=str(ball.number),
                font=('Arial', 10, 'bold'),
                angle=angle
            )
        
        # Kollisionen Kugel-Kugel prüfen
        for i in range(len(self.balls)):
            for j in range(i + 1, len(self.balls)):
                self.balls[i].collide_with_ball(self.balls[j])
        
        # Nächstes Update planen
        self.last_time = self.root.after(16, self.update)  # ~60 FPS

if __name__ == '__main__':
    root = tk.Tk()
    root.title('Bouncing Balls in a Spinning Heptagon')
    simulator = HeptagonBounceSimulator(root)
    root.mainloop()

🕵️ Zusätzliche Erkenntnisse & Tipps

1. Unsere empirischen Tests zeigen, dass eine niedrigere KV-Cache-Quantisierung (4bit) die Generierungsqualität zu verschlechtern scheint - weitere Tests sind nötig, aber wir empfehlen die Verwendung von q8_0 Cache-Quantisierung. Das Ziel der Quantisierung ist die Unterstützung längerer Kontextlängen, da der KV-Cache ziemlich viel Speicher benötigt.

2. Wir stellten fest, dass die down_proj in diesem Modell gegenüber Quantisierung extrem empfindlich ist. Wir mussten einige unserer dynamischen Quants, die 2 Bit verwendeten, überarbeiten down_proj und verwenden jetzt 3 Bit als Minimum für all diese Matrizen.

3. Die Verwendung von llama.cpp s Flash-Attention-Backend führt zu etwas schnelleren Decodiergeschwindigkeiten. Verwenden Sie -DGGML_CUDA_FA_ALL_QUANTS=ON beim Kompilieren. Es ist außerdem am besten, Ihre CUDA-Architektur wie auf https://developer.nvidia.com/cuda-gpus gefunden einzustellen, um die Kompilierzeiten zu reduzieren, und setzen Sie sie dann über -DCMAKE_CUDA_ARCHITECTURES="80"

4. Die Verwendung eines min_p=0.01ist wahrscheinlich ausreichend. llama.cppStandardmäßig ist es 0.1, was wahrscheinlich nicht notwendig ist. Da ohnehin eine Temperatur von 0.3 verwendet wird, werden sehr unwahrscheinliche Token höchstwahrscheinlich kaum ausgewählt, daher ist das Entfernen sehr unwahrscheinlicher Token eine gute Idee. DeepSeek empfiehlt eine Temperatur von 0.0 für Programmieraufgaben.