🐳DeepSeek-V3-0324: ローカルで実行する方法

当社の動的クオンタイズを使って精度を回復し、DeepSeek-V3-0324 をローカルで実行する方法。

をご覧ください https://docs.unsloth.ai/basics/deepseek-r1-0528-how-to-run-locally （2025年5月28日更新）DeepSeekをより速く、より効率的に実行する方法を学びましょう！

DeepSeekがまた動き出しました！2024年12月と2025年1月にV3、R1 Zero、R1をリリースした後、DeepSeekはV3のチェックポイント／モデルを更新し、3月のアップデートを公開しました！

DeepSeekによると、MMLU-Proは+5.3%上昇して81.2%になりました。 GPQA +9.3ポイント。AIMEは+19.8%、LiveCodeBenchは+10.0%！彼らは以前のV3チェックポイントやGPT 4.5、Claude Sonnet 3.7などのモデルと比較したプロットを提供しました。 では、6710億パラメータのモデルをどうやってローカルで動かすのでしょうか？

MoE ビット数	タイプ	ディスクサイズ	精度	リンク	詳細
1.78ビット	IQ1_S	173GB	OK	リンク	2.06/1.56ビット
1.93ビット	IQ1_M	183GB	公平	リンク	2.5/2.06/1.56
2.42ビット	IQ2_XXS	203GB	推奨	リンク	2.5/2.06ビット
2.71ビット	Q2_K_XL	231GB	推奨	リンク	3.5/2.5ビット
3.5ビット	Q3_K_XL	320GB	素晴らしい	リンク	4.5/3.5ビット
4.5ビット	Q2_K_XL（動的2ビット量子化）や	406GB	最高	リンク	5.5/4.5ビット

DeepSeek V3の元のアップロードはfloat8で、715GBかかります。Q4_K_Mを使うとファイルサイズは約404GBに半減し、我々の動的1.78ビット量子化は約151GBに収まります。 サイズと精度のバランスを取るために、我々の2.7ビット量子化を使うことを推奨します！2.4ビットのものもよく機能します！

⚙️ 公式推奨設定

によると DeepSeek、これらが推論の推奨設定です：

• Temperature（温度）0.3 （コーディングではおそらく0.0、 こちらで確認）)

• Min_Pを0.00（オプション、但し0.01がよく機能します。llama.cppのデフォルトは0.1）

• チャットテンプレート： <｜User｜>Pythonで簡単に遊べるFlappy Birdゲームを作成してください。完成したゲームはマークダウンのセクション内に配置してください。<｜Assistant｜>

• BOSトークンは <｜begin▁of▁sentence｜> トークナイゼーション時に自動的に追加されます（手動で追加しないでください！）

• DeepSeekは システムプロンプト も使用すると述べています（オプション）—それは中国語です： 该助手为DeepSeek Chat，由深度求索公司创造。\n今天是3月24日，星期一。 は次のように翻訳されます： このアシスタントはDeepSeek Chatで、DeepSeekによって作成されました。\n今日は3月24日、月曜日です。

• KVキャッシュの量子化には8ビットを使用してください。4ビットでは明らかに性能が悪いことが分かっています。

📖 チュートリアル：llama.cppでDeepSeek-V3を実行する方法

1. 最新の llama.cpp を GitHubで入手してください。以下のビルド手順にも従うことができます。を変更してください -DGGML_CUDA=ON に -DGGML_CUDA=OFF GPUを持っていない場合やCPUで推論したい場合は Apple Mac / Metalデバイスの場合、次を設定してください -DGGML_CUDA=OFF その後通常通り続行してください — Metalサポートはデフォルトで有効です。

注： -DGGML_CUDA=ON をGPU向けに使用するとコンパイルに5分かかる場合があります。CPUのみでは1分でコンパイルできます。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. モデルをダウンロードするには（をインストールした後） モデルをダウンロードするには（ を選択できます。 UD-IQ1_S（動的 1.78bit 量子化）や他の量子化バージョンのような Q4_K_M . 我々の2.7ビット動的量子化の使用を推奨します サイズと精度のバランスを取るために私たちの2.7ビット動的量子化を UD-Q2_K_XLなどがあります。さらに多くのバージョンは： 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*"], # 動的2.7ビット（230GB） 動的1.78ビット（151GB）には "*UD-IQ_S*" を使用
)

1. UnslothのFlappy Birdテストを、DeepSeek R1の1.58ビット動的量子化で説明したとおりに実行してください。

2. 編集 次の --threads 32 はCPUスレッドの数、 --ctx-size 16384 はコンテキスト長、 --n-gpu-layers 2

export LLAMA_CACHE="unsloth/GLM-4.7-GGUF"
    --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 \
    はコンテキスト長、 \
    -no-cnv \
    --fit on \
    --temp 0.3 \
    --min-p 0.01 \
    --ctx-size 4096 \
    --model unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
    --prompt "<｜User｜>PythonでFlappy Birdゲームを作成してください。以下の点を必ず含めてください:\n1. pygame を使用すること。\n2. 背景色はランダムに選択され、淡い色合いにすること。最初は薄い青色から始めること。\n3. SPACE を複数回押すと鳥が加速すること。\n4. 鳥の形状はランダムに四角形、円、三角形のいずれかにし、色はランダムに暗い色にすること。\n5. 画面下部に、ランダムに選ばれた暗い茶色または黄色の土地を配置すること。\n6. スコアを右上に表示すること。パイプを通過して当たらなかった場合に増加させること。\n7. 十分な間隔のランダムな間隔でパイプを配置すること。色はランダムに濃い緑、薄い茶色、または暗い灰色のいずれかにすること。\n8. ゲームオーバー時にベストスコアを表示すること。テキストは画面内に表示すること。q または Esc を押すとゲームを終了すること。再開は再び SPACE を押すこと。\n最終的なゲームは Python のマークダウンセクション内に入れること。コードのエラーを確認して最終マークダウンセクションの前に修正してください。<｜Assistant｜>"

上記を実行すると、非常に異なる2つの結果が得られます。 標準の2ビット版： 結果を見るにはクリック （発作注意！） 動的2ビット版： 以下に結果を示します：

標準の2ビット。背景で失敗、衝突でも失敗

動的2ビット。プレイ可能なゲームの作成に成功。

1. DeepSeek-R1と同様に、V3は61層あります。たとえば24GB GPUや80GB GPUでは、四捨五入してオフロードすると（メモリ不足になる場合は1層減らす）、次のようになります：

量子化	ファイルサイズ	24GB GPU	80GB GPU	2x80GB GPU
1.73bit	173GB	5	25	56
2.22bit	183GB	4	22	49
2.51bit	212GB	2	19	32

Mac / Apple デバイスでの実行

Apple Metalデバイスでは、次に注意してください： --n-gpu-layers。マシンがメモリ不足になる場合はこれを減らしてください。128GBの統一メモリマシンでは、およそ59層をオフロードできるはずです。

export LLAMA_CACHE="unsloth/GLM-4.7-GGUF"
    --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 \
    --model unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
    --n-gpu-layers 59 \
    -no-cnv \
    --prompt "<｜User｜>Create a Flappy Bird game in Python.<｜Assistant｜>"

🎱 ヘプタゴンテスト

我々はまた動的量子化を通じてテストします： r/Localllama そこでモデルは、移動する閉じた七角形の中で回転するボールをシミュレートする基本的な物理エンジンを作成するテストを受けます。

目標は七角形を回転させ、七角形内のボールが動くようにすることです。

export LLAMA_CACHE="unsloth/GLM-4.7-GGUF"
    --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 \
    --fit on \
    --temp 0.3 \
    --min_p 0.01 \
    --ctx-size 4096 \
    --model unsloth/GLM-4.7-GGUF/UD-Q2_K_XL/GLM-4.7-UD-Q2_K_XL-00001-of-00003.gguf \
    --prompt "<｜User｜>回転する七角形の中で20個のボールが跳ねるPythonプログラムを書いてください:\n- すべてのボールは同じ半径を持ちます。\n- すべてのボールには1から20の番号が付いています。\n- 開始時にすべてのボールは七角形の中心から落ちます。\n- 色は次の通り：#f8b862, #f6ad49, #f39800, #f08300, #ec6d51, #ee7948, #ed6d3d, #ec6800, #ec6800, #ee7800, #eb6238, #ea5506, #ea5506, #eb6101, #e49e61, #e45e32, #e17b34, #dd7a56, #db8449, #d66a35\n- ボールは重力と摩擦の影響を受け、回転する壁に対して現実的に跳ね返らなければなりません。ボール同士の衝突も必要です。\n- すべてのボールの素材により、衝突後の跳ね上がり高さは七角形の半径を超えないが、ボール半径より大きくなります。\n- すべてのボールは摩擦で回転し、ボール上の番号はボールの回転を示すのに使用できます。\n- 七角形は中心を中心に回転し、回転速度は5秒で360度です。\n- 七角形のサイズはすべてのボールを収容できる十分な大きさにしてください。\n- pygameライブラリを使用しないでください。衝突検出アルゴリズムや衝突応答などは自分で実装してください。次のPythonライブラリが許可されています：tkinter, math, numpy, dataclasses, typing, sys。\n- すべてのコードは単一のPythonファイルにまとめてください。<｜Assistant｜>"

非動的2ビット。失敗 - 発作注意 再び！

unsloth-q2_k_rotate.txt

動的2ビット。実際にヘプタゴンパズルを正しく解きます！！

unsloth-q2_k_xl_rotate.txt

元のfloat8

fp8-heptagon.txt

サイズがわずか230GBの動的2.7ビット量子化は実際にヘプタゴンパズルを解くことに成功しました！3つのバージョンすべて（完全なfp8を含む）の完全な出力は以下の通りです：

動的2ビット ヘプタゴンコード

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

# 定数
HEPTAGON_RADIUS = 300
BALL_RADIUS = 20
GRAVITY = 0.2
FRICTION = 0.99
BOUNCE_FACTOR = 0.8
ROTATION_SPEED = 360 / 5  # 秒あたりの度数
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):
        # 初期の七角形の壁を作成
        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
        
        # 経過時間を計算（概算）
        dt = 0.016  # 約60FPSと仮定
        
        # 七角形の回転を更新
        self.heptagon_angle += ROTATION_SPEED * dt
        self.update_heptagon_walls(self.heptagon_angle)
        
        # ボールを更新
        for ball in self.balls:
            # 重力を適用
            ball.vy += GRAVITY
            
            # 摩擦を適用
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            ball.spin *= SPIN_FRICTION
            
            # ボールを移動
            ball.x += ball.vx
            ball.y += ball.vy
            
            # 壁との衝突をチェック
            self.check_wall_collisions(ball)
            
            # 他のボールとの衝突をチェック
            for other in self.balls:
                if other.number != ball.number:
                    self.check_ball_collision(ball, other)
        
        # すべてを描画
        self.draw()
    
    def check_wall_collisions(self, ball):
        for wall in self.walls:
            # 壁の線分上でボールに最も近い点を見つける
            closest = self.closest_point_on_segment(
                wall.x1, wall.y1, wall.x2, wall.y2, ball.x, ball.y
            )
            
            # 壁までの距離を計算
            dx = ball.x - closest[0]
            dy = ball.y - closest[1]
            distance = math.sqrt(dx*dx + dy*dy)
            
            if distance < BALL_RADIUS:
                # 衝突検出
                # 法線ベクトルを計算
                nx = dx / distance
                ny = dy / distance
                
                # 法線方向の相対速度を計算
                v_rel = ball.vx * nx + ball.vy * ny
                
                if v_rel < 0:  # 壁に向かって移動している
                    # インパルスを計算
                    j = -(1 + BOUNCE_FACTOR) * v_rel
                    
                    # インパルスを適用
                    ball.vx += j * nx
                    ball.vy += j * ny
                    
                    # 衝突に基づく回転を追加
                    ball.spin += (ball.vx * ny - ball.vy * nx) * 0.1
                    
                    # 衝突からボールを移動させる
                    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:
            # 衝突検出
            nx = dx / distance
            ny = dy / distance
            
            # 相対速度を計算
            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:  # 互いに近づいている
                # インパルスを計算
                j = -(1 + BOUNCE_FACTOR) * v_rel / 2
                
                # インパルスを適用
                ball1.vx -= j * nx
                ball1.vy -= j * ny
                ball2.vx += j * nx
                ball2.vy += j * ny
                
                # 衝突に基づく回転を追加
                ball1.spin += (ball1.vx * ny - ball1.vy * nx) * 0.05
                ball2.spin += (ball2.vx * ny - ball2.vy * nx) * 0.05
                
                # ボールを引き離す
                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):
        # 点から線分の開始点へのベクトル
        dx = x - x1
        dy = y - y1
        
        # 線分ベクトル
        sx = x2 - x1
        sy = y2 - y1
        
        # 点の線分への射影
        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
        out = MAP_FN[fx](**json.loads(args))
            return x1 + param * sx, y1 + param * sy
    
    def draw(self):
        self.canvas.delete("all")
        
        # 七角形を描画
        points = []
        for wall in self.walls:
            points.extend([wall.x1, wall.y1])
        self.canvas.create_polygon(points, fill="", outline="black", width=2)
        
        # ボールを描画
        for ball in self.balls:
            # ボールを描画
            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"
            )
            
            # 回転に基づいて番号を描画
            angle = ball.spin * 10  # 視覚効果のために回転を拡大
            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("回転する七角形の中の跳ねるボール")
    app = BouncingBalls(root)
    root.mainloop()

非動的2ビット ヘプタゴンコード

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

# 定数
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  # 5秒で360度
SPIN_DECAY = 0.99

# ボールの色
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")
        
        # 七角形の角度を更新
        self.heptagon.angle += ROTATION_SPEED / 60  # 60FPSを仮定
        
        # 七角形を描画
        self.draw_heptagon()
        
        # ボールを更新して描画
        for ball in self.balls:
            # 重力を適用
            ball.vy += GRAVITY
            
            # 位置を更新
            ball.x += ball.vx
            ball.y += ball.vy
            
            # 摩擦を適用
            ball.vx *= FRICTION
            ball.vy *= FRICTION
            
            # 回転減衰を適用
            ball.spin *= SPIN_DECAY
            
            # 七角形の壁との衝突をチェック
            self.check_heptagon_collision(ball)
            
            # 他のボールとの衝突をチェック
            for other in self.balls:
                if other != ball:
                    if self.check_ball_collision(ball, other):
                        self.resolve_ball_collision(ball, other)
            
            # ボールを描画
            self.draw_ball(ball)
        
        self.root.after(16, self.update)  # 約60FPS
    
    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))
        
        # 七角形を描画
        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"
        )
        
        # 番号を描く
        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
        
        # 中心からの距離をチェック
        dx = ball.x - center_x
        dy = ball.y - center_y
        dist = math.sqrt(dx**2 + dy**2)
        
        if dist + ball.radius > self.heptagon.radius:
            # 中心からボールへの法線ベクトルを求める
            angle = math.atan2(dy, dx)
            normal_x = math.cos(angle)
            normal_y = math.sin(angle)
            
            # ボールを七角形の内側に戻す
            overlap = (dist + ball.radius) - self.heptagon.radius
            ball.x -= overlap * normal_x
            ball.y -= overlap * normal_y
            
            # 速度を反射
            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)
        
        # 法線ベクトル
        nx = dx / distance
        ny = dy / distance
        
        # 相対速度
        dvx = ball2.vx - ball1.vx
        dvy = ball2.vy - ball1.vy
        
        # インパルスを計算
        impulse = 2 * (dvx * nx + dvy * ny) / 2
        impulse *= ELASTICITY
        
        # インパルスを適用
        ball1.vx -= impulse * nx
        ball1.vy -= impulse * ny
        ball2.vx += impulse * nx
        ball2.vy += impulse * ny
        
        # ボールがくっつくのを防ぐために分離
        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("回転する七角形の中の跳ねるボール")
    app = BouncingBalls(root)
    app.run()

Float8 ヘプタゴンコード

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

# 定数
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  # 秒あたりの度数
ELASTICITY = 0.8
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
    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:
            # 衝突法線を計算する
            nx = dx / distance
            ny = dy / distance
            
            # 相対速度を計算
            dvx = other.vx - self.vx
            dvy = other.vy - self.vy
            
            # インパルスを計算
            impulse = 2 * (dvx * nx + dvy * ny) / (1/self.radius + 1/other.radius)
            
            # インパルスを適用
            self.vx += impulse * nx / self.radius
            self.vy += impulse * ny / self.radius
            other.vx -= impulse * nx / other.radius
            other.vy -= impulse * ny / other.radius
            
            # ボールがくっつくのを防ぐために分離する
            overlap = (self.radius + other.radius - distance) / 2
            self.x -= overlap * nx
            self.y -= overlap * ny
            other.x += overlap * nx
            other.y += overlap * ny
            
            # 回転（スピン）を一部転送する
            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):
            # すべてのボールを中心に配置し、小さなランダムな速度で開始する
            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
        
        # 七角形の各辺との衝突をチェックする
        for i in range(len(vertices)):
            p1 = vertices[i]
            p2 = vertices[(i + 1) % len(vertices)]
            
            # p1からp2へのベクトル
            edge_x = p2[0] - p1[0]
            edge_y = p2[1] - p1[1]
            edge_length = math.hypot(edge_x, edge_y)
            
            # 辺ベクトルを正規化する
            edge_x /= edge_length
            edge_y /= edge_length
            
            # 法線ベクトル（辺に対して垂直で内側を向く）
            nx = -edge_y
            ny = edge_x
            
            # p1からボールへのベクトル
            ball_to_p1_x = ball.x - p1[0]
            ball_to_p1_y = ball.y - p1[1]
            
            # ボールを辺の法線に射影する
            projection = ball_to_p1_x * nx + ball_to_p1_y * ny
            
            # 射影が負の場合、ボールは七角形の外側にある
            if projection < ball.radius:
                # 辺上でボールに最も近い点を見つける
                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
                
                # ボールと辺上の最も近い点との距離
                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:
            # 反発の応答を計算する
            dot_product = ball.vx * closest_normal[0] + ball.vy * closest_normal[1]
            
            # 反発を弾性率を用いて適用する
            ball.vx -= (1 + ELASTICITY) * dot_product * closest_normal[0]
            ball.vy -= (1 + ELASTICITY) * dot_product * closest_normal[1]
            
            # 衝撃に基づいてスピンを追加する
            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)
                # 速度と辺方向の外積
                spin_effect = (ball.vx * edge_vec[1] - ball.vy * edge_vec[0]) * 0.1
                ball.spin += spin_effect
            
            # ボールがくっつくのを防ぐために七角形の外側へ移動させる
            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
        
        # キャンバスをクリアする
        self.canvas.delete('all')
        
        # 七角形の回転を更新
        self.heptagon_angle += ROTATION_SPEED / 60  # おおよそ60FPSを想定
        
        # 七角形を描画
        vertices = self.get_heptagon_vertices()
        self.canvas.create_polygon(vertices, outline='black', fill='', width=2)
        
        # ボールを更新して描画
        for i, ball in enumerate(self.balls):
            # ボールを移動
            ball.move()
            
            # 七角形との衝突をチェック
            self.check_ball_heptagon_collision(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'
            )
            
            # 回転に基づいて番号を描画
            angle = ball.spin * 10  # 目に見える回転のためにスピンを拡大
            self.canvas.create_text(
                ball.x, ball.y,
                text=str(ball.number),
                font=('Arial', 10, 'bold'),
                angle=angle
            )
        
        # ボール同士の衝突をチェック
        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])
        
        # 次の更新をスケジュールする
        self.last_time = self.root.after(16, self.update)  # 約60FPS

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

🕵️ 追加の発見とヒント

1. 実験的テストでは、KVキャッシュの低ビット量化（4ビット）を使用すると生成品質が低下するように見えます — さらにテストが必要ですが、以下を使用することを推奨します。 q8_0 キャッシュ量子化の目的は、KVキャッシュがかなりのメモリを使用するため、より長いコンテキスト長をサポートすることです。

2. 我々は down_proj このモデルでは量子化に極めて敏感であることを発見しました。2ビットを使用していた動的量子化の一部をやり直す必要があり、これらの行列に対しては現在最小で3ビットを使用しています。 down_proj and now we use 3bits as the minimum for all these matrices.

3. 使用すると、 llama.cpp のFlash Attentionバックエンドはデコード速度をやや向上させる結果になります。コンパイル時にを使用してください。 また、 -DGGML_CUDA_FA_ALL_QUANTS=ON https://developer.nvidia.com/cuda-gpus で見つかるようにCUDAアーキテクチャを設定するのが最良です。これによりコンパイル時間を短縮し、その後以下で設定します。 -DCMAKE_CUDA_ARCHITECTURES="80" 使用する場合、

4. min_p=0.01 おそらく十分です。のデフォルトは0.1で、これはおそらく不要です。温度0.3が使用されているため、低確率トークンをサンプリングする可能性は非常に低く、非常にありそうもないトークンを除外するのは良い考えです。DeepSeekはコーディング作業に対して温度0.0を推奨します。 llama.cppdefaults to 0.1, which is probably not necessary. Since a temperature of 0.3 is used anyways, we most likely will very unlikely sample low probability tokens, so removing very unlikely tokens is a good idea. DeepSeek recommends 0.0 temperature for coding tasks.