🥝Kimi K2.5：如何本地运行指南

在你自己的本地设备上运行 Kimi-K2.5 的指南！

Kimi-K2.5 是 Moonshot 推出的新模型，在视觉、编码、智能体和聊天任务上实现了 SOTA 性能。这个 1T 参数的混合推理模型需要 600GB 磁盘空间，而量化版 Unsloth Dynamic 1.8-bit 则将其缩减到 240GB（-60% 大小）: Kimi-K2.5-GGUF

所有上传都使用 Unsloth Dynamic 2.0 用于 SOTA 的 Aider 和 5-shot MMLU 表现。看看我们的动态 1–2 bit GGUF 在编码基准.

⚙️ 推荐配置要求

你需要 >240GB 磁盘空间 才能运行 1-bit 量化版！

为了获得最佳性能，请确保你的可用总内存（VRAM + 系统内存）大于你正在下载的量化模型文件大小。如果不足，llama.cpp 仍可通过 SSD/HDD 卸载运行，但推理会更慢。

1.8-bit（UD-TQ1_0）量化版在你将所有 MoE 层卸载到系统 RAM（或快速 SSD）时，可在单张 24GB GPU 上运行。使用约 256GB RAM 时，预计约 10 tokens/s。完整的 Kimi K2.5 模型为 630GB，通常至少需要 4× H200 GPU。

如果模型能放得下，使用 B200 时你将获得 >40 tokens/s。

要以接近 满精度运行模型，你可以使用 4-bit 或 5-bit 量化。为了保险，也可以使用任何更高的量化。

若要获得强劲性能，建议拥有 >240GB 统一内存（或合计 RAM+VRAM），以达到 10+ tokens/s。低于此配置也能运行，但速度会下降（llama.cpp 仍可通过 mmap/磁盘卸载运行），并可能从约 10 tokens/s 降至 <2 token/s。

我们推荐 UD-Q2_K_XL（375GB），作为尺寸/质量平衡较好的选择。最佳经验法则：RAM+VRAM ≈ 量化大小；否则仍能运行，只是因为卸载而更慢。

🥝 运行 Kimi K2.5 指南

Kimi-K2.5 针对不同使用场景需要不同的采样参数。

目前有 没有视觉支持 适用于该模型，但希望 llama.cpp 很快能支持它。

要以全精度运行该模型，你只需使用 4-bit 或 5-bit Dynamic GGUFs（例如 UD_Q4_K_XL），因为该模型最初以 INT4 格式发布。

你也可以选择更高位宽的量化以防万一量化差异较小，但在大多数情况下这是不必要的。

🌙 使用指南：

根据 Moonshot AI 的说法，以下是 Kimi K2.5 推理的推荐设置：

默认设置（即时模式）

思考模式

temperature = 0.6

temperature = 1.0

top_p = 0.95

min_p = 0.01

将 temperature 1.0 设为较低值，以减少重复和不连贯。
建议上下文长度 = 98,304（最高可达 256K）
注意：使用不同工具可能需要不同设置

我们建议将 min_p 设为 0.01 用于抑制出现概率较低的不太可能 token。以及 关闭或将 repeat penalty 设为 1.0 （如有需要）。

Kimi K2.5 的聊天模板

运行 tokenizer.apply_chat_template([{"role": "user", "content": "1+1 等于多少？"},]) 得到：

<|im_system|>system<|im_middle|>你是 Kimi，一位由 Moonshot AI 创建的 AI 助手。<|im_end|><|im_user|>user<|im_middle|>1+1 等于多少？<|im_end|><|im_assistant|>assistant<|im_middle|><think>

🦥 在 Unsloth Studio 中运行 Kimi-K2.5

Kimi-K2.5 可以在 Unsloth Studio，这是我们新的本地 AI 开源 Web UI。借助 Unsloth Studio，你可以在以下平台本地运行模型 MacOS、Windows、Linux 以及：

搜索、下载、运行 GGUF 和 safetensor 模型
自修复 工具调用 + 网页搜索
代码执行 （Python、Bash）
自动推理参数调优（温度、top-p 等）
通过 llama.cpp 实现快速 CPU + GPU 推理
训练 LLM 速度快 2 倍，VRAM 占用减少 70%

安装 Unsloth

在你的终端中运行：

MacOS、Linux、WSL：

curl -fsSL https://unsloth.ai/install.sh | sh

Windows PowerShell：

irm https://unsloth.ai/install.ps1 | iex

安装会很快，约需 1-2 分钟。

启动 Unsloth

MacOS、Linux、WSL 和 Windows：

unsloth studio -H 0.0.0.0 -p 8888

然后打开 http://localhost:8888 在你的浏览器中。

搜索并下载 Kimi-K2.5

首次启动时，你需要创建一个密码来保护你的账户，并在稍后再次登录。随后你会看到一个简短的新手引导向导，用于选择模型、数据集和基本设置。你可以随时跳过，直接进入聊天。

然后前往 Unsloth Chat 标签页并搜索 Kimi-K2.5 ，然后在搜索栏中下载你想要的模型和量化版本。请确保你有足够的算力来运行该模型。

运行 Kimi-K2.5

在使用 Unsloth Studio 时，推理参数应自动设置，不过你仍然可以手动更改。你也可以编辑上下文长度、聊天模板和其他设置。

更多信息请查看我们的 Unsloth Studio 推理指南.

✨ 在 llama.cpp 中运行 Kimi K2.5

在本指南中，我们将运行最小的 1-bit 量化版，它的大小为 240GB。你可以自由将量化类型改为 2-bit、3-bit 等。要以接近 满精度运行模型，你可以使用 4-bit 或 5-bit 量化。为了保险，也可以使用任何更高的量化。

获取最新的 llama.cpp 在 GitHub 上获取。你也可以按照下面的构建说明进行操作。将 -DGGML_CUDA=ON 改为 -DGGML_CUDA=OFF 如果你没有 GPU，或者只想使用 CPU 推理。 对于 Apple Mac / Metal 设备，设置 -DGGML_CUDA=OFF 然后按常规继续——Metal 支持默认开启。

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
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-mtmd-cli llama-server llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp

如果你想使用 llama.cpp 直接加载模型，你可以这样做：（:UD-TQ1_0）是量化类型。你也可以通过 Hugging Face（第 3 点）下载。这与以下方式类似： ollama run 。使用 export LLAMA_CACHE="folder" 来强制 llama.cpp 保存到特定位置。

LLAMA_SET_ROWS=1 会让 llama.cpp 稍微更快一点！用上它！ --fit on 会自动以最优方式将模型适配到你的所有 GPU 和 CPU 上。

export LLAMA_CACHE="unsloth/Kimi-K2.5-GGUF"
LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    -hf unsloth/Kimi-K2.5-GGUF:UD-TQ1_0\\
    --temp 1.0 \\
    --min-p 0.01 \
    --top-p 0.95 \\
    --ctx-size 16384 \
    --seed 3407

--fit on 会自动将模型适配到你的系统。如果不使用 --fit on 并且你大约有 360GB 的 GPU 总内存，请移除 -ot ".ffn_.*_exps.=CPU" 以获得最大速度。

使用 --fit on 用于在 GPU 和 CPU 上自动适配。如果这不起作用，请看下面：

请试试 -ot ".ffn_.*_exps.=CPU" 将所有 MoE 层卸载到 CPU！这实际上让你可以把所有非 MoE 层放到 1 张 GPU 上，从而提升生成速度。如果你有更多 GPU 容量，还可以自定义正则表达式以容纳更多层。

如果你有更多一点 GPU 内存，可以尝试 -ot ".ffn_(up|down)_exps.=CPU" 这会卸载上投影和下投影 MoE 层。

尝试 -ot ".ffn_(up)_exps.=CPU" 如果你有更多 GPU 内存。这只会卸载上投影 MoE 层。

最后通过以下方式卸载所有层： -ot ".ffn_.*_exps.=CPU" 这会使用最少的 VRAM。

你也可以自定义正则表达式，例如 -ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU" 表示从第 6 层开始，只卸载 gate、up 和 down MoE 层。

通过以下方式下载模型（在安装 pip install huggingface_hub hf_transfer ）。我们建议使用我们的 2bit 动态量化 UD-Q2_K_XL 来平衡大小和精度。所有版本见： huggingface.co/unsloth/Kimi-K2.5-GGUF 如果下载卡住，请查看 Hugging Face Hub、XET 调试

pip install -U huggingface_hub
hf download unsloth/Kimi-K2.5-GGUF \\
    --local-dir unsloth/Kimi-K2.5-GGUF \\
    --include "*UD-TQ1_0*" # 动态 2bit 请使用 "*UD-Q2_K_XL*"

如果你发现下载卡在 90% 到 95% 左右，请查看我们的故障排查指南.

运行任意提示词。
编辑 --ctx-size 16384 用于上下文长度。你也可以将其省略，以便通过 --fit on

LLAMA_SET_ROWS=1 ./llama.cpp/llama-cli \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --temp 1.0 \\
    --min-p 0.01 \
    --top-p 0.95 \\
    --ctx-size 16384 \
    --seed 3407

例如试试："创建一个 HTML 中的 Flappy Bird 游戏"，你会得到：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            background: #222;
            display: flex;
            justify-content: center;
            align-items: center;
            height: 100vh;
            font-family: 'Segoe UI', sans-serif;
            overflow: hidden;
            touch-action: none;
        }
        
        #game-container {
            position: relative;
            width: 400px;
            height: 600px;
            background: linear-gradient(to bottom, #70c5ce 0%, #70c5ce 80%, #c23810 80%, #c23810 100%);
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
            overflow: hidden;
        }
        
        canvas {
            display: block;
        }
        
        .overlay {
            position: absolute;
            top: 50%;
            left: 50%;
            transform: translate(-50%, -50%);
            text-align: center;
            color: white;
            text-shadow: 2px 2px 0 #000;
            font-weight: bold;
            pointer-events: none;
        }
        
        .game-title {
            font-size: 48px;
            margin-bottom: 20px;
        }
        
        .score-display {
            font-size: 36px;
            margin-bottom: 10px;
        }
        
        .best-score {
            font-size: 24px;
            color: #ffe;
        }
        
        .instruction {
            font-size: 20px;
            animation: pulse 1s infinite;
        }
        
        @keyframes pulse {
            0%, 100% { opacity: 1; }
            50% { opacity: 0.5; }
        }
        
        .hidden { display: none; }
    </style>
</head>
<body>
    <div id="game-container">
        <canvas id="canvas" width="400" height="600"></canvas>
        
        <!-- 开始屏幕 -->
        <div id="start-screen" class="overlay">
            <div class="game-title">FLAPPY BIRD</div>
            <div class="instruction">点击或按空格键起飞</div>
        </div>
        
        <!-- 游戏结束屏幕 -->
        <div id="game-over-screen" class="overlay hidden">
            <div class="game-title">游戏结束</div>
            <div class="score-display">得分：<span id="final-score">0</span></div>
            <div class="best-score">最佳：<span id="best-score">0</span></div>
            <div class="instruction">点击重新开始</div>
        </div>
        
        <!-- 分数计数器 -->
        <div id="current-score" class="overlay hidden" style="top: 10%; font-size: 72px; color: white; text-shadow: 4px 4px 0 #000;">
            0
        </div>
    </div>

    <script>
        const canvas = document.getElementById('canvas');
        const ctx = canvas.getContext('2d');
        
        // 游戏常量
        const GRAVITY = 0.4;
        const JUMP_STRENGTH = -7;
        const PIPE_SPEED = 3;
        const PIPE_SPAWN_RATE = 120; // 帧
        const PIPE_GAP = 120;
        
        // 游戏状态
        let bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
        let pipes = [];
        let score = 0;
        let bestScore = localStorage.getItem('flappyBest') || 0;
        let frameCount = 0;
        let isGameOver = false;
        let isPlaying = false;
        
        // DOM 元素
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const currentScoreDisplay = document.getElementById('current-score');
        const finalScoreEl = document.getElementById('final-score');
        const bestScoreEl = document.getElementById('best-score');
        
        // 输入处理
        function handleInput(e) {
            if (!isPlaying) {
                if (isGameOver) {
                    resetGame();
                }
                startGame();
            } else if (!isGameOver) {
                bird.velocity = JUMP_STRENGTH;
                bird.wingState = 1;
            }
        }
        
        document.addEventListener('keydown', (e) => {
            if (e.code === 'Space' || e.code === 'ArrowUp') handleInput(e);
        });
        canvas.addEventListener('pointerdown', handleInput);
        
        function startGame() {
            isPlaying = true;
            isGameOver = false;
            startScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function resetGameState() {
            bird = { x: 50, y: 200, velocity: 0, radius: 15, wingState: 0 };
            pipes = [];
            score = 0;
            frameCount = 0;
            currentScoreDisplay.textContent = score;
        }
        
        function resetGame() {
            isGameOver = false;
            isPlaying = true;
            gameOverScreen.classList.add('hidden');
            currentScoreDisplay.classList.remove('hidden');
            resetGameState();
            gameLoop();
        }
        
        function spawnPipe() {
            const minHeight = 100;
            const maxHeight = 400;
            const topHeight = Math.floor(Math.random() * (maxHeight - minHeight + 1) + minHeight);
            const bottomHeight = canvas.height - topHeight - PIPE_GAP;
            
            pipes.push({
                x: canvas.width,
                topHeight: topHeight,
                bottomY: topHeight + PIPE_GAP,
                bottomHeight: bottomHeight,
                passed: false
            });
        }
        
        function update() {
            if (isGameOver) return;
            
            // 小鸟物理
            bird.velocity += GRAVITY;
            bird.y += bird.velocity;
            
            // 地板/天花板碰撞
            if (bird.y + bird.radius > canvas.height || bird.y - bird.radius < 0) {
                gameOver();
                return;
            }
            
            // 管道生成
            frameCount++;
            if (frameCount % PIPE_SPAWN_RATE === 0) {
                spawnPipe();
            }
            
            // 管道移动和碰撞
            for (let i = pipes.length - 1; i >= 0; i--) {
                const pipe = pipes[i];
                pipe.x -= PIPE_SPEED;
                
                // 移除屏幕外的管道
                if (pipe.x + 60 < 0) {
                    pipes.splice(i, 1);
                    continue;
                }
                
                // 碰撞检测（简化的矩形-圆形）
                const pipeWidth = 60;
                const pipeX = pipe.x;
                const pipeLeft = pipeX;
                const pipeRight = pipeX + pipeWidth;
                
                // 小鸟是圆形，管道是矩形
                const birdLeft = bird.x - bird.radius + 4; // 喙部偏移 +4
                const birdRight = bird.x + bird.radius + 2;
                const birdTop = bird.y - bird.radius;
                const birdBottom = bird.y + bird.radius;
                
                // 水平碰撞检查
                if (birdRight > pipeLeft && birdLeft < pipeRight) {
                    // 上方管道碰撞
                    if (birdTop < pipe.topHeight) {
                        gameOver();
                        return;
                    }
                    // 下方管道碰撞
                    if (birdBottom > pipe.bottomY) {
                        gameOver();
                        return;
                    }
                }
                
                // 计分
                if (pipe.x + pipeWidth < bird.x && !pipe.passued) {
                    pipe.passed = true;
                    score++;
                    currentScoreDisplay.textContent = score;
                }
            }
            
            // 翅膀动画
            if (bird.wingState > 0) {
                bird.wingState = (bird.wingState + 0.2) % 2;
            }
        }
        
        function draw() {
            // 清空画布
            ctx.clearRect(0, 0, canvas.width, canvas.height);
            
            // 绘制管道
            pipes.forEach(pipe => {
                // 上管道
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, 0, 60, pipe.topHeight);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.topHeight - 20, 60, 20); // 管帽
                
                // 下管道
                ctx.fillStyle = '#46c';
                ctx.fillRect(pipe.x, pipe.bottomY, 60, canvas.height - pipe.bottomY);
                ctx.fillStyle = '#34a';
                ctx.fillRect(pipe.x, pipe.bottomY - 20, 60, 20); // 管帽
            });
            
            // 绘制小鸟（带喙的圆形）
            ctx.fillStyle = '#e3bc4e';
            ctx.beginPath();
            ctx.arc(bird.x, bird.y, bird.radius, 0, Math.PI * 2);
            ctx.fill();
            
            // 喙
            ctx.fillStyle = '#e04c4c';
            ctx.beginPath();
            ctx.moveTo(bird.x + bird.radius - 4, bird.y - 4);
            ctx.lineTo(bird.x + bird.radius + 10, bird.y);
            ctx.lineTo(bird.x + bird.radius - 4, bird.y + 4);
            ctx.fill();
            
            // 眼睛
            ctx.fillStyle = 'black';
            ctx.beginPath();
            ctx.arc(bird.x + 5, bird.y - 6, 3, 0, Math.PI * 2);
            ctx.fill();
            
            // 翅膀
            ctx.fillStyle = '#c4a';
            ctx.beginPath();
            ctx.ellipse(bird.x - 5, bird.y + 5, 10, 6, 0, 0, Math.PI * 2);
            ctx.fill();
        }
        
        function gameOver() {
            isGameOver = true;
            isPlaying = false;
            
            // 更新最高分
            if (score > bestScore) {
                bestScore = score;
                localStorage.setItem('flappyBest', bestScore);
            }
            
            // 显示游戏结束界面
            currentScoreDisplay.classList.add('hidden');
            gameOverScreen.classList.remove('hidden');
            finalScoreEl.textContent = score;
            bestScoreEl.textContent = bestScore;
        }
        
        function gameLoop() {
            if (!isPlaying) return;
            
            update();
            draw();
            requestAnimationFrame(gameLoop);
        }
        
        // 初始绘制
        draw();
    </script>
</body>
</html>

✨ 使用 llama-server 和 OpenAI 的 completion 库进行部署

使用 --kv-unified 可以让 llama.cpp 中的推理服务更快！参见 https://www.reddit.com/r/LocalLLaMA/comments/1qnwa33/glm_47_flash_huge_performance_improvement_with_kvu/

按照 Kimi K2.5安装 llama.cpp 后，你可以使用下面的命令启动一个兼容 OpenAI 的服务器：

LLAMA_SET_ROWS=1 ./llama.cpp/llama-server \\
    --model unsloth/Kimi-K2.5-GGUF/UD-TQ1_0/Kimi-K2.5-UD-TQ1_0-00001-of-00005.gguf \\
    --special \\
    --alias "unsloth/Kimi-K2.5" \\
    --min-p 0.01 \
    --ctx-size 16384 \
    --port 8001 \\
    --kv-unified

然后使用 OpenAI 的 Python 库 pip install openai :

from openai import OpenAI
import json
openai_client = OpenAI(
    base_url = "http://127.0.0.1:8001/v1",
    api_key = "sk-no-key-required",
)
completion = openai_client.chat.completions.create(
    model = "unsloth/Kimi-K2.5",
    messages = [{"role": "user", "content": "1+1 等于多少？"},],
)
print(completion.choices[0].message.content)

然后我们得到：

而在另一个 llama-server 窗口中：

📊 基准测试

你可以在下方以表格形式查看更多基准测试：

推理与知识

基准

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

HLE-Full

30.1

34.5

30.8

37.5

25.1†

HLE-Full（含工具）

50.2

45.5

43.2

45.8

40.8†

AIME 2025

96.1

100

92.8

95.0

93.1

HMMT 2025（2月）

95.4

99.4

92.9*

97.3*

92.5

IMO-AnswerBench

81.8

86.3

78.5*

83.1*

78.3

GPQA-Diamond

87.6

92.4

87.0

91.9

82.4

MMLU-Pro

87.1

86.7*

89.3*

90.1

85.0

图像与视频

基准

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

MMMU-Pro

78.5

79.5*

74.0

81.0

69.3

CharXiv (RQ)

77.5

82.1

67.2*

81.4

66.1

MathVision

84.2

83.0

77.1*

86.1*

74.6

MathVista（迷你版）

90.1

82.8*

80.2*

89.8*

85.8

ZeroBench

ZeroBench（含工具）

12*

OCRBench

92.3

80.7*

86.5*

90.3*

87.5

OmniDocBench 1.5

88.8

85.7

87.7*

88.5

82.0*

InfoVQA（验证集）

92.6

84*

76.9*

57.2*

89.5

SimpleVQA

71.2

55.8*

69.7*

56.8*

WorldVQA

46.3

28.0

36.8

47.4

23.5

VideoMMMU

86.6

85.9

84.4*

87.6

80.0

MMVU

80.4

80.8*

77.3

77.5

71.1

MotionBench

70.4

64.8

60.3

70.3

VideoMME

87.4

86.0*

88.4*

79.0

LongVideoBench

79.8

76.5*

67.2*

77.7*

65.6*

LVBench

75.9

73.5*

63.6

编码

基准

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

SWE-Bench 已验证

76.8

80.0

80.9

76.2

73.1

SWE-Bench Pro

50.7

55.6

55.4*

SWE-Bench 多语言

73.0

72.0

77.5

65.0

70.2

终端基准 2.0

50.8

54.0

59.3

54.2

46.4

PaperBench

63.5

63.7*

72.9*

47.1

CyberGym

41.3

50.6

39.9*

17.3*

SciCode

48.7

52.1

49.5

56.1

38.9

OJBench (cpp)

57.4

54.6*

68.5*

54.7*

LiveCodeBench（v6）

85.0

82.2*

87.4*

83.3

长上下文

基准

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

Longbench v2

61.0

54.5*

64.4*

68.2*

59.8*

AA-LCR

70.0

72.3*

71.3*

65.3*

64.3*

智能体搜索

基准

Kimi K2.5

GPT-5.2

Claude 4.5 Opus

Gemini 3 Pro

DeepSeek V3.2

Qwen3-VL-235B-A22B-Thinking

BrowseComp

60.6

65.8

37.0

37.8

51.4

BrowseComp（含上下文管理）

74.9

65.8

57.8

59.2

67.6

BrowseComp（智能体群）

78.4

WideSearch（item-f1）

72.7

76.2*

57.0

32.5*

WideSearch（item-f1 智能体群）

79.0

DeepSearchQA

77.1

71.3*

76.1*

63.2*

60.9*

FinSearchCompT2&T3

67.8

66.2*

49.9

59.1*

Seal-0

57.4

45.0

47.7*

45.5*

49.5*

说明

* = 分数由作者重新评估（此前未公开）。
† = DeepSeek V3.2 的分数对应其仅文本子集（如脚注所述）。
- = 未评估 / 不可用。

上一页GLM-5

下一页GLM-4.7-Flash

最后更新于 2个月前

这有帮助吗？