「clef」構造化意思決定モデル：必要VRAM 80GB〜

2026年10月2日2026年10月3日

基本情報

情報を集めた時点で、当サイトのコードが確定させた値です。日付はJSTで表示しています。

当サイトで確かめたこと

• 全ての意思決定モデルに出している当サイトの判定問題20問を、配布元のコードをクラウドの GPU(NVIDIA A100 80GB PCIe・ネットワーク遮断)で動かして解かせ、日本語で20問・英語で19問正解しました。

詳しい値と条件は、下の「当サイトでの実測」の節にあります。

概要

Cloudflareは、Qwen3.8-27Bをベースとした27Bパラメータのマルチモーダル意思決定モデル「Clef」を公開しました。このモデルは、テキスト、JSON、画像、動画といった「状態」と、型定義された「質問スキーマ」を入力として受け取り、各選択肢の確率を直接出力するように設計されています。自由形式のテキスト生成や出力のパースを必要とせず、1回のフォワードパスで構造化された意思決定を行うことが可能です。

Clefは、Qwen3.8-27Bをベースにポストトレーニングされており、Cloudflareのブログによれば、状態を読み取ってスキーマに基づいた意思決定を行う「意思決定モデル」として位置づけられています。APIはJevやSystemOneと完全な互換性があり、実務的なワークフローへの統合が容易です。

出典：Clef decision models on the Cloudflare blog

スペック

• パラメータ数: 27B
• アーキテクチャ: Qwen3.5アーキテクチャベース（Denseモデル）、ビジョンエンコーダー搭載
• コンテキスト長: 262,144 トークン（ネイティブ）、最大1,000,000トークンまで拡張可能
• 入力形式: テキスト、JSON、画像、動画

性能

モデルカードに記載された、意思決定タスクのベンチマーク群「Decision Index」の比較結果を紹介します。ここでは、Clef、軽量版のClef-flash、および既存モデルのJev、Kev 9Bの4列に絞って掲載します。

Decision Index

公開元の測定によれば、ClefはBFCL（関数の選択と引数の組み立ての正確性）において98.5%という極めて高いスコアを記録しており、エージェントとしてのツール利用能力に非常に優れています。また、BANKING77やCLINC150+OOSといった分類タスクにおいても、比較対象の中で最高値をマークしています。一方で、GPQA Diamond（科学の難問）では48.0%に留まり、Jevの78.3%と比較すると、専門的な科学知識を必要とする推論タスクでは及ばない面があります。BBH（推論タスク）においてもJevが優勢です。

次に、ビジネス実務を模した「Workflow evals」の結果です。

Workflow evals

請求書処理（Invoice processing）やセキュリティインシデント対応などの実務的なワークフローにおいて、Clefは既存のJevを上回る精度を示しています。特に請求書処理の主要アクションの特定では86.2%と高い数値を記録しています。

なお、ClefのベースモデルであるQwen3.8-27B自体の性能も極めて高く、公開元のベンチマークでは、SWE-bench Pro（実リポジトリの修正）で61.7%、LiveCodeBench v6（競技プログラミング）で90.3%を記録するなど、コーディングやエージェントタスクにおいて同規模のモデルを圧倒する性能を持っています。Clefはこの強力な基盤の上に、構造化出力に特化した学習を施したモデルです。

得意なこと・想定用途

Clefは、与えられた入力「状態（state）」と型定義された「質問スキーマ（questions）」に基づき、あらかじめ決められた選択肢に対する確率を計算して返す意思決定タスクを得意としています。テキストやJSONデータだけでなく、画像や動画フレームも状態として同時に入力できるため、マルチモーダルな情報をもとにした分類や判定が可能です。

質問スキーマでは、真偽判定を行う noul 型、複数の選択肢から選ぶ choice 型、段階的な評価を行う score 型といった形式がサポートされています。モデル内部では、バックボーンであるQwen3.8-27B（ビジョンエンコーダー含む）の最終隠し状態を小さなトランスフォーマーヘッド（joint schema head）が読み取り、全質問の選択肢に対するスコア（対数確率）を1回のフォワードパスで一括して計算します。

この仕組みにより、従来のLLMで必要だった自由形式テキストの生成や、出力結果をJSON等に変換するための複雑なパース処理が一切不要となります。具体的には、以下のような実務用途が想定されています。

• 請求書や領収書の自動判定: 画像やテキスト形式の請求書データから、支払い状況や金額の条件判定を行います。
• カスタマーサポートのルーティング: ユーザーからの問い合わせ本文をもとに、担当部署（請求担当、技術担当など）の振り分けや緊急度（即日対応、今週中など）を判定します。
• セキュリティインシデントの分類: 障害報告やログメッセージから、サービス停止の有無などを自動で識別します。

また、既存の意思決定システムであるJevやSystemOneのAPI（POST /v1/systemone）と完全な互換性を持っているため、これらのフォーマットに対応した既存ワークフローへそのまま組み込んで運用できます。

類似モデルとの違い

当サイトで過去に取り上げたQwen3.8-27B派生モデルと比較すると、Clefは明確に異なるアプローチを採用しています。

「OrcaSAQ-2-27B」テキスト生成モデル：当サイトでの回答例・必要VRAM 16GB〜は、54GBある元のモデルを16GBのGPU 1枚で動作させることを目的に、独自の量子化技術（SAQ2）で平均3.21bitまで圧縮したテキストモデルです。これに対してClefは、パラメータを圧縮して軽量化するのではなく、バックボーンにビジョンエンコーダーを残したまま構造化意思決定ヘッドを追加し、マルチモーダル入力に対応させたモデルとなっています。

また、「Hemmingway-1」日常文章特化の言語モデル：必要VRAM 12GB〜・GGUF版ありは、電子メールやメッセージなど、人が書いたような日常文章を直接生成することに特化したモデルです。一方のClefは、自然言語テキストの文章生成を行わず、あらかじめ定義された質問の選択肢に対する確率値（確率分布）のみを出力します。文章の作成を目的とするHemmingway-1に対し、Clefは分類や意思決定の自動化に特化している点が大きな違いです。

動作環境

動作環境の目安(Local Model Watch 算出) — パラメータ数 27.4B

推論エンジンの対応状況(各プロジェクトのソースにあるモデル登録表とアーキテクチャ名を当サイトが機械的に照合。2026-10-03 時点): llama.cpp: 登録あり、vLLM: 登録あり、MLX (mlx-lm): 登録あり。

必要メモリは配布ファイルの実サイズに実行時のオーバーヘッド(KVキャッシュ等)を20%見込んだ概算で、文脈長・バッチサイズ・推論エンジンによって増減します。公開元の公称値ではなく、当サイトがファイルサイズから機械的に算出した値です。 他のモデルとの比較はVRAM別の早見表を参照してください。 量子化の名前の読み方は用語集にあります。

手元で動かせるか

現時点では Ollama・LM Studio・llama.cpp で動かせません(GGUF版を確認できていない)。

公開元の配布は safetensors のみです。ただし llama.cpp の登録表にはこのモデルのアーキテクチャ名があるため、GGUFへの変換自体は可能な状態で、変換版が公開されれば動くようになります。公開元と実績のある量子化担当以外による変換版は 4 件あります。現時点で動かすなら transformers(PyTorch)・vLLM で読み込む形になり、必要メモリは上の表のとおりです。

ライセンス apache-2.0(商用利用可): 商用利用を含めて自由に利用・改変・再配布できます。再配布時にライセンス文と変更点の告知が必要で、特許の許諾条項があります。

配布形式・当サイトが見つけた変換版・各推論エンジンの登録表を突き合わせた判定です。「確認できていない」は当サイトが見つけていないという意味で、存在しないことの断定ではありません。ライセンスの要約は法的助言ではないため、実際の利用にあたっては公開元の原文を確認してください。

当サイトでの実測

当サイトのサーバー(GPUなし)で、このモデルのファイルを実際に読み込み・動かして確かめた値です。モデルカードの記載ではなく、当サイトが測った結果です。測り方と全モデルの一覧は観測データにまとめています。

意思決定モデルとしての評価(当サイトの判定問題)

全ての意思決定モデルに出しているのと同じ、当サイトが書いた11の状況・20問の判定問題(はい/いいえ・名前付きの選択肢・順序のある段階。日本語と英語)を解かせました。このモデルの判定の部分は llama.cpp で動かせないため、配布元のコード(joint_schema_model.py とその SystemOne 互換の関数)を、クラウドの GPU を借りて、ネットワークを遮断したコンテナの中で動かしました。どの問いも判定の規則を文に書いて答えが1つに決まるようにし、正誤はコードが判定しています(はい/いいえは「はい」の確率が0.5以上なら「はい」、選択肢と段階は確率が最も高いもの)。ベンチマークの問題ではなく、モデルの総合的な性能の順位でもありません。

条件は Modal・NVIDIA A100 80GB PCIe(ピーク時の VRAM 51.4GB)・BF16・transformers 5.18.0・torch 2.14.1+cu130・配布元の版 2f3de3dd85 です。1回の判定の時間は、1つの状況(1〜3問)を配布元の関数に渡してから返るまでをその GPU で測った値で、手元の GPU の速さの目安ではなく、当サイトの CPU で測った時間とも比べられません。

日本語では英語より1問多く正解しました(20問中 日本語20問・英語19問)。

ほかの行は同じ条件で測ったほかの意思決定モデルです(「参考」は比較のために測ったモデル)。方式はモデルごとに違い、量子化もそれぞれの配布のものです。

時間に(GPU)とある行はクラウドの GPU で、それ以外は当サイトの CPU で測ったため、その間で時間は比べられません(正解の数は比べられます)。

問いごとの答え

状況と問いの全文と、正解の根拠は観測データに載せています。

環境構築と実行の手順

ダウンロード(GPU の無い別のコンテナ。配布元のコードは実行しません): Python 3.12・pip install huggingface_hub で、Cloudflare/clef の版 2f3de3dd85f379784083b0814d997ab627200f0c の次のファイルを落としました(pickle の重みは落としません)。

chat_template.jinja
config.json
generation_config.json
joint_head.safetensors
joint_head_config.json
joint_schema_model.py
model-00001-of-00012.safetensors
model-00002-of-00012.safetensors
model-00003-of-00012.safetensors
model-00004-of-00012.safetensors
model-00005-of-00012.safetensors
model-00006-of-00012.safetensors
model-00007-of-00012.safetensors
model-00008-of-00012.safetensors
model-00009-of-00012.safetensors
model-00010-of-00012.safetensors
model-00011-of-00012.safetensors
model-00012-of-00012.safetensors
model.safetensors.index.json
processor_config.json
tokenizer.json
tokenizer_config.json

実行(GPU のコンテナ。ネットワーク遮断・モデルのファイルは読み取り専用): Python 3.12・pip install torch transformers accelerate safetensors pillow torchvision。コンテナで実行したコードの全文(decision_remote.py)です。問いは上と同じ要求の本文を渡しています。

"""
Modal のコンテナの中で動く、意思決定モデルの配布元のコードによる評価(2026-10-02、ユーザーの判断「Clef を Modal で動かす」)。
lmw/lab/gpu_modal.py の decision_run から呼ばれる。**標準ライブラリだけを先頭で読み**、torch・transformers は関数の中で読む。

llama.cpp に判定の方式が無い意思決定モデル(Clef は判定ヘッド joint_head.safetensors を配布元の joint_schema_model.py で
読む)を、配布元の SystemOne 互換の関数(systemone)で動かす。このコンテナは**ネットワーク遮断・Modal の機能なし・
Volume は読み取り専用**で、配布元のコードはここでだけ import する(ダウンロードは remote_code_remote.download が
GPU の無い別のコンテナで行い、そちらでは import しない)。

問題(要求の本文)はホストが組んで渡す(lmw/lab/decision.py の request_body。llama.cpp で測るモデルと同じもの)。
正誤はホストのコード(decision.score)が判定する。ここでは応答をそのまま返し、1回の判定にかかった時間を測るだけ。
"""
import os
import platform
import sys
import time
from datetime import datetime, timezone

MOUNT = "/models"
PYTHON_VERSION = "3.12"
# 実行用のコンテナに入れるパッケージ(記事の手順にも同じ値を載せる)。Clef のカードの記載は torch 2.11・
# transformers 5.10.2 で、画像を読む処理(AutoProcessor)のために pillow・torchvision を入れる
RUN_PACKAGES = ("torch", "transformers", "accelerate", "safetensors", "pillow", "torchvision")

def installed_packages() -> list[str]:
    from importlib import metadata
    seen = {}
    for dist in metadata.distributions():
        name = dist.metadata["Name"]
        if name and name.lower() not in seen:
            seen[name.lower()] = f"{name}=={dist.version}"
    return sorted(seen.values(), key=str.lower)

def _keep(answer: dict) -> dict:
    return {k: answer[k] for k in ("type", "choice", "noul", "score", "probabilities", "confidence") if k in answer}

def _log(t0: float, message: str) -> None:
    print(f"[decision {time.time() - t0:6.0f}s] {message}", flush=True)

def run(job: dict) -> dict:
    """
    job: {"dir", "module", "loader", "answer", "warmup": 要求, "requests": {lang: [[状況の id, 要求], ...]}}。
    戻り値は記録の一部({"results", "gpu", "vram_*", "transformers", "torch", "packages", ...})。
    """
    import torch
    import transformers
    os.environ["HF_HUB_OFFLINE"] = "1"
    os.environ["TRANSFORMERS_OFFLINE"] = "1"
    t0 = time.time()
    path = os.path.join(MOUNT, job["dir"])
    gpu = torch.cuda.get_device_name(0)
    _log(t0, f"GPU: {gpu}・transformers {transformers.__version__}・torch {torch.__version__}")
    # 配布元のコード。このコンテナ(ネットワーク遮断)でだけ読む
    sys.path.insert(0, path)
    module = __import__(job["module"])
    model, processor = getattr(module, job["loader"])(path, device="cuda")
    answer = getattr(module, job["answer"])
    torch.cuda.synchronize()
    load_sec = round(time.time() - t0)
    vram_loaded = torch.cuda.memory_allocated()
    _log(t0, f"読み込み {load_sec}秒・VRAM {vram_loaded / 1024 ** 3:.1f}GB")
    torch.cuda.reset_peak_memory_stats()
    answer(model, processor, job["warmup"])  # 1回目は時間を測らない
    results: dict = {}
    for lang, items in job["requests"].items():
        out = {}
        for task_id, body in items:
            torch.cuda.synchronize()
            started = time.perf_counter()
            resp = answer(model, processor, body)
            torch.cuda.synchronize()
            out[task_id] = {"answers": {qid: _keep(a) for qid, a in (resp.get("answers") or {}).items()},
                            "ms": round((time.perf_counter() - started) * 1000, 1),
                            "input_tokens": (resp.get("usage") or {}).get("input_tokens")}
        results[lang] = out
    _log(t0, "全ての状況を解き終えました")
    return {"results": results, "gpu": gpu, "vram_total": int(torch.cuda.get_device_properties(0).total_memory),
            "vram_loaded": int(vram_loaded), "vram_peak": int(torch.cuda.max_memory_allocated()),
            "load_sec": load_sec, "dtype": "bfloat16", "transformers": str(transformers.__version__),
            "torch": str(torch.__version__), "python": platform.python_version(), "packages": installed_packages(),
            "measured_at": datetime.now(timezone.utc).isoformat()}

実行のコンテナに入っていたパッケージ:

accelerate==1.15.0
aiohappyeyeballs==2.6.1
aiohttp==3.12.7
aiosignal==1.3.2
annotated-doc==0.0.5
anyio==4.15.1
attrs==25.3.0
cbor2==5.7.0
certifi==2026.7.22
click==8.5.0
cuda-bindings==13.4.3
cuda-pathfinder==1.8.3
cuda-toolkit==13.0.3.0
filelock==4.0.9
frozenlist==1.6.0
fsspec==2026.9.0
grpclib==0.4.8
h11==0.16.0
h2==4.2.0
hf-xet==1.6.0
hpack==4.1.0
httpcore==1.0.9
httpx==0.28.1
huggingface_hub==1.33.0
hyperframe==6.1.0
idna==3.20
Jinja2==3.1.6
markdown-it-py==4.2.0
MarkupSafe==3.0.3
mdurl==0.1.2
mpmath==1.3.0
multidict==6.4.4
networkx==3.7
numpy==2.5.3
nvidia-cublas==13.1.1.3
nvidia-cuda-cupti==13.0.85
nvidia-cuda-nvrtc==13.0.88
nvidia-cuda-runtime==13.0.96
nvidia-cudnn-cu13==9.24.0.43
nvidia-cufft==12.0.0.61
nvidia-cufile==1.15.1.6
nvidia-curand==10.4.0.35
nvidia-cusolver==12.0.4.66
nvidia-cusparse==12.6.3.3
nvidia-cusparselt-cu13==0.8.1
nvidia-nccl-cu13==2.30.7
nvidia-nvjitlink==13.4.92
nvidia-nvshmem-cu13==3.4.5
nvidia-nvtx==13.0.85
packaging==26.3
pillow==12.3.0
pip==25.1.1
propcache==0.3.1
protobuf==6.31.1
psutil==7.2.2
Pygments==2.21.0
PyYAML==6.0.3
regex==2026.9.29
rich==15.0.0
safetensors==0.8.0
setuptools==84.0.0
shellingham==1.5.4
sympy==1.14.0
tokenizers==0.23.2
torch==2.14.1
torchvision==0.29.1
tqdm==4.70.1
transformers==5.18.0
triton==3.8.0
typer==0.27.2
typing_extensions==4.16.0
uv==0.7.19
wheel==0.45.1
yarl==1.20.0

入手方法

Clefの重みと関連コードは、Hugging FaceのリポジトリからApache-2.0ライセンスのもとで入手可能です。ゲートモデルではないため、特別な同意手続きなしで直接ダウンロードできます。

配布形式は標準的な safetensors 形式で、モデル本体の重み（model-*.safetensors）に加えて、意思決定用のヘッド重み（joint_head.safetensors）およびPython用のスクリプト（joint_schema_model.py）が同梱されています。

動作の前提環境として、Pythonライブラリの torch（2.11でテスト済み）および transformers（5.10.2でテスト済み）が必要です。画像や動画を入力として扱う場合は、画像処理ライブラリの pillow も用意する必要があります。

モデルの取得と読み込みは、huggingface_hub ライブラリの snapshot_download 関数を利用して行います。以下は、モデルをダウンロードして推論を実行するPythonコードの例です。

import sys
import torch
from huggingface_hub import snapshot_download

path = snapshot_download("Cloudflare/clef")
sys.path.insert(0, path)
from joint_schema_model import collate_records, encode_record, load_release_model

model, processor = load_release_model(path, device="cuda")

record = {
    "state": {"invoice": {"vendor": "Acme", "total": 1250.0, "currency": "USD", "status": "overdue"}},
    "questions": {
        "status": {
            "type": "choice",
            "instructions": "What is the invoice status?",
            "criteria": {"paid": "Invoice is paid.", "overdue": "Invoice is past due.", "draft": "Not sent."},
        },
        "large": {"type": "noul", "instructions": "Is the total above 1000 USD?"},
    },
}

encoded = encode_record(processor.tokenizer, record, processor=processor)
batch = collate_records([encoded], processor.tokenizer.pad_token_id, torch.device("cuda"))
with torch.inference_mode():
    logits = model(batch)[0]

for question, question_logits in zip(encoded.questions, logits):
    probabilities = question_logits.float().softmax(-1).tolist()
    print(question.question_id, dict(zip(question.option_ids, probabilities)))

Jev / SystemOne APIと互換のある形式で推論を行いたい場合は、同梱されている systemone 関数を使用することで、POST /v1/systemone リクエストと同様のデータ構造で結果を取得できます。

関連記事

• 「clef」構造化出力に特化した27Bの意思決定モデル：必要VRAM 80GB〜
• 「Qwen3.8-27B」マルチモーダル視覚言語モデル：当サイトでの回答例・必要VRAM 8GB〜・GGUF版あり
• 「Ternary-Bonsai-2-27B-gguf」テキスト生成モデル：必要VRAM 8GB〜
• 「Qwopus3.8-27B-Flash-GGUF」VLMモデル：当サイトでの回答例・必要VRAM 16GB〜

次に読むなら

• GPUのVRAMから探す(このモデルは80GBの階層から動きます) → VRAM別 ローカルモデル早見表
• 同じモデル系統を調べる → Qwen3.8 系統のまとめ(記事9本・変換版11件)
• このモデルを動かすエンジンを調べる → vLLM
• このモデルを入手できる形式を調べる → Safetensors形式の解説と対応モデル
• 公開元について調べる → Alibaba(Qwen) のモデル・ライセンス・記事のまとめ

出典

• https://huggingface.co/Cloudflare/clef
• https://blog.cloudflare.com/clef-decision-models

更新履歴

• 2026-10-03: 当サイトでの実測(意思決定モデルとしての判定の評価)を追加しました。