🐳DeepSeek-V3-0324: Anleitung zum lokalen Betrieb

Wie man DeepSeek-V3-0324 lokal ausführt, unter Verwendung unserer dynamischen Quants, die Genauigkeit wiederherstellen

Bitte siehe 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! Nach der Veröffentlichung von V3, R1 Zero und R1 im Dezember 2024 und Januar 2025 hat DeepSeek ihre Checkpoints/Modelle für V3 aktualisiert und ein März-Update veröffentlicht!

Laut DeepSeek stieg MMLU-Pro um +5,3 % auf 81,2 %. GPQA +9,3 Prozentpunkte. AIME +19,8 % und LiveCodeBench +10,0 %! Sie stellten ein Diagramm bereit, das zeigt, wie sie im Vergleich zum vorherigen V3-Checkpoint und anderen Modellen wie GPT-4.5 und Claude Sonnet 3.7 abgeschnitten haben. Aber wie betreiben wir ein Modell mit 671 Milliarden Parametern lokal?

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

Das originale DeepSeek V3-Upload liegt in float8 vor und belegt 715 GB. Durch die Verwendung von Q4_K_M wird die Dateigröße etwa halbiert auf ca. 404 GB, und unsere dynamische 1,78-Bit-Quantisierung passt in ungefähr 151 GB. Wir empfehlen die Verwendung unserer 2,7-Bit-Quantisierung, um Größe und Genauigkeit auszugleichen! Die 2,4-Bit-Variante funktioniert ebenfalls gut!

⚙️ Offiziell empfohlene Einstellungen

Laut DeepSeekDies sind die empfohlenen Einstellungen für die Inferenz:

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

• Min_P von 0,00 (optional, aber 0,01 funktioniert gut, der Standard in llama.cpp 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 System-Prompts 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 KV-Cache-Quantisierung 8bit verwenden, NICHT 4bit – wir stellten fest, dass 4bit deutlich schlechter abschneidet.

📖 Tutorial: Wie man DeepSeek-V3 in llama.cpp ausführt

1. Holen Sie sich die neueste llama.cpp auf GitHub hier. Sie können auch den unten stehenden Build-Anweisungen folgen. Ändern Sie -DGGML_CUDA=ON zu -DGGML_CUDA=OFF wenn Sie keine GPU haben oder nur CPU-Inferenz wünschen.

HINWEIS: Die Verwendung von -DGGML_CUDA=ON für GPUs kann 5 Minuten Kompilierzeit benötigen. Nur CPU braucht 1 Minute zum Kompilieren. Möglicherweise interessieren Sie sich für die vorcompilierten Binaries 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 über (nach Installation von pip install huggingface_hub hf_transfer ). Sie können wählen UD-IQ1_S(dynamisches 1,78-Bit-Quant) oder andere quantisierte Versionen wie Q4_K_M . Ich empfehle die Verwendung unserer dynamischen 2,7-Bit-Quantisierung UD-Q2_K_XL um Größe und Genauigkeit auszugleichen. Weitere 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 (230 GB) Verwende "*UD-IQ_S*" für Dynamisch 1,78 Bit (151 GB)
)

1. Führe Unsloths Flappy-Bird-Test wie in unserem 1,58-Bit-Dynamik-Quant für DeepSeek R1 beschrieben aus.

2. Bearbeiten --threads 32 für die Anzahl der CPU-Threads bearbeiten, --ctx-size 16384 für die Kontextlänge, --n-gpu-layers 2 für das GPU-Offloading für wie viele Schichten. Versuchen Sie, es anzupassen, wenn Ihre GPU nicht mehr genügend Speicher hat. Entfernen Sie es auch, wenn Sie nur CPU-Inferenz haben.

./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｜>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. Standard 2-Bit-Version: Klicken, um Ergebnis zu sehen (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 bei einer 24GB- oder 80GB-GPU kann man erwarten, nach dem Abrunden auszulagern (um 1 reduzieren, wenn es wegen Speichermangel abstürzt):

Quant	Dateigröße	24GB GPU	80GB GPU	2x80GB GPU
1,73bit	173 GB	5	25	56
2,22bit	183GB	4	22	49
2,51bit	212GB	2	19	32

Ausführung auf Mac / Apple-Geräten

Bei Apple-Metal-Geräten sei vorsichtig mit --n-gpu-layers. Wenn der Rechner in den Out-of-Memory-Zustand gerät, reduziere diesen Wert. Bei einer Maschine mit 128 GB Unified Memory solltest du in der Lage sein, ungefähr 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 Quants auch mittels r/Localllama der das Modell darin testet, eine grundlegende Physik-Engine zu erstellen, um Kugeln in einer rotierenden, geschlossenen Heptagon-Form zu simulieren.

Das Ziel ist, das Heptagon zum Drehen zu bringen, 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 Bälle zeigt, die in einem rotierenden Heptagon springen:\n- Alle Bälle haben den gleichen Radius.\n- Alle Bälle haben eine Nummer von 1 bis 20.\n- Alle Bälle 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 Bälle sollen von Gravitation und Reibung beeinflusst werden und müssen realistisch von den rotierenden Wänden abprallen. Es sollte auch Kollisionen zwischen den Bällen geben.\n- Das Material aller Bälle bestimmt, dass ihre Aufprallsprunghöhe den Radius des Heptagons nicht überschreiten darf, aber höher als der Ballradius sein soll.\n- Alle Bälle rotieren mit Reibung; die Nummern auf den Bällen können verwendet werden, um die Drehung 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 Bälle aufzunehmen.\n- Verwende nicht die pygame-Bibliothek; implementiere Kollisionsdetektions- und Kollisionsantwortalgorithmen usw. selbst. Die folgenden Python-Bibliotheken sind erlaubt: tkinter, math, numpy, dataclasses, typing, sys.\n- Alle Codes sollten in einer einzigen Python-Datei abgelegt werden.<｜Assistant｜>"

Nicht-dynamisch 2bit. Scheitert - WARNUNG VOR ANFÄLLEN wieder!

unsloth-q2_k_rotate.txt

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

unsloth-q2_k_xl_rotate.txt

Original float8

fp8-heptagon.txt

Die dynamische 2,7-Bit-Quantisierung, die nur 230 GB 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) steht 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 initiale 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
        
        # Berechne Delta-Zeit (ungefähr)
        dt = 0.016  # Annahme ~60 FPS
        
        # Aktualisiere Heptagon-Rotation
        self.heptagon_angle += ROTATION_SPEED * dt
        self.update_heptagon_walls(self.heptagon_angle)
        
        # Aktualisiere Bälle
        for ball in self.balls:
            # Wende Gravitation an
            ball.vy += GRAVITY
            
            # Wende Reibung an
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            ball.spin *= SPIN_FRICTION
            
            # Bewege Ball
            ball.x += ball.vx
            ball.y += ball.vy
            
            # Prüfe Kollisionen mit Wänden
            self.check_wall_collisions(ball)
            
            # Prüfe Kollisionen mit anderen Bällen
            for other in self.balls:
                if other.number != ball.number:
                    self.check_ball_collision(ball, other)
        
        # Zeichne alles
        self.draw()
    
    def check_wall_collisions(self, ball):
        for wall in self.walls:
            # Finde den nächsten Punkt auf dem Wandsegment zum Ball
            closest = self.closest_point_on_segment(
                wall.x1, wall.y1, wall.x2, wall.y2, ball.x, ball.y
            )
            
            # Berechne Abstand zur Wand
            dx = ball.x - closest[0]
            dy = ball.y - closest[1]
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < BALL_RADIUS:
                # Kollision erkannt
                # Berechne Normalenvektor
                nx = dx / distance
                ny = dy / distance
                
                # Berechne relative Geschwindigkeit entlang der Normalen
                v_rel = ball.vx * nx + ball.vy * ny
                
                if v_rel < 0:  # Bewegt sich zur Wand hin
                    # Berechne Impuls
                    j = -(1 + BOUNCE_FACTOR) * v_rel
                    
                    # Wende Impuls an
                    ball.vx += j * nx
                    ball.vy += j * ny
                    
                    # Füge etwas Spin basierend auf der Kollision hinzu
                    ball.spin += (ball.vx * ny - ball.vy * nx) * 0.1
                    
                    # Bewege Ball aus der Kollision heraus
                    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
            
            # Berechne relative Geschwindigkeit
            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:  # Bewegen sich aufeinander zu
                # Berechne Impuls
                j = -(1 + BOUNCE_FACTOR) * v_rel / 2
                
                # Wende Impulse an
                ball1.vx -= j * nx
                ball1.vy -= j * ny
                ball2.vx += j * nx
                ball2.vy += j * ny
                
                # Füge Spin basierend auf der Kollision hinzu
                ball1.spin += (ball1.vx * ny - ball1.vy * nx) * 0.05
                ball2.spin += (ball2.vx * ny - ball2.vy * nx) * 0.05
                
                # Bewege Bälle auseinander
                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")
        
        # Zeichne Heptagon
        points = []
        for wall in self.walls:
            points.extend([wall.x1, wall.y1])
        self.canvas.create_polygon(points, fill="", outline="black", width=2)
        
        # Zeichne Bälle
        for ball in self.balls:
            # Zeichne 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"
            )
            
            # Zeichne Nummer mit Rotation basierend auf Spin
            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 Bälle 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 Bälle
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")
        
        # Aktualisiere Heptagon-Winkel
        self.heptagon.angle += ROTATION_SPEED / 60  # Annahme 60 FPS
        
        # Zeichne Heptagon
        self.draw_heptagon()
        
        # Aktualisiere und zeichne Bälle
        for ball in self.balls:
            # Wende Gravitation an
            ball.vy += GRAVITY
            
            # Aktualisiere Position
            ball.x += ball.vx
            ball.y += ball.vy
            
            # Wende Reibung an
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            
            # Wende Spin-Abnahme an
            ball.spin *= SPIN_DECAY
            
            # Prüfe Kollision mit Heptagon-Wänden
            self.check_heptagon_collision(ball)
            
            # Prüfe Kollision mit anderen Bällen
            for other in self.balls:
                if other != ball:
                    if self.check_ball_collision(ball, other):
                        self.resolve_ball_collision(ball, other)
            
            # Zeichne den Ball
            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))
        
        # Zeichne Heptagon
        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"
        )
        
        # Zeichne die Nummer
        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
        
        # Prüfe Abstand zum Zentrum
        dx = ball.x - center_x
        dy = ball.y - center_y
        dist = math.sqrt(dx**2 + dy**2)
        
        if dist + ball.radius > self.heptagon.radius:
            # Finde den Normalenvektor vom Zentrum zum Ball
            angle = math.atan2(dy, dx)
            normal_x = math.cos(angle)
            normal_y = math.sin(angle)
            
            # Bewege Ball zurück ins Heptagon
            overlap = (dist + ball.radius) - self.heptagon.radius
            ball.x -= overlap * normal_x
            ball.y -= overlap * normal_y
            
            # Reflektiere Geschwindigkeit
            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
        
        # Relative Geschwindigkeit
        dvx = ball2.vx - ball1.vx
        dvy = ball2.vy - ball1.vy
        
        # Berechne Impuls
        impulse = 2 * (dvx * nx + dvy * ny) / 2
        impulse *= ELASTICITY
        
        # Wende Impuls an
        ball1.vx -= impulse * nx
        ball1.vy -= impulse * ny
        ball2.vx += impulse * nx
        ball2.vy += impulse * ny
        
        # Trenne die Bälle, um Kleben 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 Bälle 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 Bälle
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:
            # Berechne Kollisionsnormalenvektor
            nx = dx / distance
            ny = dy / distance
            
            # Berechne relative Geschwindigkeit
            dvx = other.vx - self.vx
            dvy = other.vy - self.vy
            
            # Berechne Impuls
            impulse = 2 * (dvx * nx + dvy * ny) / (1/self.radius + 1/other.radius)
            
            # Wende Impuls an
            self.vx += impulse * nx / self.radius
            self.vy += Impuls * ny / self.radius
            other.vx -= Impuls * nx / other.radius
            other.vy -= Impuls * ny / other.radius
            
            # Trenne Kugeln, um Kleben zu verhindern
            Überlappung = (self.radius + other.radius - Entfernung) / 2
            self.x -= Überlappung * nx
            self.y -= Überlappung * ny
            other.x += Überlappung * nx
            other.y += Überlappung * ny
            
            # Übertrage etwas Spin
            transfer = Impuls * 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):
            # Starte alle Kugeln in der Mitte mit kleiner zufälliger Geschwindigkeit
            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
        
        # Überprüfe Kollision mit jeder Kante des Heptagons
        for i in range(len(vertices)):
            p1 = vertices[i]
            p2 = vertices[(i + 1) % len(vertices)]
            
            # Vektor von p1 nach p2
            edge_x = p2[0] - p1[0]
            edge_y = p2[1] - p1[1]
            edge_length = math.hypot(edge_x, edge_y)
            
            # Normiere den Kantenvektor
            edge_x /= edge_length
            edge_y /= edge_length
            
            # Normalenvektor (senkrecht zur Kante, nach innen gerichtet)
            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]
            
            # Projektiere Kugel auf die Kanten-Normale
            projection = ball_to_p1_x * nx + ball_to_p1_y * ny
            
            # Wenn die Projektion negativ ist, befindet sich die Kugel außerhalb des Heptagons
            if projection < ball.radius:
                # Finde den nächsten Punkt auf der Kante zur Kugel
                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ächsten 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:
            # Berechne Abprallreaktion
            dot_product = ball.vx * closest_normal[0] + ball.vy * closest_normal[1]
            
            # Wende Abprall mit Elastizität an
            ball.vx -= (1 + ELASTICITY) * dot_product * closest_normal[0]
            ball.vy -= (1 + ELASTICITY) * dot_product * closest_normal[1]
            
            # Füge basierend auf dem Aufprall etwas Spin hinzu
            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 Kantendirection
                spin_effect = (ball.vx * edge_vec[1] - ball.vy * edge_vec[0]) * 0.1
                ball.spin += spin_effect
            
            # Bewege Kugel außerhalb des Heptagons, 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
        
        # Lösche Canvas
        self.canvas.delete('all')
        
        # Aktualisiere Heptagon-Rotation
        self.heptagon_angle += ROTATION_SPEED / 60  # Angenommen ~60 FPS
        
        # Zeichne Heptagon
        vertices = self.get_heptagon_vertices()
        self.canvas.create_polygon(vertices, outline='black', fill='', width=2)
        
        # Aktualisiere und zeichne Bälle
        for i, ball in enumerate(self.balls):
            # Bewege Ball
            ball.move()
            
            # Überprüfe Kollisionen mit dem Heptagon
            self.check_ball_heptagon_collision(ball)
            
            # Zeichne 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'
            )
            
            # Zeichne Nummer mit Rotation basierend auf Spin
            angle = ball.spin * 10  # Skaliere Spin für sichtbare Rotation
            self.canvas.create_text(
                ball.x, ball.y,
                text=str(ball.number),
                font=('Arial', 10, 'bold'),
                angle=angle
            )
        
        # Überprüfe Kugel-Kugel-Kollisionen
        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])
        
        # Plane das nächste Update
        self.last_time = self.root.after(16, self.update)  # ~60 FPS

if __name__ == '__main__':
    root = tk.Tk()
    root.title('Springende Kugeln in einem rotierenden Heptagon')
    simulator = HeptagonBounceSimulator(root)
    root.mainloop()

🕵️ Zusätzliche Erkenntnisse & Tipps

1. Unsere empirischen Tests zeigen, dass die Verwendung einer niedrigeren KV-Cache-Quantisierung (4bit) die Generierungsqualität zu verschlechtern scheint - es müssen noch weitere Tests durchgeführt werden, aber wir empfehlen die Verwendung von q8_0 Cache-Quantisierung. Das Ziel der Quantisierung ist es, längere Kontextlängen zu ermöglichen, da der KV-Cache recht viel Speicher verwendet.

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

3. Die Verwendung von llama.cpp s Flash-Attention-Backend führt zu etwas schnelleren Decodiergeschwindigkeiten. Verwende -DGGML_CUDA_FA_ALL_QUANTS=ON beim Kompilieren. Beachte, dass es auch am besten ist, deine CUDA-Architektur wie auf https://developer.nvidia.com/cuda-gpus anzugeben, um Kompilierzeiten zu reduzieren, und setze 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 oder gar nicht gesampelt, daher ist das Entfernen sehr unwahrscheinlicher Token eine gute Idee. DeepSeek empfiehlt für Programmieraufgaben eine Temperatur von 0.0.