> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/jp/moderu/qwen3-coder-next.md).

# Qwen3-Coder-Next: ローカルでの実行方法

Qwen が Qwen3-Coder-Next をリリース。80B の MoE モデル（有効パラメータ 3B）で、 **256K コンテキスト** 高速なエージェント型コーディングとローカル利用向けです。10〜20倍多い有効パラメータを持つモデルに匹敵する性能です。

これは次の環境で動作します **46GB の RAM**/VRAM/統合メモリ（8-bit では 85GB）で動作し、超高速なコード応答向けの非推論モデルです。このモデルは、長期的な推論、複雑なツール使用、実行失敗からの回復に優れています。

{% hint style="success" %}
**2月19日更新**： llama.cpp のパース修正後、ツール呼び出しはさらに改善されているはずです。

**新着！** 参照: [量子化ベンチマーク](#gguf-quantization-benchmarks) Dynamic GGUF 向け！

**2月4日：** `llama.cpp` の計算を修正するバグを修正しました `ベクトル化された key_gdiff。` これにより以前のループや出力の問題が修正されます。GGUF を更新しました。ぜひ **再ダウンロードしてください** および **更新** `llama.cpp` より良い出力のために。
{% endhint %}

また、Codex と Claude Code でモデルを実行する方法も学べます。 **ファインチューニング**、Qwen3-Next-Coder は Unsloth で bf16 LoRA を行う場合、B200 GPU 1枚に収まります。

Qwen3-Coder-Next Unsloth [Dynamic GGUF](/docs/jp/ji-ben/unsloth-dynamic-2.0-ggufs.md) 実行するには： [unsloth/Qwen3-Coder-Next-GGUF](https://huggingface.co/unsloth/Qwen3-Coder-Next-GGUF)

<a href="/pages/983a60d2a135fd088443d0cba9213375b211e188#run-qwen3-coder-next" class="button primary">GGUF 実行チュートリアル</a><a href="/pages/983a60d2a135fd088443d0cba9213375b211e188#improving-generation-speed" class="button secondary">Codex と Claude Code</a><a href="/pages/983a60d2a135fd088443d0cba9213375b211e188#fp8-qwen3-coder-next-in-vllm" class="button secondary">FP8 vLLM チュートリアル</a>

### ⚙️ 使用ガイド

46GB の RAM や統合メモリがなくても大丈夫です。3-bit などの小さな量子化モデルを実行できます。モデルサイズ = 次の計算資源の合計（ **`ディスク容量 + RAM + VRAM ≥ 量子化サイズ）となるのが理想です。`** 量子化モデルがデバイスに完全に収まる場合は、20トークン/秒以上が期待できます。収まらない場合でもオフロードで動作しますが、速度は遅くなります。

最適な性能を得るには、Qwen は以下の設定を推奨しています：

* <mark style="background-color:blue;">`Temperature = 1.0`</mark>
* `Top_P = 0.95`
* `Top_K = 40`
* `Min_P = 0.01` (llama.cppのデフォルトは0.05です)
* `リピートペナルティ` = 無効、または 1.0

最大でサポート `262,144` のコンテキストをネイティブにサポートしますが、次の値に設定できます： `32,768` メモリ使用量を減らすためにトークン。

### 🖥️ Qwen3-Coder-Next を実行

使用ケースによっては、異なる設定を使う必要があります。このガイドでは 4-bit を使うため、約 46GB の RAM/統合メモリが必要です。最高の性能を得るには、少なくとも 3-bit 精度を推奨します。

#### 🦥 Unsloth Studio ガイド

Qwen3-Coder-Next は次の環境で実行およびファインチューニングできます： [Unsloth Studio](/docs/jp/xin-zhe/studio.md)、これはローカル AI 向けの新しいオープンソース Web UI です。Unsloth Studio を使うと、モデルをローカルで次の環境上で実行できます： **macOS、Windows**、Linux などでローカル実行できます:

{% columns %}
{% column %}

* 検索、ダウンロード、 [GGUF を実行](/docs/jp/xin-zhe/studio.md#run-models-locally) および safetensors モデル
* [**自己修復** ツール呼び出し](/docs/jp/xin-zhe/studio.md#execute-code--heal-tool-calling) + **ウェブ検索**
* [**コード実行**](/docs/jp/xin-zhe/studio.md#run-models-locally) (Python、Bash)
* [自動推論](/docs/jp/xin-zhe/studio.md#model-arena) パラメータ調整（temp、top-p など）
* llama.cpp による高速な CPU + GPU 推論
* [LLM を学習](/docs/jp/xin-zhe/studio.md#no-code-training) VRAM を 70% 削減しながら 2 倍高速
  {% endcolumn %}

{% column %}

<div data-with-frame="true"><figure><img src="/files/c32867f999db074387ac16732ce548485cc593de" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}
**Unsloth をインストール**

端末で次を実行します:

macOS、Linux、WSL:

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

Windows PowerShell:

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

{% hint style="success" %}
**インストールはすぐ終わり、およそ 1〜2 分です。**
{% endhint %}
{% endstep %}

{% step %}
**Unsloth を起動**

macOS、Linux、WSL、および Windows:

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

その後、 `http://localhost:8888` をブラウザで開いてください。
{% endstep %}

{% step %}
**Qwen3-Coder-Next を検索してダウンロード**

初回起動時には、アカウントを保護するためのパスワードを作成し、後で再度サインインする必要があります。その後、モデル、データセット、基本設定を選ぶ簡単な初期設定ウィザードが表示されます。いつでもスキップして、そのままチャットに進めます。

次に [Studio Chat](/docs/jp/xin-zhe/studio/chat.md) タブで次を検索： **Qwen3-Coder-Next** を検索バーに入力し、目的のモデルと量子化版をダウンロードしてください。

<div data-with-frame="true"><figure><img src="/files/df70edf2fe9ba3c58c1fff02ee34685549ec9e57" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}
**Qwen3-Coder-Next を実行**

推論パラメータは Unsloth Studio 使用時に自動設定されるはずですが、手動で変更することもできます。コンテキスト長、チャットテンプレート、その他の設定も編集できます。

詳細については、次をご覧ください: [Unsloth Studio 推論ガイド](/docs/jp/xin-zhe/studio/chat.md).

<div data-with-frame="true"><figure><img src="/files/44d9105dd956eac31f9586bcf01055a289b0ef3e" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

#### Llama.cpp チュートリアル（GGUF）：

llama.cpp での実行手順（ほとんどのデバイスに収めるため 4-bit を使用します）：

{% stepper %}
{% step %}
最新のものを入手 `llama.cpp` を [GitHub はこちら](https://github.com/ggml-org/llama.cpp)。以下のビルド手順に従うこともできます。次を変更してください: `-DGGML_CUDA=ON` を `-DGGML_CUDA=OFF` GPU がない場合、または CPU 推論だけを使いたい場合。 **Apple Mac / Metal デバイスの場合**、次を設定してください `-DGGML_CUDA=OFF` その後は通常どおり続けてください - Metal サポートはデフォルトで有効です。

{% code overflow="wrap" %}

```bash
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
```

{% endcode %}
{% endstep %}

{% step %}
Hugging Face から直接取得できます。RAM/VRAM に収まるなら、コンテキストを 256K まで増やせます。次を使用すると `--fit on` コンテキスト長も自動で判定されます。

推奨パラメータを使用できます： `temperature=1.0`, `top_p=0.95`, `top_k=40`

```bash
./llama.cpp/llama-cli \\
    -hf unsloth/Qwen3-Coder-Next-GGUF:UD-Q4_K_XL \
    --ctx-size 16384 \\
    --temp 1.0 --top-p 0.95 --min-p 0.01 --top-k 40
```

{% endstep %}

{% step %}
次をインストールした後にモデルをダウンロードしてください `pip install huggingface_hub`）。選べます `UD-Q4_K_XL` または他の量子化版でも構いません。ダウンロードが止まる場合は、次を参照してください： [Hugging Face Hub、XETデバッグ](/docs/jp/ji-ben/troubleshooting-and-faqs/hugging-face-hub-xet-debugging.md)

{% code overflow="wrap" %}

```bash
pip install -U huggingface_hub
hf download unsloth/Qwen3-Coder-Next-GGUF \
    --local-dir unsloth/Qwen3-Coder-Next-GGUF \
    --include "*UD-Q4_K_XL*"
```

{% endcode %}
{% endstep %}

{% step %}
その後、会話モードでモデルを実行します:

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \\
    --model unsloth/Qwen3-Coder-Next-GGUF/Qwen3-Coder-Next-UD-Q4_K_XL.gguf \
    --seed 3407 \
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01 \\
    --top-k 40
```

{% endcode %}

また、次を調整してください： **コンテキストウィンドウ** 必要に応じて、最大で `262,144`

{% hint style="info" %}
注：このモデルは non-thinking モードのみをサポートし、出力に `<think></think>` ブロックを生成しません。そのため、 `enable_thinking=False` は不要になりました。
{% endhint %}
{% endstep %}
{% endstepper %}

### 🦙Llama-server の提供とデプロイ

Qwen3-Coder-Next を本番環境にデプロイするには、次を使用します： `llama-server` 新しいターミナルを tmux などで開きます。次に、以下でモデルをデプロイします：

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-server \\
    --model unsloth/Qwen3-Coder-Next-GGUF/Qwen3-Coder-Next-UD-Q4_K_XL.gguf \
    --alias "unsloth/Qwen3-Coder-Next" \
    --seed 3407 \
    --temp 1.0 \\
    --top-p 0.95 \\
    --min-p 0.01 \\
    --top-k 40 \
    --port 8001
```

{% endcode %}

その後、新しい端末で、次を実行したあとに `pip install openai`、モデルを実行できます：

{% code overflow="wrap" %}

```python
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/Qwen3-Coder-Next",
    messages = [{"role": "user", "content": "HTML で Flappy Bird ゲームを作成して"},],
)
print(completion.choices[0].message.content)
```

{% endcode %}

以下の出力になります：

{% columns %}
{% column width="66.66666666666666%" %}
{% code overflow="wrap" expandable="true" %}

````markdown
これは、1つのファイルに収められた完全に動作する Flappy Bird ゲームです。

グラフィックには **HTML5 Canvas** を、物理演算（重力、衝突判定、スコア計算）には **JavaScript** を使用しました。外部画像やダウンロードは不要で、コードで鳥とパイプを描画します。

### 実行方法：
1.  以下のコードブロックをコピーします。
2.  コンピュータ上に `game.html` という新しいファイルを作成します。
3.  そのファイルにコードを貼り付けて保存します。
4.  `game.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>シンプルな Flappy Bird</title>
    <style>
        body {
            margin: 0;
            padding: 0;
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            height: 100vh;
            background-color: #333;
            font-family: 'Courier New', Courier, monospace;
            color: white;
        }

        h1 {
            margin-bottom: 10px;
        }

        #game-container {
            position: relative;
            box-shadow: 0 0 20px rgba(0,0,0,0.5);
        }

        canvas {
            display: block;
            background-color: #70c5ce; /* 空の青 */
            border: 4px solid #000;
        }

        #ui-layer {
            position: absolute;
            top: 0;
            left: 0;
            width: 100%;
            height: 100%;
            pointer-events: none; /* クリックを canvas に通す */
            display: flex;
            flex-direction: column;
            justify-content: center;
            align-items: center;
            text-align: center;
        }

        .message {
            background: rgba(255, 255, 255, 0.8);
            padding: 20px;
            border-radius: 10px;
            color: #333;
        }

        #score-board {
            position: absolute;
            top: 20px;
            width: 100%;
            text-align: center;
            font-size: 40px;
            font-weight: bold;
            color: white;
            text-shadow: 2px 2px 0 #000;
            z-index: 10;
        }
    </style>
</head>
<body>

    <h1>Flappy Bird のクローン</h1>
    
    <div id="game-container">
        <div id="score-board">0</div>
        <canvas id="birdCanvas" width="320" height="480"></canvas>
        
        <div id="ui-layer">
            <div id="start-screen" class="message">
                <h2>飛ぶ準備はできましたか？</h2>
                <p><strong>Space</strong> または <strong>クリック</strong> でジャンプ</p>
                <p>Space を押して開始</p>
            </div>
            <div id="game-over-screen" class="message" style="display: none;">
                <h2>ゲームオーバー</h2>
                <p>スコア: <span id="final-score">0</span></p>
                <p>ベスト: <span id="best-score">0</span></p>
                <p><strong>Space</strong> を押して再スタート</p>
            </div>
        </div>
    </div>

    <script>
        // --- 設定 ---
        const canvas = document.getElementById('birdCanvas');
        const ctx = canvas.getContext('2d');
        const scoreElement = document.getElementById('score-board');
        const startScreen = document.getElementById('start-screen');
        const gameOverScreen = document.getElementById('game-over-screen');
        const finalScoreSpan = document.getElementById('final-score');
        const bestScoreSpan = document.getElementById('best-score');

        // ゲーム変数
        let frames = 0;
        let score = 0;
        let highScore = localStorage.getItem('flappyHighScore') || 0;
        let gameState = 'START'; // START、PLAYING、GAMEOVER
        const gravity = 0.25;
        const speed = 2; // 左に移動するパイプの速度

        // --- 鳥オブジェクト ---
        const bird = {
            x: 50,
            y: 150,
            width: 30,
            height: 30,
            velocity: 0,
            jumpStrength: 4.5,
            radius: 15,
            draw: function() {
                ctx.fillStyle = "#FFD700"; // 金色
                ctx.beginPath();
                ctx.arc(this.x + this.radius, this.y + this.radius, this.radius, 0, Math.PI * 2);
                ctx.fill();
                ctx.lineWidth = 2;
                ctx.stroke();

                // 目
                ctx.fillStyle = "white";
                ctx.beginPath();
                ctx.arc(this.x + this.radius + 5, this.y + this.radius - 5, 5, 0, Math.PI * 2);
                ctx.fill();
                ctx.fillStyle = "black";
                ctx.beginPath();
                ctx.arc(this.x + this.radius + 7, this.y + this.radius - 5, 2, 0, Math.PI * 2);
                ctx.fill();
                
                // くちばし
                ctx.fillStyle = "orange";
                ctx.beginPath();
                ctx.moveTo(this.x + this.radius + 10, this.y + this.radius);
                ctx.lineTo(this.x + this.radius + 20, this.y + this.radius + 5);
                ctx.lineTo(this.x + this.radius + 10, this.y + this.radius + 10);
                ctx.fill();
                ctx.stroke();
            },
            update: function() {
                this.velocity += gravity;
                this.y += this.velocity;

                // 床との衝突
                if (this.y + this.height >= canvas.height) {
                    this.y = canvas.height - this.height;
                    gameOver();
                }
                
                // 天井との衝突（任意：パイプを飛び越えるのを防ぐ）
                if (this.y < 0) {
                    this.y = 0;
                    this.velocity = 0;
                }
            },
            jump: function() {
                this.velocity = -this.jumpStrength;
            },
            reset: function() {
                this.y = 150;
                this.velocity = 0;
            }
        };

        // --- パイプ配列 ---
        const pipes = {
            position: [],
            width: 50,
            gap: 120, // 上のパイプと下のパイプの間隔
            dx: 2, // 移動速度

            draw: function() {
                for (let i = 0; i < this.position.length; i++) {
                    let p = this.position[i];
                    let topY = p.y;
                    let bottomY = p.y + this.gap;

                    ctx.fillStyle = "#228B22"; // フォレストグリーン

                    // 上のパイプ
                    ctx.fillRect(p.x, 0, this.width, topY);
                    ctx.strokeRect(p.x, 0, this.width, topY);

                    // 下のパイプ
                    ctx.fillRect(p.x, bottomY, this.width, canvas.height - bottomY);
                    ctx.strokeRect(p.x, bottomY, this.width, canvas.height - bottomY);
                }
            },

            update: function() {
                // 120 フレームごとに新しいパイプを追加（約 2 秒）
                if (frames % 120 === 0) {
                    // 上のパイプのランダムな高さ
                    // 最小高さ 50、最大高さ canvas - gap - 50
                    let maxY = canvas.height - this.gap - 50;
                    let randomY = Math.floor(Math.random() * (maxY - 50 + 1) + 50);
                    
                    this.position.push({
                        x: canvas.width,
                        y: randomY
                    });
                }

                for (let i = 0; i < this.position.length; i++) {
                    let p = this.position[i];
                    p.x -= this.dx;

                    // 衝突判定
                    // ロジック：鳥の X 座標がパイプの X 範囲内か確認
                    if (bird.x + bird.width > p.x && bird.x < p.x + this.width) {
                        // ロジック：鳥の Y 座標が上のパイプまたは下のパイプに当たっているか確認
                        if (bird.y < p.y || bird.y + bird.height > p.y + this.gap) {
                            gameOver();
                        }
                    }

                    // スコア更新（鳥がパイプを通過したとき）
                    if (p.x + this.width < bird.x && !p.passed) {
                        score++;
                        scoreElement.innerText = score;
                        p.passed = true;
                    }

                    // 画面外に出たパイプを削除
                    if (p.x + this.width <= 0) {
                        this.position.shift();
                        // 配列の長さが変わったので i をデクリメント
                        i--; 
                    }
                }
            },
            
            reset: function() {
                this.position = [];
            }
        };

        // --- 背景（雲 / 草） ---
        const background = {
            draw: function() {
                // 草を描画
                ctx.fillStyle = "#7cfc00"; // 芝生グリーン
                ctx.fillRect(0, canvas.height - 20, canvas.width, 20);
                ctx.beginPath();
                ctx.moveTo(0, canvas.height - 20);
                ctx.lineTo(canvas.width, canvas.height - 20);
                ctx.stroke();
            }
        };

        // --- ゲーム制御関数 ---

        function loop() {
            // キャンバスをクリア
            ctx.clearRect(0, 0, canvas.width, canvas.height);

            // 背景を描画
            background.draw();

            if (gameState === 'START') {
                bird.draw();
                // 地面のラインを描画
                ctx.fillStyle = "#ded895";
                ctx.fillRect(0, canvas.height - 10, canvas.width, 10);
            } 
            else if (gameState === 'PLAYING') {
                bird.update();
                bird.draw();
                pipes.update();
                pipes.draw();
                frames++;
            } 
            else if (gameState === 'GAMEOVER') {
                pipes.draw();
                bird.draw();
                // frames や position は更新せず、そのまま停止
            }

            requestAnimationFrame(loop);
        }

        function startGame() {
            gameState = 'PLAYING';
            startScreen.style.display = 'none';
            gameOverScreen.style.display = 'none';
            score = 0;
            frames = 0;
            scoreElement.innerText = score;
            bird.reset();
            pipes.reset();
        }

        function gameOver() {
            gameState = 'GAMEOVER';
            
            // ハイスコアを更新
            if (score > highScore) {
                highScore = score;
                localStorage.setItem('flappyHighScore', highScore);
            }

            finalScoreSpan.innerText = score;
            bestScoreSpan.innerText = highScore;
            gameOverScreen.style.display = 'block';
        }

        // --- 入力処理 ---

        function handleInput(e) {
            // Space キーのデフォルトのスクロール動作を防止
            if (e.type === 'keydown' && e.code === 'Space') {
                e.preventDefault();
            }

            if (e.code === 'Space' || e.type === 'mousedown' || e.type === 'touchstart') {
                switch (gameState) {
                    case 'START':
                        startGame();
                        bird.jump();
                        break;
                    case 'PLAYING':
                        bird.jump();
                        break;
                    case 'GAMEOVER':
                        startGame();
                        bird.jump();
                        break;
                }
            }
        }

        window.addEventListener('keydown', handleInput);
        canvas.addEventListener('mousedown', handleInput);
        canvas.addEventListener('touchstart', handleInput);

        // 初期化
        loop();

    </script>
</body>
</html>
```

### このバージョンの機能：
1.  **物理演算:** リアルな重力とジャンプの仕組み。
2.  **衝突判定:** パイプ、床、天井に当たるとゲーム終了。
3.  **スコアシステム:** 通過するたびに 1 点獲得。
4.  **ハイスコア:** ページを更新しても、ブラウザの LocalStorage にベストスコアを保存します。
5.  **レスポンシブな操作:** **Spacebar**、**マウスクリック**、**タッチ**（モバイル端末）で操作できます。
6.  **グラフィック:** 鳥はコードで描画され（目とくちばし付き）、パイプには枠線があるため、壊れた画像リンクは発生しません。
````

{% endcode %}

HTML を抽出して実行したところ、生成された Flappy Bird のサンプルゲームはうまく動作しました！
{% endcolumn %}

{% column width="33.33333333333334%" %}

<figure><img src="/files/02e2b4d07493d93098e19b83db2ccee186aa3c92" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

### 👾 OpenAI Codex と Claude Code <a href="#claude-codex" id="claude-codex"></a>

ローカルのコーディングエージェント型ワークロードでモデルを実行するには、ガイドに従ってください。上記の `llama-server` 先ほどセットアップしたものを使い、モデル名を `GET /v1/models` （ `--alias` の値を使用し、 `unsloth/Qwen3-Coder-Next`）。正しい Qwen3-Coder-Next のパラメータと使用方法に従ってください。

{% columns %}
{% column %}
{% content-ref url="/pages/ee610b22aa43d29d8415fd27eb7de15ba88f7385" %}
[Claude Code](/docs/jp/ji-ben/claude-code.md)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="/pages/c87896ff7159620f4c01bb39fe9df1fd1a55274e" %}
[OpenAI Codex](/docs/jp/ji-ben/codex.md)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

例えば Claude Code の手順に従った後、次のように表示されます:

<figure><img src="/files/ac5ba4dbc7b649aceacab8fa5ec1e8616642acf6" alt="" width="563"><figcaption></figcaption></figure>

その後、たとえば `チェスの Python ゲームを作成して` :

<div><figure><img src="/files/ad665850d5315c4be5a608351515356ff59d082b" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/e66b5d09d577fb36f0dc6f8e34d987a9ae0dbbaf" alt="" width="563"><figcaption></figcaption></figure> <figure><img src="/files/03a03b0c279f2ea141b94abfad9dec6275485ba1" alt="" width="563"><figcaption></figcaption></figure></div>

次のエラーが表示されたら `API エラー: 400 {"error":{"code":400,"message":"リクエスト（16582 トークン）が利用可能なコンテキストサイズ（16384 トークン）を超えています。増やしてみてください","type":"exceed_context_size_error","n_prompt_tokens":16582,"n_ctx":16384}}` つまり、コンテキスト長を増やすか、次を参照する必要があります： [#how-to-fit-long-context-256k-to-1m](#how-to-fit-long-context-256k-to-1m "mention")

<figure><img src="/files/aaa9d1bd5a841b3db5bd29e4acc6aedb11013e5e" alt=""><figcaption></figcaption></figure>

### 🎱 vLLM における FP8 Qwen3-Coder-Next

これで新しいものを使用できます [FP8動的量子化](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) モデルのプレミアムで高速な推論向けです。まず nightly 版の vLLM をインストールしてください。次を変更してください `--extra-index-url https://wheels.vllm.ai/nightly/cu130` 以下で確認したCUDAバージョンに `nvidia-smi` のみ `cu129` および `cu130` が現在サポートされています。

{% hint style="success" %}
vLLM / SGLang を使用している場合は、スループットを25%以上向上できる当社のFP8-Dynamic量子化を試してください！参照： [#fp8-qwen3-coder-next-in-vllm](#fp8-qwen3-coder-next-in-vllm "mention")
{% endhint %}

{% code overflow="wrap" %}

```bash
# 環境のインストールを高速化するため、uv がない場合はインストールしてください
curl -LsSf https://astral.sh/uv/install.sh | sh

# 新しいPython環境を作成します - システム全体を変更したい場合は不要です
uv venv unsloth_fp8 --python 3.12 --seed
source unsloth_fp8/bin/activate

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
```

{% endcode %}

その後、起動します [Unslothの動的FP8版](https://huggingface.co/unsloth/Qwen3-Coder-Next-FP8-Dynamic) モデルの。さらに、次を追加してFP8を有効にすると、KVキャッシュのメモリ使用量を50%削減できます `--kv-cache-dtype fp8` 4基のGPUで提供しましたが、1基のGPUしかない場合は、次を使用してください `CUDA_VISIBLE_DEVICES='0'` そして設定します `--tensor-parallel-size 1` またはこの引数を削除してください。次を使用してください `tmux` 以下を新しい端末で起動するには、CTRL+B+D を押してください - 次を使用 `tmux attach-session -t0` そこに戻るには。

```bash
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:False
CUDA_VISIBLE_DEVICES='0,1,2,3' vllm serve unsloth/Qwen3-Coder-Next-FP8-Dynamic \\
    --served-model-name unsloth/Qwen3-Coder-Next \\
    --tensor-parallel-size 4 \\
    --tool-call-parser qwen3_coder \\
    --enable-auto-tool-choice \
    --dtype bfloat16 \
    --seed 3407 \
    --max-model-len 200000 \
    --gpu-memory-utilization 0.93 \
    --port 8001
```

以下のようなものが表示されるはずです。参照： [#tool-calling-with-qwen3-coder-next](#tool-calling-with-qwen3-coder-next "mention") OpenAI API とツール呼び出しを使って Qwen3-Coder-Next を実際に使う方法については、こちらを参照してください - これは vLLM と llama-server で動作します。

<figure><img src="/files/819fa8becabe39421cd5080be48d241452c0a8f7" alt=""><figcaption></figcaption></figure>

### :wrench:Qwen3-Coder-Next でのツール呼び出し

新しい端末で、2つの数値の加算、Pythonコードの実行、Linux関数の実行など、さまざまなツールを作成します：

{% code expandable="true" %}

```python
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"],
            },
        },
    },
]
```

{% endcode %}

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

{% code overflow="wrap" expandable="true" %}

```python
from openai import OpenAI
def unsloth_inference(
    messages,
    temperature = 1.0,
    top_p = 0.95,
    top_k = 40,
    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"Using model = {model_name}")
    has_tool_calls = True
    original_messages_len = len(messages)
    while has_tool_calls:
        print(f"Current messages = {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
```

{% endcode %}

ここでは、さまざまなユースケースにおけるツール呼び出しの複数の実行方法を紹介します：

#### 生成されたPythonコードを実行

{% code overflow="wrap" %}

```python
messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Create a Fibonacci function in Python and find fib(20)."}],
}]
unsloth_inference(messages, temperature = 1.0, top_p = 0.95, top_k = 40, min_p = 0.00)
```

{% endcode %}

<figure><img src="/files/149e6471b8306d473f6545aabab1c4fb9b09e792" alt=""><figcaption></figcaption></figure>

#### 任意のターミナル関数を実行

{% code overflow="wrap" %}

```python
messages = [{
    "role": "user",
    "content": [{"type": "text", "text": "Write 'I'm a happy Sloth' to a file, then print it back to me."}],
}]
messages = unsloth_inference(messages, temperature = 1.0, top_p = 1.0, top_k = 40, min_p = 0.00)
```

{% endcode %}

ファイルが作成されたことを確認し、実際に作成されていました！

<figure><img src="/files/0dba92b353a36ecdaacbad2b67443b6af62ef157" alt=""><figcaption></figcaption></figure>

参照: [Tool Calling Guide](/docs/jp/ji-ben/tool-calling-guide-for-local-llms.md) ツール呼び出しのその他の例について。

## :triangular\_ruler:ベンチマーク

### GGUF量子化ベンチマーク

以下は、第三者評価者によるいくつかの量子化ベンチマークです。

<div><figure><img src="/files/8065a5a23bf49aee01e4e59d4d71e31eec2e3a5a" alt="" width="563"><figcaption><p>Aider Polyglot ベンチマーク</p></figcaption></figure> <figure><img src="/files/caf01dd085af11bfa9e713556cca7de78754c2ed" alt="" width="450"><figcaption><p>Benjamine Marie ベンチマーク（<a href="https://x.com/bnjmn_marie/status/2019809651387514947/photo/1">出典</a>)</p></figcaption></figure></div>

{% columns %}
{% column %}
ベンチマークは、Aider Polyglot サーバー上で第三者の協力者によって実施され、Aider Polyglot ベンチマーク（スコア対VRAM）における Unsloth の GGUF 量子化を比較しました。特に、3ビットの **`UD-IQ3_XXS`** 量子化は〜にかなり近く **BF16** の性能を示し、 **3ビットを妥当な最小値にしています** ほとんどのユースケースに対して。

**NVFP4** BF16参照をわずかに上回っていますが、これは試行回数が少ないことによるサンプリングノイズかもしれません。ただし、以下の全体的な傾向は： **1-bit → 2-bit → 3-bit → 6-bit** 着実に改善していることから、このベンチマークは Unsloth GGUF 全体の意味のある品質差を捉えていると考えられます。 **非Unsloth** FP8は両方よりも性能が悪いようです **`UD-IQ3_XXS`** および **`UD-Q6_K_XL`**。これは量子化パイプラインの違い、あるいはやはりサンプリング不足を反映している可能性があります。
{% endcolumn %}

{% column %}
[Benjamin Marie（第三者）がベンチマークを実施しました](https://x.com/bnjmn_marie/status/2019809651387514947/photo/1) **Qwen3-Coder-Next** Unsloth と Qwen の GGUF を使用して、 **750プロンプトの混合スイートで** （LiveCodeBench v6、MMLU Pro、GPQA、Math500）を対象に、以下の両方を報告しています **全体精度** および **相対誤差増加** （量子化モデルが元のモデルよりどれだけ多くミスをするか）。

グラフは、Unsloth の Q4\_K\_M 量子化が標準の Q4\_K\_M より明らかに優れていることを示しています。Q3\_K\_M は予想どおり Live Code Bench v6 では劣りますが、意外にも HumanEval では標準の Q4\_K\_M よりかなり良い結果です。\
\
最も効率よく動作するようなので、少なくとも Q4\_K\_M を使うことをお勧めします。
{% endcolumn %}
{% endcolumns %}

### Qwen3-Coder-Next ベンチマーク

Qwen3-Coder-Next は、その規模に対して最も高性能なモデルであり、その性能はアクティブパラメータ数が10〜20倍多いモデルに匹敵します。

<table data-full-width="true"><thead><tr><th>ベンチマーク</th><th align="right">Qwen3-Coder-Next (80B)</th><th align="right">DeepSeek-V3.2 (671B)</th><th align="right">GLM-4.7 (358B)</th><th align="right">MiniMax M2.1 (229B)</th></tr></thead><tbody><tr><td>SWE-Bench Verified（SWE-Agent使用）</td><td align="right">70.6</td><td align="right">70.2</td><td align="right">74.2</td><td align="right">74.8</td></tr><tr><td>SWE-Bench Multilingual（SWE-Agent使用）</td><td align="right">62.8</td><td align="right">62.3</td><td align="right">63.7</td><td align="right">66.2</td></tr><tr><td>SWE-Bench Pro（SWE-Agent使用）</td><td align="right">44.3</td><td align="right">40.9</td><td align="right">40.6</td><td align="right">34.6</td></tr><tr><td>Terminal-Bench 2.0（Terminus-2 JSON使用）</td><td align="right">36.2</td><td align="right">39.3</td><td align="right">37.1</td><td align="right">32.6</td></tr><tr><td>Aider</td><td align="right">66.2</td><td align="right">69.9</td><td align="right">52.1</td><td align="right">61.0</td></tr></tbody></table>

<figure><img src="/files/9ebed3290b3302af6566d1c063765b8063a15323" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/41d1eca4aafd039b82ccf76c4b6a3186c061b280" alt="" width="563"><figcaption></figcaption></figure>

<figure><img src="/files/9721d17b0eb4feea293609bd2e11d66d0d20e986" alt=""><figcaption></figcaption></figure>


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/jp/moderu/qwen3-coder-next.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.