🐳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

了解

リンク

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ビット

Q4_K_XL

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キャッシュの量子化には8bitを使用してください。4bitはかなり性能が悪くなることがわかっています。

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

最新の llama.cpp を GitHub で入手できます。下のビルド手順に従うこともできます。変更してください -DGGML_CUDA=ON から -DGGML_CUDA=OFF GPU がない場合や CPU 推論のみを行いたい場合は。

注意：GPU向けに -DGGML_CUDA=ON を使用するとコンパイルに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

（以下をインストールした後に）モデルをダウンロードします pip install huggingface_hub hf_transfer ）。量子化バージョンとして選べます UD-IQ1_S（ダイナミック1.78bit量子化）や他の量子化バージョンのような Q4_K_M . 我々の動的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*"を使用
)

DeepSeek R1向けの1.58ビット動的量子化で説明したように、UnslothのFlappy Birdテストを実行してください。
編集 --threads 32 でCPUスレッド数を編集できます、 --ctx-size 16384 でコンテキスト長を、 --n-gpu-layers 2 で何層をGPUにオフロードするかを指定します。GPUがメモリ不足になる場合は調整してみてください。CPUのみの推論の場合はこれを削除してください。

./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｜>"

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

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

DeepSeek-R1と同様に、V3は61層あります。例えば24GB GPUや80GB GPUでは、切り下げ後にオフロードできることが期待できます（メモリ不足になる場合は1層減らしてください）：

量子化

ファイルサイズ

24GB GPU

80GB GPU

2x80GB GPU

1.73bit

173GB

2.22bit

183GB

2.51bit

212GB

Mac / Apple デバイスでの実行

Apple Metal デバイスでは --n-gpu-layers に注意してください。マシンがメモリ不足になる場合は減らしてください。128GB ユニファイドメモリのマシンなら約59レイヤーをオフロードできるはずです。

./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テストで試すこともできます、 r/Localllama

./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｜>回転する七角形の中で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
PRINTER = 0  # デバッグのために時々出力する
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
    
    すぐに人気となり、現在では業界標準となり、ほとんどのトレーニングパッケージに統合されています。これはアクティベーションをCPU RAMにオフロードし、コンテキスト長を10倍にすることを可能にしました。我々の新しい拡張はCUDAストリームやその他の工夫を用い、精度に影響を与えずに最大で
    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
        scores.append(2.0)   # 動作したが2048には到達しなかった
            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
PRINTER = 0  # デバッグのために時々出力する
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('回転する七角形内のバウンドするボール')
    simulator = HeptagonBounceSimulator(root)
    root.mainloop()

🕵️ 追加の発見とヒント

経験的なテストでは、KVキャッシュ量子化を低いビット（4ビット）にすると生成品質が低下するように見えました — さらなるテストが必要ですが、我々は以下の使用を推奨します q8_0 キャッシュ量子化。量子化の目的は、KVキャッシュがかなりのメモリを使用するため、より長いコンテキスト長をサポートすることです。
我々は down_proj このモデルにおいて量子化に非常に敏感であることを発見しました。いくつかの動的量子化をやり直す必要があり、2ビットを使っていたものを down_proj として、これらの行列すべてに対して最小で3ビットを使用するようにしました。
使用すると、 llama.cpp のFlash Attentionバックエンドはデコード速度がやや速くなる結果となります。コンパイル時には -DGGML_CUDA_FA_ALL_QUANTS=ON を使用してください。また、CUDAアーキテクチャは次の場所で確認したものを設定するのが最良です https://developer.nvidia.com/cuda-gpus コンパイル時間を短縮するために、それから次のように設定します -DCMAKE_CUDA_ARCHITECTURES="80"
使用する min_p=0.01で十分でしょう。 llama.cppデフォルトは0.1で、おそらく必要ありません。温度が0.3に設定されているため、低確率トークンをサンプリングする可能性は非常に低く、非常にあり得ないトークンを除去するのは良い考えです。DeepSeekはコーディングタスクには温度0.0を推奨しています。

前へRun Unsloth models in Docker 次へDeepSeek-R1

最終更新 1 か月前

役に立ちましたか？

hashtag⚙️ 公式推奨設定

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

hashtagMac / Apple デバイスでの実行

hashtag🎱 ヘプタグオン（七角形）テスト

hashtag🕵️ 追加の発見とヒント

⚙️ 公式推奨設定

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

Mac / Apple デバイスでの実行

🎱 ヘプタグオン（七角形）テスト

🕵️ 追加の発見とヒント