GLM-5：ローカル実行ガイド

Z.aiの新しいGLM-5モデルを自分のローカルデバイスで実行しましょう！

GLM-5はZ.aiの最新推論モデルで、より強力なコーディング、エージェント、チャット性能を提供し GLM-4.7、また長文コンテキスト推論向けに設計されています。Humanity's Last Exam 50.4%（+7.6%）、BrowseComp 75.9%（+8.4%）、Terminal-Bench-2.0 61.1%（+28.3%）などのベンチマークで性能を向上させます。

フルの744Bパラメータ（40Bアクティブ）モデルは 200Kコンテキスト のウィンドウを持ち、28.5Tトークンで事前学習されています。フル版GLM-5モデルには 1.65TB のディスク容量が必要ですが、Unsloth Dynamic 2-bit GGUFではサイズが 241GB (-85%)に縮小され、Dynamic 1-bitは176GB（-89%）です： GLM-5-GGUF

すべてのアップロードはUnsloth Dynamic 2.0 を使用し、SOTAの量子化性能を実現しています。そのため1-bitでは重要な層が8ビットまたは16ビットにアップキャストされています。初日からUnslothにアクセスを提供してくれたZ.aiに感謝します。

⚙️ 使用ガイド

2-bit動的量子化UD-IQ2_XXSは 241GB のディスク容量を使用します。これは直接 256GB統合メモリのMacに収まり、 1×24GBカードと256GBのRAM でも、MoEオフロードで問題なく動作します。 1-bit 量子化版は180GBのRAMに収まり、8-bitには805GBのRAMが必要です。

最高のパフォーマンスを得るには、利用可能な総メモリ（VRAM + システムRAM）が、ダウンロードする量子化済みモデルファイルのサイズを上回っていることを確認してください。そうでない場合でも、llama.cppはSSD/HDDオフロードで実行できますが、推論は遅くなります。

推奨設定

用途ごとに異なる設定を使ってください：

デフォルト設定（ほとんどのタスク）	SWE Bench Verified
temperature = 1.0	temperature = 0.7
top_p = 0.95	top_p = 1.0
max new tokens = 131072	max new tokens = 16384
repeat penalty = 無効または1.0	repeat penalty = 無効または1.0

• Min_P = 0.01 (llama.cppのデフォルトは0.05です)

• 最大コンテキストウィンドウ： 202,752.

• 複数ターンのエージェント型タスク（τ²-Bench と Terminal Bench 2）では、Preserved Thinkingモードをオンにしてください。

GLM-5チュートリアルを実行：

✨ llama.cppで実行

1

最新の 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

2

を使いたい場合は llama.cpp モデルを直接読み込むには、以下のようにできます。(:IQ2_XXS) は量子化タイプです。Hugging Face（3番）経由でもダウンロードできます。これは次と似ています ollama run 。使用 export LLAMA_CACHE="folder" を強制するために llama.cpp を特定の場所に保存します。モデルの最大コンテキスト長は200Kまでであることを覚えておいてください。

これに従ってください： 一般的な指示 のユースケース：

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \\
    --ctx-size 16384 \\
    --flash-attn on \\
    --temp 0.7 \\
    --top-p 1.0 \\
    --min-p 0.01

これに従ってください： ツール呼び出し のユースケース：

export LLAMA_CACHE="unsloth/GLM-5-GGUF"
./llama.cpp/llama-cli \\
    -hf unsloth/GLM-5-GGUF:UD-IQ2_XXS \\
    --ctx-size 16384 \\
    --flash-attn on \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01

3

（次をインストール後）経由でモデルをダウンロード： pip install huggingface_hub hf_transfer ）。次から選べます UD-Q2_K_XL （動的2bit量子化）または、次のような他の量子化版 UD-Q4_K_XL 。 私たちの2bit動的量子化の使用を推奨します UD-Q2_K_XL 。サイズと精度のバランスを取るためです。ダウンロードが止まる場合は、次を参照してください： Hugging Face Hub、XETのデバッグ

pip install -U huggingface_hub
hf download unsloth/GLM-5-GGUF \\
    --local-dir unsloth/GLM-5-GGUF \\
    --include "*UD-IQ2_XXS*" # 動的1bitには"*UD-TQ1_0*"を使用

4

編集できます --threads 32 をCPUスレッド数として、 --ctx-size 16384 をコンテキスト長として、 --n-gpu-layers 2 をGPUオフロードする層数として指定します。GPUのメモリ不足が起きる場合は調整してみてください。CPUのみで推論する場合は削除してください。

./llama.cpp/llama-cli \\
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01 \\
    --ctx-size 16384 \\
    --seed 3407

🦙 Llama-serverの提供とOpenAIのcompletionライブラリ

本番環境でGLM-5を展開するには、 llama-server を使用します。新しいターミナルをtmuxなどで開き、次の方法でモデルを展開します：

./llama.cpp/llama-server \\
    --model unsloth/GLM-5-GGUF/UD-IQ2_XXS/GLM-5-UD-IQ2_XXS-00001-of-00006.gguf \\
    --alias "unsloth/GLM-5" \\
    --prio 3 \\
    --temp 1.0 \\
    --top-p 0.95 \\
    --ctx-size 16384 \\
    --port 8001

その後、新しいターミナルで、 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/GLM-5",
    messages = [{"role": "user", "content": "ヘビゲームを作ってください。"},],
)
print(completion.choices[0].message.content)

すると、次のスネークゲームの例が得られます：

これは、1つのHTMLファイルに収められた、完全にプレイ可能なスネークゲームです。このコードをコピーして `.html` ファイル（例：`snake.html`）として保存し、Webブラウザで開いて遊べます。

### コード

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>クラシックなスネークゲーム</title>
    <style>
        body {
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            margin: 0;
            background-color: #222;
            color: white;
            font-family: Arial, sans-serif;
        }

        #gameCanvas {
            border: 2px solid #fff;
            background-color: #000;
        }

        h1 {
            margin-bottom: 10px;
        }

        #scoreBoard {
            font-size: 20px;
            margin-bottom: 10px;
        }

        #gameOverMenu {
            position: absolute;
            display: none;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            background: rgba(0, 0, 0, 0.85);
            padding: 20px;
            border-radius: 10px;
            border: 2px solid red;
        }

        button {
            margin-top: 15px;
            padding: 10px 20px;
            font-size: 16px;
            cursor: pointer;
            background-color: #4CAF50;
            color: white;
            border: none;
            border-radius: 5px;
        }
        
        button:hover {
            background-color: #45a049;
        }
    </style>
</head>
<body>

    <h1>スネークゲーム</h1>
    <div id="scoreBoard">スコア: 0</div>
    <canvas id="gameCanvas" width="400" height="400"></canvas>

    <div id="gameOverMenu">
        <h2 style="color: red; margin: 0;">ゲームオーバー！</h2>
        <p id="finalScore">最終スコア: 0</p>
        <button onclick="resetGame()">もう一度プレイ</button>
    </div>

    <script>
        // ゲーム定数
        const canvas = document.getElementById('gameCanvas');
        const ctx = canvas.getContext('2d');
        const scoreBoard = document.getElementById('scoreBoard');
        const gameOverMenu = document.getElementById('gameOverMenu');
        const finalScoreDisplay = document.getElementById('finalScore');

        const gridSize = 20; // 各マスのサイズ
        const tileCount = canvas.width / gridSize; // 行/列あたりのマス数

        // ゲーム変数
        let dx = 0; // 水平方向の速度
        let dy = 0; // 垂直方向の速度
        let score = 0;
        let snake = [];
        let foodX, foodY;
        let gameInterval;
        let isGameRunning = false;

        // ゲームを初期化
        function initGame() {
            snake = [
                {x: 10, y: 10}, 
                {x: 9, y: 10}, 
                {x: 8, y: 10}
            ];
            score = 0;
            scoreBoard.innerText = 'スコア: ' + score;
            dx = 1; // すぐに右へ移動を開始
            dy = 0;
            placeFood();
            isGameRunning = true;
            gameOverMenu.style.display = 'none';
            
            // ゲームループを開始
            if (gameInterval) clearInterval(gameInterval);
            gameInterval = setInterval(gameLoop, 100); // 100msごとにゲームループを実行
        }

        // メインゲームループ
        function gameLoop() {
            if (!isGameRunning) return;

            moveSnake();
            if (checkGameOver()) {
                endGame();
                return;
            }
            checkFoodCollision();
            draw();
        }

        // スネークを移動
        function moveSnake() {
            // 現在の方向に基づいて新しい頭を作成
            const head = {x: snake[0].x + dx, y: snake[0].y + dy};
            
            // 新しい頭を配列の先頭に追加
            snake.unshift(head);

            // 食べ物を食べていない限り、しっぽ（最後の要素）を削除
            // 注：しっぽの削除はcheckFoodCollisionで処理します
            snake.pop(); 
        }

        // スネークが食べ物を食べたか確認
        function checkFoodCollision() {
            const head = snake[0];
            
            if (head.x === foodX && head.y === foodY) {
                // スネークを成長させる：しっぽの1ピースを追加する（最後の要素を複製）
                snake.push({...snake[snake.length - 1]});
                score += 10;
                scoreBoard.innerText = 'スコア: ' + score;
                placeFood();
            }
        }

        // 衝突（壁または自分自身）を確認
        function checkGameOver() {
            const head = snake[0];

            // 壁との衝突
            if (head.x < 0 || head.x >= tileCount || head.y < 0 || head.y >= tileCount) {
                return true;
            }

            // 自己衝突（頭は最初の3セグメントには当たれないので、4番目のセグメントから確認を開始）
            for (let i = 4; i < snake.length; i++) {
                if (head.x === snake[i].x && head.y === snake[i].y) {
                    return true;
                }
            }

            return false;
        }

        // すべてを描画
        function draw() {
            // キャンバスをクリア
            ctx.fillStyle = 'black';
            ctx.fillRect(0, 0, canvas.width, canvas.height);

            // 食べ物を描画
            ctx.fillStyle = 'red';
            ctx.fillRect(foodX * gridSize, foodY * gridSize, gridSize - 2, gridSize - 2);

            // スネークを描画
            ctx.fillStyle = 'lime';
            for (let i = 0; i < snake.length; i++) {
                // 頭を少し変えて描くか、標準のまま描画
                const part = snake[i];
                ctx.fillRect(part.x * gridSize, part.y * gridSize, gridSize - 2, gridSize - 2);
            }
        }

        // 食べ物をランダムな位置に配置
        function placeFood() {
            foodX = Math.floor(Math.random() * tileCount);
            foodY = Math.floor(Math.random() * tileCount);

            // 食べ物がスネークの体上に出現しないようにする
            for (let part of snake) {
                if (part.x === foodX && part.y === foodY) {
                    placeFood(); // 再帰的に新しい場所を見つける
                    return;
                }
            }
        }

        // ゲーム終了処理
        function endGame() {
            isGameRunning = false;
            clearInterval(gameInterval);
            finalScoreDisplay.innerText = '最終スコア: ' + score;
            gameOverMenu.style.display = 'flex';
        }

        // ゲームをリセット
        function resetGame() {
            initGame();
        }

        // キーボード操作
        document.addEventListener('keydown', (e) => {
            // 逆方向への移動を防止（右に進んでいるときは左に行けない）
            switch(e.key) {
                case 'ArrowUp':
                    if (dy !== 1) { dx = 0; dy = -1; }
                    break;
                case 'ArrowDown':
                    if (dy !== -1) { dx = 0; dy = 1; }
                    break;
                case 'ArrowLeft':
                    if (dx !== 1) { dx = -1; dy = 0; }
                    break;
                case 'ArrowRight':
                    if (dx !== -1) { dx = 1; dy = 0; }
                    break;
                case ' ':
                    if (!isGameRunning && gameOverMenu.style.display !== 'flex') {
                        initGame();
                    }
                    break;
            }
        });

        // 読み込み時にゲームを開始
        initGame();
    </script>
</body>
</html>
```

### 遊び方
1.  **上記のコードをコピー**してください。
2.  コンピュータ上に `snake.html` という名前の新しいファイルを作成します。
3.  そのファイルに**コードを貼り付け**て保存します。
4.  **`snake.html` をダブルクリック**してブラウザで開きます。

### 操作方法
*   **矢印キー**: 上、下、左、右に移動します。
*   **スペースバー**: まだ開始されていない場合、ゲームを開始します。
*   **再プレイボタン**: 衝突すると表示され、ゲームを再開できます。

### このバージョンの機能
*   **グリッドベースの移動**: 懐かしいレトロな雰囲気。
*   **スコア追跡**: リアルタイムで更新されます。
*   **ゲームオーバー画面**: 最終スコアを表示し、簡単に再開できます。
*   **衝突検出**: 壁や自分自身に当たるとゲームが終了します。
*   **自己衝突の安全対策**: このコードは、簡単なチュートリアルでよく見られる「テールスキッピング」ロジックにより、食べ物を食べた直後にヘビが誤って自分自身を食べてしまうのを防ぎます。

💻 vLLM のデプロイ

これで vLLM 経由で Z.ai の FP8 版モデルを提供できます。860GB 以上の VRAM が必要なため、少なくとも 8xH200（141x8 = 1128GB）を推奨します。8xB200 でも問題なく動作します。まず、vllm nightly をインストールします:

uv pip install --upgrade --force-reinstall vllm --torch-backend=auto --extra-index-url https://wheels.vllm.ai/nightly/cu130
uv pip install --upgrade --force-reinstall git+https://github.com/huggingface/transformers.git
uv pip install --force-reinstall numba

FP8 KV キャッシュを無効にするには（メモリ使用量を 50% 削減します）、次を削除します --kv-cache-dtype fp8

export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
vllm serve unsloth/GLM-5-FP8 \
    --served-model-name unsloth/GLM-5-FP8 \
    --kv-cache-dtype fp8 \
    --tensor-parallel-size 8 \
    --tool-call-parser glm47 \
    --reasoning-parser glm45 \
    --enable-auto-tool-choice \
    --dtype bfloat16 \
    --seed 3407 \
    --max-model-len 200000 \
    --gpu-memory-utilization 0.93 \
    --max_num_batched_tokens 4096 \
    --speculative-config.method mtp \
    --speculative-config.num_speculative_tokens 1 \
    --port 8001

その後、OpenAI API 経由で提供中のモデルを呼び出せます:

from openai import AsyncOpenAI, OpenAI
openai_api_key = "EMPTY"
openai_api_base = "http://localhost:8001/v1"
client = OpenAI( # または AsyncOpenAI
    api_key = openai_api_key,
    base_url = openai_api_base,
)

🔨GLM 5 でのツール呼び出し

参照 Tool Calling Guide ツール呼び出しの詳細については、こちらを参照してください。新しいターミナルで（tmux を使っている場合は CTRL+B+D を使用）、2つの数を足す、Python コードを実行する、Linux コマンドを実行するなど、いくつかのツールを作成します:

import json, subprocess, random
from typing import Any
def add_number(a: float | str, b: float | str) -> float:
    return float(a) + float(b)
def multiply_number(a: float | str, b: float | str) -> float:
    return float(a) * float(b)
def subtract_number(a: float | str, b: float | str) -> float:
    return float(a) - float(b)
def write_a_story() -> str:
    return random.choice([
        "はるか遠い銀河系の昔々...",
        "ナマケモノとコードを愛する2人の友人がいました...",
        "すべてのナマケモノが超人的な知能を持つよう進化したため、世界は終わりを迎えようとしていました...",
        "ある友人には知られていませんでしたが、もう一人の友人は誤ってナマケモノを進化させるプログラムを書いてしまっていました...",
    ])
def terminal(command: str) -> str:
    if "rm" in command or "sudo" in command or "dd" in command or "chmod" in command:
        msg = "危険なため、'rm, sudo, dd, chmod' コマンドは実行できません"
        print(msg); return msg
    print(f"ターミナルコマンド `{command}` を実行しています")
    try:
        return str(subprocess.run(command, capture_output = True, text = True, shell = True, check = True).stdout)
    except subprocess.CalledProcessError as e:
        return f"コマンド失敗: {e.stderr}"
def python(code: str) -> str:
    data = {}
    exec(code, data)
    del data["__builtins__"]
    return str(data)
MAP_FN = {
    "add_number": add_number,
    "multiply_number": multiply_number,
    "subtract_number": subtract_number,
    "write_a_story": write_a_story,
    "terminal": terminal,
    "python": python,
}
tools = [
    {
        "type": "function",
        "function": {
            "name": "add_number",
            "description": "2つの数を足します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "multiply_number",
            "description": "2つの数を掛けます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "subtract_number",
            "description": "2つの数を引きます。",
            "parameters": {
                "type": "object",
                "properties": {
                    "a": {
                        "type": "string",
                        "description": "最初の数。",
                    },
                    "b": {
                        "type": "string",
                        "description": "2番目の数。",
                    },
                },
                "required": ["a", "b"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "write_a_story",
            "description": "ランダムな物語を書きます。",
            "parameters": {
                "type": "object",
                "properties": {},
                "required": [],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "terminal",
            "description": "ターミナルから操作を実行します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "実行したいコマンド。例: `ls`, `rm`, ...",
                    },
                },
                "required": ["command"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "python",
            "description": "実行する Python コードを使って Python インタープリターを呼び出します。",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {
                        "type": "string",
                        "description": "実行する Python コード",
                    },
                },
                "required": ["code"],
            },
        },
    },
]

次に、以下の関数（コピーして貼り付けて実行）を使用します。これにより関数呼び出しが自動的に解析され、どのモデルに対しても OpenAI エンドポイントが呼び出されます:

from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = -1,
    min_p = 0.01,
    repetition_penalty = 1.0,
):
    messages = messages.copy()
    openai_client = OpenAI(
        base_url = "http://127.0.0.1:8001/v1",
        api_key = "sk-no-key-required",
    )
    model_name = next(iter(openai_client.models.list())).id
    print(f"使用中のモデル = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"現在のメッセージ = {messages}")
        response = openai_client.chat.completions.create(
            model = model_name,
            messages = messages,
            temperature = temperature,
            top_p = top_p,
            tools = tools if tools else None,
            tool_choice = "auto" if tools else None,
            extra_body = {"top_k": top_k, "min_p": min_p, "repetition_penalty" :repetition_penalty,}
        )
        tool_calls = response.choices[0].message.tool_calls or []
        content = response.choices[0].message.content or ""
        tool_calls_dict = [tc.to_dict() for tc in tool_calls] if tool_calls else tool_calls
        messages.append({"role": "assistant", "tool_calls": tool_calls_dict, "content": content,})
        for tool_call in tool_calls:
            fx, args, _id = tool_call.function.name, tool_call.function.arguments, tool_call.id
            out = MAP_FN[fx](**json.loads(args))
            messages.append({"role": "tool", "tool_call_id": _id, "name": fx, "content": str(out),})
        else:
            has_tool_calls = False
    return messages

GLM 5 を次の方法で起動した後 llama-server のように GLM-5 または Tool Calling Guide 詳細については、いくつかのツール呼び出しを行えます。

📊 ベンチマーク

ベンチマークは下の表形式でも確認できます:

ベンチマーク	GLM-5	GLM-4.7	DeepSeek-V3.2	Kimi K2.5	Claude Opus 4.5	Gemini 3 Pro	GPT-5.2 (xhigh)
HLE	30.5	24.8	25.1	31.5	28.4	37.2	35.4
HLE（ツールあり）	50.4	42.8	40.8	51.8	43.4*	45.8*	45.5*
AIME 2026 I	92.7	92.9	92.7	92.5	93.3	90.6	-
HMMT 2025年11月	96.9	93.5	90.2	91.1	91.7	93.0	97.1
IMOAnswerBench	82.5	82.0	78.3	81.8	78.5	83.3	86.3
GPQA-Diamond	86.0	85.7	82.4	87.6	87.0	91.9	92.4
SWE-bench Verified	77.8	73.8	73.1	76.8	80.9	76.2	80.0
SWE-bench Multilingual	73.3	66.7	70.2	73.0	77.5	65.0	72.0
Terminal-Bench 2.0 (Terminus 2)	56.2 / 60.7 †	41.0	39.3	50.8	59.3	54.2	54.0
Terminal-Bench 2.0 (Claude Code)	56.2 / 61.1 †	32.8	46.4	-	57.9	-	-
CyberGym	43.2	23.5	17.3	41.3	50.6	39.9	-
BrowseComp	62.0	52.0	51.4	60.6	37.0	37.8	-
BrowseComp（コンテキスト管理あり）	75.9	67.5	67.6	74.9	67.8	59.2	65.8
BrowseComp-Zh	72.7	66.6	65.0	62.3	62.4	66.8	76.1
τ²-Bench	89.7	87.4	85.3	80.2	91.6	90.7	85.5
MCP-Atlas (Public Set)	67.8	52.0	62.2	63.8	65.2	66.6	68.0
Tool-Decathlon	38.0	23.8	35.2	27.8	43.5	36.4	46.3
Vending Bench 2	$4,432.12	$2,376.82	$1,034.00	$1,198.46	$4,967.06	$5,478.16	$3,591.33