主要な発見
  • MoEアーキテクチャ（DeepSeek-V3の671Bモデルなど）は推論ごとに37Bのパラメータのみを活性化します——「脳の区分化」戦略を用いて超大規模モデルの経済的推論を実現しています
  • Speculative Decodingは小型モデルに大型モデルの「下書き」をさせることで、数学的に同一の出力を維持しながら2〜3倍の高速化を達成します——精度損失ゼロを保証する唯一の高速化技術です
  • Token MergingはViTのトークン数を精度低下0.2%未満で半減させます。Stable Diffusionに適用すると、視覚的にほぼ区別がつかない品質で2倍の高速化を達成します
  • DeepCacheは拡散モデルの冗長なU-Net計算をスキップし、学習不要で2.3倍の高速化を達成します——Token Mergingと組み合わせると4倍を超えることも可能です

1. AIの「一律計算」ジレンマ：すべてのトークンに同じ計算コストを支払っている

プルーニング、蒸留、量子化——これら3つの主要なモデル圧縮技術には共通の特性があります。それは、デプロイメント前にモデルのサイズや精度を恒久的に変更することです。圧縮が完了すると、モデルはすべての入力に対して同じ計算量を投資します。しかし現実は教えてくれます。すべての入力が同じ難易度ではありません。

契約書を処理する翻訳システムを想像してみてください。「The」はほぼ思考を必要としませんが、「indemnification（免責）」は正確な翻訳のためにモデルが全パラメータを動員する必要があるかもしれません。従来のモデルは両方の単語に全く同じ計算量を投資しています——これは体系的な無駄です。Harvard Business Reviewは[1]、グローバルなAIインフラのエネルギー消費が驚くべき速度で増加しており、計算量の相当部分が「不要な計算」に費やされていると指摘しています。

MIT Sloan Management Reviewの研究[2]はさらに、効率的なAIデプロイメントは最大のモデルを追求するよりも高いビジネスリターンをもたらすことが多いと指摘しています。動的計算はこの問題に対処する技術パラダイムです。入力の難易度に基づいてモデルが自動的に計算投資を調整できるようにするのです。単純な入力は素早く通過し、複雑な入力のみが全リソースを動員します。

静的圧縮とは異なり、動的計算はモデルのサイズや精度を変更しません——モデルはフル機能を維持しつつ、必要な時にのみそれを使用します。これにより、動的計算はモデル効率の第4の柱となり、プルーニング、蒸留、量子化と完全に直交し、スタック可能です。

2. 技術的進化：適応的計算から条件付き推論へ

2.1 Adaptive Computation Time：ネットワークに「どれだけ考えるか」を決めさせる

動的計算の理論的ルーツは2016年に遡ります。Alex GravesはAdaptive Computation Time（ACT）[3]を提案しました。リカレントニューラルネットワーク（RNN）に各入力が必要とする計算ステップ数を学習させるものです。ネットワークは「停止確率」を使って計算を停止するタイミングを決定します——単純な入力は1ステップで十分ですが、複雑な入力は「もう数ステップ考える」ことができます。

ACTの核心的洞察は革命的でした。計算量そのものがモデルの学習可能な出力になり得るということです。この概念は後続のすべての動的計算技術の基盤を築きました——Early ExitからMixture of Expertsまで、すべてがこのアイデアの異なるエンジニアリング実装です。

2.2 Early Exit：単純なトークンを早めに卒業させる

現代のTransformerアーキテクチャモデルは通常、数十のレイヤーを持っています。しかし、すべての入力がすべてのレイヤーを通過する必要があるのでしょうか？GoogleのCALM（Confident Adaptive Language Modeling）[4]がNeurIPS 2022で証明したところ、答えはノーです。

CALMのメカニズムは直感的でエレガントです。各レイヤーの出力に軽量な「信頼度分類器」を付加します。あるトークンの予測信頼度がしきい値を超えると、そのトークンは早期に終了できます——残りのレイヤーを通過する必要がなくなるのです。CALMはT5モデルで印象的な結果を示しました。平均計算量が3分の1に削減されながら、出力品質はほぼ変わりませんでした。

MicrosoftのSkipDecode[5]はさらに、Early Exitの実運用デプロイメントにおける問題点——バッチ推論の効率性——に取り組みました。バッチ内では、異なるシーケンスが異なる計算深度を必要とします。SkipDecodeはトークンレベルのレイヤースキップ戦略と適応型KVキャッシュを使用し、異なるシーケンスが異なるレイヤーで終了しながらも、バッチ推論のハードウェア効率を維持することを可能にしました。

2.3 Mixture of Experts：必要なエキスパートだけを活性化する

Early Exitが「垂直方向」の動的計算（何層通過するかを選択）だとすれば、Mixture of Experts（MoE）は「水平方向」の動的計算です——各レイヤー内でパラメータのサブセットのみを活性化します。

Switch Transformer[6]（JMLR 2022）はMoEアーキテクチャのマイルストーンでした。GoogleのWilliam Fedusらは各FFNレイヤーを複数の「エキスパート」サブネットワークに置き換え、各トークンを1つのエキスパートにのみルーティングしました（top-1ルーティング）。この一見シンプルな設計でモデルを1.6兆パラメータまでスケーリングしました——しかし各推論ではそのごく一部しか使用しません。

Mistral AIのMixtral 8x7B[7]はMoEを実用的なデプロイメントに持ち込みました。トークンごとに8つのエキスパートから2つを選択（top-2ルーティング）し、総パラメータ46.7Bですがトークンごとの活性化は12.9Bのみ——計算量5分の1以下でLLaMA-2 70Bと同等の性能を達成しました。Mixtralは、MoEが研究コンセプトだけでなく、直接デプロイ可能な効率的アーキテクチャ設計であることを証明しました。

DeepSeek-V3[8]は現在のMoEアーキテクチャの頂点を代表しています。総パラメータ671Bの中に256のルーテッドエキスパートと1つの共有エキスパートがあり、トークンごとにtop-8を選択し、実際には約37Bのパラメータを活性化します。Multi-head Latent Attention（MLA）によるKVキャッシュ圧縮と組み合わせ、DeepSeek-V3は複数のベンチマークでGPT-4oやClaude 3.5 Sonnetと競合しています——しかし学習コストはわずか約557万ドル（2,048基のH800 GPUで約2ヶ月）で、同等の密なモデルの10分の1以下です。

モデル総パラメータ活性化パラメータ活性化率ルーティング戦略
Switch Transformer1.6T~数B<1%Top-1
Mixtral 8x7B46.7B12.9B28%Top-2 / 8エキスパート
DeepSeek-V3671B37B5.5%Top-8 / 256エキスパート

2.4 Speculative Decoding：小型モデルに大型モデルの「下書き」をさせる

自己回帰言語モデルには根本的なボトルネックがあります。各トークンは前のトークンが生成されるのを待ってからでないと開始できません。つまり、Nトークンの生成にはN回のフォワードパスが必要で、並列化ができません。Speculative decodingは巧妙な「下書き＋検証」メカニズムでこのボトルネックを打破します。

2022〜2023年に、GoogleのLeviathanら[9]とDeepMindのChenら[10]が独立して同じコアアイデアを提案しました。

  1. 小型のドラフトモデル（例：OPT-125M）を使って、K個の候補トークンを素早く生成する
  2. K個のトークンをすべて一度に大型モデルに入力して検証する（大型モデルはこれらを並列処理可能）
  3. 棄却サンプリングを使って、各候補トークンを受け入れるか棄却するかを決定する

重要なブレークスルーは数学的保証にあります。最終的な出力確率分布は、大型モデルを単独で使用した場合と完全に同一なのです。これは「近似」ではなく、数学的に厳密に等価です。これにより、speculative decodingは唯一の精度損失ゼロの推論高速化技術となっています。実際には2〜3倍の高速化を達成し、大型モデルと小型モデルの能力差が適度な場合に最も良い性能を発揮します。

ICML 2024のMedusa[11]はさらにエレガントなアプローチを提案しました。別途ドラフトモデルを必要とせず、元のモデルに直接複数のデコーディングヘッドを追加します。各ヘッドは異なる位置の将来のトークンを予測し、ツリーアテンションメカニズムで一括検証します。Medusaの利点はデプロイメントがよりシンプルなこと（モデルが1つだけで済む）であり、デコーディングヘッドは最小限のファインチューニングのみを必要とします。

2.5 Token Merging：冗長なトークンをマージする

Vision Transformer（ViT）は画像をN個のパッチトークンに分割して処理します。しかし多くのパッチは非常に冗長です——青空の隣接パッチはほぼ同一の情報を持っています。Token Merging（ToMe）[12]（ICLR 2023）は次の戦略を取ります。各Transformerレイヤー内で最も類似したトークンをマージするのです。

ToMeは二部ソフトマッチングを使って最適なマージペアを見つけます。このアルゴリズムは新しい学習可能パラメータも再学習も不要で、事前学習済みViTに直接適用できます。ImageNetでは、ToMeはViT-L/16のスループットを精度低下わずか0.2%で2倍に向上させました。

さらにエキサイティングなのは、ToMeの拡散モデルへの応用[13]です。Stable Diffusionの各デノイジングステップはU-Net（アテンションレイヤーを含む）を通過し、ToMeは各ステップで冗長なトークンをマージできます。tomesd[14]ライブラリを使えば、たった1行のコードでSDを2倍に高速化でき、画像品質はほとんど区別がつきません。さらに、ToMeは他の高速化技術とスタック可能で、論文では最大5.4倍の高速化が報告されています。

2.6 Mixture-of-Depths：各レイヤーが計算するかどうかを決定する

MoEが「どのエキスパートを使うか」を選択するものだとすれば、Google DeepMindのMixture-of-Depths（MoD）[15]はより過激です——トークンに「このレイヤーを通過するかどうか」を選択させるのです。

MoDは各レイヤーに軽量なルーターを追加し、トークンの重要度に基づいて現在のレイヤーを「スキップ」させるかどうかを決定します。スキップされたトークンは残差接続を通じて次のレイヤーに直接渡され、計算量はゼロです。論文は驚くべき結論を見出しました。計算容量がわずか12.5%（レイヤーごとにトークンの1/8のみ処理）であっても、モデルはフル容量版の性能に匹敵できたのです。これは理論的に、MoDがモデル品質を維持しながら推論を50%以上高速化できることを意味します。

MoDの意義は、Transformer計算における驚異的な冗長性を明らかにしたことにあります——ほとんどのレイヤーのほとんどのトークンは、実際には処理する必要がないのです。

2.7 特徴キャッシング：冗長なデノイジング計算をスキップする

拡散モデルの推論は数十回のデノイジング反復を必要とし、各回で完全なU-Netを通過します。しかし隣接するステップ間で、U-Netの高レベル特徴の変化は実際にはごくわずかです。DeepCache[16]（CVPR 2024）はこの観察を活用します。高レベル特徴をキャッシュし、より変化が大きい低レベル特徴のみを更新するのです。

具体的には、Nステップごとにのみ完全なU-Netを実行し、中間ステップでは低レベルブランチのみを実行しながら高レベル特徴はキャッシュから直接読み取ります。Stable Diffusion 1.5において、DeepCacheはCLIP ScoreとFIDがほぼ変わらないまま2.3倍の高速化を達成しました。さらに重要なのは：

3. テキスト生成AIにおける実用的応用

テキスト生成AIにおける動的計算の応用は、研究段階からプロダクション段階へと移行しています。以下に最もインパクトの大きい3つのデプロイメントシナリオを紹介します。

シナリオ1：大規模LLMサービス——MoEアーキテクチャ

DeepSeek-V3の成功は重要なテーゼを証明しています。次世代のフロンティアモデルは必ずしもより多くの計算を必要としません——よりスマートな計算配分が必要なのです。671Bパラメータモデルは高コストに聞こえますが、各推論で活性化されるのはわずか37Bで、その推論コストは30〜40Bの密なモデルに近いものです。Mixtral 8x7Bの商用版（Mistral APIまたはAWS Bedrockでデプロイ）は企業に広く採用されており、推論速度6倍以上でLLaMA-2 70Bレベルの品質を提供しています。

シナリオ2：低レイテンシアプリケーション——Speculative Decoding

対話AI、リアルタイム翻訳、コード自動補完などのアプリケーションはレイテンシに極めて敏感です。Speculative decodingは品質を一切犠牲にすることなく、大型モデルの応答速度を2〜3倍に向上させます。HuggingFaceはTransformers v4.29+でこれをネイティブサポートしており[17]、assistant_modelパラメータ1つを設定するだけで有効化できます。GoogleのGeminiやAnthropicのClaudeも推論エンジンで同様の技術を広く使用しています。

シナリオ3：分類と理解——Early Exit

テキスト分類、感情分析、エンティティ認識などの理解タスクでは、ほとんどの入力がモデルの全深度を必要としません。CALMの早期終了メカニズムにより、モデルは80%の単純な入力を最初の数レイヤーで処理し、最も難しい20%のみがすべてのレイヤーを通過する必要があります。これは大量のリクエストを処理するAPIサービスに特に適しており、平均レイテンシを2〜3倍削減できます。

4. 画像生成AIにおける実用的応用

拡散モデルはLLMよりも推論コストが高く（数十回のデノイジングステップ × 大規模U-Net）、この領域では動的計算の価値がさらに大きくなります。

シナリオ1：Token Mergingによる生成高速化

tomesd[14]はStable Diffusionの各デノイジングステップで冗長なトークンをマージします。マージ率50%の場合、SD 1.5の生成速度は約2倍に向上し、VRAM使用量も削減されながら、品質の差は人間の目にはほとんど見えません。これはeコマース、広告、デザインワークフローでバッチ画像生成が必要な場面で特に価値があります。

シナリオ2：DeepCacheによるキャッシュベースの高速化

DeepCache[18]はSD、SDXL、Stable Video Diffusionで2倍以上の高速化を実証しています。SDXL（より多くのVRAMを必要とする）では、DeepCacheの節約効果はさらに顕著で、元々ハイエンドGPUが必要だったモデルをミッドレンジデバイスでスムーズに動作させることが可能になります。

シナリオ3：技術スタッキング——究極の高速化

動的計算の最も強力な特性の一つは、技術がスタック可能であることです。Stable Diffusionで同時に以下を使用すると：

3つすべてをスタックすると4〜8倍のエンドツーエンド高速化を達成でき、Stable Diffusionをコンシューマ向けGPUでリアルタイム生成に近づけます。

5. ハンズオンラボ：Token Merging（コンピュータビジョン）

最も直感的な技術から始めましょう——ViTにToken Mergingを実装し、「冗長なトークンをマージする」ことで推論がどのように高速化されるかを実際に体験します。

Google Colabを開く（CPUでも動作、T4の方が高速）、新しいNotebookを作成し、以下のコードブロックを順番に貼り付けてください。

5.1 ステップ1——環境設定とモデル読み込み

!pip install timm tome Pillow requests -q

import timm
import tome
import torch
import time
import requests
from PIL import Image
from io import BytesIO

# サンプル画像をダウンロード（Wikipediaの猫）
url = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Cat_November_2010-1a.jpg/1200px-Cat_November_2010-1a.jpg"
img = Image.open(BytesIO(requests.get(url).content)).convert("RGB")

# 事前学習済みViT-Base/16を読み込み（約86Mパラメータ）
model = timm.create_model("vit_base_patch16_224", pretrained=True)
model.eval()

# 画像の前処理
data_config = timm.data.resolve_model_data_config(model)
transform = timm.data.create_transform(**data_config, is_training=False)
x = transform(img).unsqueeze(0)  # [1, 3, 224, 224]

# ImageNetラベル
labels_url = "https://storage.googleapis.com/bit_models/ilsvrc2012_wordnet_lemmas.txt"
labels = requests.get(labels_url).text.strip().split("\n")

print(f"モデル読み込み完了: ViT-Base/16")
print(f"  パラメータ数: {sum(p.numel() for p in model.parameters()) / 1e6:.1f}M")
print(f"  入力トークン数: {(224//16)**2 + 1} = 196パッチトークン + 1 clsトークン")

5.2 ステップ2——ベンチマークツール

def benchmark(model, x, n_warmup=20, n_runs=200):
    """CPU推論レイテンシを測定（ミリ秒）"""
    for _ in range(n_warmup):
        with torch.no_grad():
            model(x)
    start = time.perf_counter()
    for _ in range(n_runs):
        with torch.no_grad():
            model(x)
    return (time.perf_counter() - start) / n_runs * 1000

def predict(model, x, labels):
    """予測結果を取得"""
    with torch.no_grad():
        logits = model(x)
    probs = logits.softmax(-1)
    top_prob, top_idx = probs.max(-1)
    return labels[top_idx.item()], top_prob.item() * 100

# ---- ベースラインデータ ----
pred, conf = predict(model, x, labels)
base_ms = benchmark(model, x)

print(f"{'='*60}")
print(f"  ベースラインモデル（ViT-Base/16、Token Mergingなし）")
print(f"{'='*60}")
print(f"  予測結果: {pred}")
print(f"  信頼度: {conf:.1f}%")
print(f"  推論レイテンシ: {base_ms:.2f} ms")
print(f"{'='*60}")

5.3 ステップ3——Token Mergingを適用

# ★ Token Merging：1行で適用 ★
# tome.patch.timmがモデルのforwardを修正し、レイヤーごとにr個のトークンをマージ
tome.patch.timm(model)

print(f"\n{'='*60}")
print(f"  Token Merging 効果比較")
print(f"{'='*60}")
print(f"{'r値':<8} {'レイテンシ(ms)':<12} {'高速化':<8} {'予測結果':<25} {'信頼度'}")
print(f"{'-'*60}")

for r in [0, 4, 8, 16, 24, 32]:
    model.r = r  # レイヤーごとにr個のトークンをマージ
    pred, conf = predict(model, x, labels)
    ms = benchmark(model, x)
    speedup = base_ms / ms
    marker = " ★ 推奨" if r == 16 else ""
    print(f"r={r:<5} {ms:<11.2f} {speedup:<7.2f}x {pred:<25} {conf:.1f}%{marker}")

print(f"{'='*60}")
print(f"\n★ 主要な観察:")
print(f"  - r=0は元のモデルと同等（マージなし）")
print(f"  - r=16は品質と速度の最適なバランス")
print(f"  - r=32（積極的なマージ）でも、予測は通常正確なまま")
print(f"  - ViT-Baseは12レイヤー -> r=16はレイヤーごとに16トークンペアをマージ")
print(f"  - 完全に学習不要——任意の事前学習済みViTに直接適用可能")

6. ハンズオンラボ：Speculative Decoding（言語モデル）

次はLLMにとって最も実用的な動的計算技術——speculative decodingです。HuggingFaceのネイティブassistant_model API[17]を使って、「小型モデルに大型モデルの下書きをさせる」体験をします。

Google Colabを開く（T4 GPUを選択）、新しいNotebookを作成し、以下のコードブロックを順番に貼り付けてください。

6.1 ステップ1——ターゲットモデルとドラフトモデルの読み込み

!pip install transformers accelerate -q

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import time

# ★ 重要：同じファミリーの大小2つのモデル ★
target_name = "facebook/opt-1.3b"   # ターゲットモデル：1.3Bパラメータ
draft_name  = "facebook/opt-125m"   # ドラフトモデル：125Mパラメータ（10倍小さい）

print("ターゲットモデルを読み込み中（1.3B）...")
tokenizer = AutoTokenizer.from_pretrained(target_name)
target_model = AutoModelForCausalLM.from_pretrained(
    target_name, torch_dtype=torch.float16, device_map="auto"
)

print("ドラフトモデルを読み込み中（125M）...")
draft_model = AutoModelForCausalLM.from_pretrained(
    draft_name, torch_dtype=torch.float16, device_map="auto"
)

target_mem = sum(p.numel() * p.element_size() for p in target_model.parameters()) / 1024**3
draft_mem = sum(p.numel() * p.element_size() for p in draft_model.parameters()) / 1024**3
print(f"\nモデル読み込み成功")
print(f"  ターゲットモデル: {target_name} ({target_mem:.2f} GB)")
print(f"  ドラフトモデル: {draft_name} ({draft_mem:.2f} GB)")
print(f"  ドラフトモデルはターゲットモデルのわずか{draft_mem/target_mem*100:.1f}%")

6.2 ステップ2——標準生成 vs. Speculative Decoding

prompts = [
    "The key advantage of dynamic computation in AI is",
    "Large language models can be accelerated by",
    "In the future, efficient AI inference will",
]

print(f"{'='*70}")
print(f"  標準生成 vs. Speculative Decoding 比較")
print(f"{'='*70}")

total_standard, total_spec = 0, 0

for prompt in prompts:
    inputs = tokenizer(prompt, return_tensors="pt").to(target_model.device)

    # ---- 標準生成（トークンごとに逐次） ----
    torch.cuda.synchronize()
    start = time.perf_counter()
    out_standard = target_model.generate(
        **inputs, max_new_tokens=80, do_sample=False
    )
    torch.cuda.synchronize()
    t_standard = time.perf_counter() - start

    # ---- Speculative decoding（assistant_model） ----
    torch.cuda.synchronize()
    start = time.perf_counter()
    out_spec = target_model.generate(
        **inputs, max_new_tokens=80, do_sample=False,
        assistant_model=draft_model,  # ★ このパラメータを追加するだけ ★
    )
    torch.cuda.synchronize()
    t_spec = time.perf_counter() - start

    total_standard += t_standard
    total_spec += t_spec
    tokens = out_standard.shape[1] - inputs["input_ids"].shape[1]

    print(f"\n  プロンプト: {prompt}")
    print(f"  標準: {t_standard:.2f}s | Speculative: {t_spec:.2f}s | "
          f"高速化: {t_standard/t_spec:.2f}x | トークン数: {tokens}")

    # 出力が同一であることを検証（speculative decodingの数学的保証）
    match = torch.equal(out_standard, out_spec)
    print(f"  出力一致: {'はい' if match else 'いいえ'}")

6.3 ステップ3——統計まとめ

print(f"\n{'='*70}")
print(f"  Speculative Decoding サマリー")
print(f"{'='*70}")
print(f"  標準生成合計時間:           {total_standard:.2f}s")
print(f"  Speculative decoding合計時間: {total_spec:.2f}s")
print(f"  総合高速化率:               {total_standard/total_spec:.2f}x")
print(f"{'='*70}")
print(f"\n★ 主要な観察:")
print(f"  - 出力は標準生成と数学的に同一（精度損失ゼロ）")
print(f"  - 高速化はドラフトモデルの「ヒット率」に依存")
print(f"  - ドラフトモデルの分布がターゲットに近いほど -> 高速化が大きい")
print(f"  - 同じファミリーのモデル（例：OPT-125M -> OPT-1.3B）が最も効果的")
print(f"  - HuggingFace Transformers v4.29+でネイティブサポート")
print(f"  - 量子化とスタック可能：4ビットターゲットモデル + 小型ドラフトモデル")

7. ハンズオンラボ：DeepCache + ToMe（拡散モデル高速化）

最後に、2つの動的計算技術——DeepCache（特徴キャッシング）とToMe（トークンマージ）——をStable Diffusionにスタックし、「学習不要」の高速化の威力を体験します。

Google Colabを開く（T4 GPUを選択）、新しいNotebookを作成し、以下のコードブロックを順番に貼り付けてください。

7.1 ステップ1——環境設定

!pip install diffusers transformers accelerate DeepCache tomesd -q

import torch
import time
from diffusers import StableDiffusionPipeline

# Stable Diffusion 1.5を読み込み
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16,
    safety_checker=None,
)
pipe = pipe.to("cuda")

prompt = "a photorealistic mountain landscape at golden hour, 8k detailed"
gen = torch.Generator("cuda").manual_seed(42)

print("Stable Diffusion 1.5 読み込み成功")
print(f"  VRAM使用量: {torch.cuda.memory_allocated()/1024**3:.2f} GB")

7.2 ステップ2——ベースライン生成

# ---- ベースライン：標準50ステップ生成 ----
gen = torch.Generator("cuda").manual_seed(42)
torch.cuda.synchronize()
start = time.perf_counter()
image_base = pipe(prompt, num_inference_steps=50, generator=gen).images[0]
torch.cuda.synchronize()
base_time = time.perf_counter() - start

print(f"ベースライン（50ステップ標準生成）: {base_time:.2f}s")
image_base.save("01_baseline.png")

7.3 ステップ3——DeepCache高速化

from DeepCache import DeepCacheSDHelper

# ★ DeepCache：U-Netの高レベル特徴をキャッシュ ★
helper = DeepCacheSDHelper(pipe=pipe)
helper.set_params(
    cache_interval=3,    # 3ステップごとにのみ完全なU-Net計算を実行
    cache_branch_id=0,   # どのレイヤーの特徴をキャッシュするか
)
helper.enable()

gen = torch.Generator("cuda").manual_seed(42)
torch.cuda.synchronize()
start = time.perf_counter()
image_dc = pipe(prompt, num_inference_steps=50, generator=gen).images[0]
torch.cuda.synchronize()
dc_time = time.perf_counter() - start

helper.disable()
print(f"DeepCache (interval=3): {dc_time:.2f}s (高速化 {base_time/dc_time:.2f}x)")
image_dc.save("02_deepcache.png")

7.4 ステップ4——ToMe高速化

import tomesd

# ★ ToMe：冗長なトークンをマージ ★
tomesd.apply_patch(pipe, ratio=0.5)  # トークンの50%をマージ

gen = torch.Generator("cuda").manual_seed(42)
torch.cuda.synchronize()
start = time.perf_counter()
image_tome = pipe(prompt, num_inference_steps=50, generator=gen).images[0]
torch.cuda.synchronize()
tome_time = time.perf_counter() - start

tomesd.remove_patch(pipe)
print(f"ToMe (ratio=0.5): {tome_time:.2f}s (高速化 {base_time/tome_time:.2f}x)")
image_tome.save("03_tome.png")

7.5 ステップ5——DeepCache + ToMe スタック

# ★ 両方をスタック：DeepCache + ToMe ★
tomesd.apply_patch(pipe, ratio=0.5)
helper = DeepCacheSDHelper(pipe=pipe)
helper.set_params(cache_interval=3, cache_branch_id=0)
helper.enable()

gen = torch.Generator("cuda").manual_seed(42)
torch.cuda.synchronize()
start = time.perf_counter()
image_both = pipe(prompt, num_inference_steps=50, generator=gen).images[0]
torch.cuda.synchronize()
both_time = time.perf_counter() - start

helper.disable()
tomesd.remove_patch(pipe)
print(f"DeepCache + ToMe: {both_time:.2f}s (高速化 {base_time/both_time:.2f}x)")
image_both.save("04_deepcache_tome.png")

7.6 ステップ6——完全比較

print(f"\n{'='*60}")
print(f"  拡散モデル 動的高速化 完全比較")
print(f"  Stable Diffusion 1.5 / 50ステップ / T4 GPU")
print(f"{'='*60}")
print(f"{'手法':<20} {'時間(s)':<10} {'高速化':<8} {'学習が必要？'}")
print(f"{'-'*60}")

results = [
    ("標準（ベースライン）", base_time, 1.0, "—"),
    ("DeepCache", dc_time, base_time/dc_time, "不要"),
    ("ToMe (50%)", tome_time, base_time/tome_time, "不要"),
    ("DeepCache + ToMe", both_time, base_time/both_time, "不要"),
]

for name, t, speedup, train in results:
    print(f"{name:<20} {t:<9.2f} {speedup:<7.2f}x {train}")

print(f"{'='*60}")
print(f"\n★ 主要な観察:")
print(f"  - 両技術とも完全に学習不要——プラグアンドプレイ")
print(f"  - DeepCacheとToMeの高速化効果はスタック可能")
print(f"  - INT8量子化を追加すると、総合高速化は5倍を超えることが可能")
print(f"  - 生成画像をファイルで比較して品質差を確認（通常は知覚できない）")
print(f"  - これらの技術はSDXLやStable Video Diffusionにも適用可能")

8. エコシステムツールの全体像

動的計算のツールエコシステムは急速に成熟しており、研究プロトタイプからプロダクションデプロイメントまでをカバーするソリューションが揃っています。

Mixture of Expertsフレームワーク

Speculative Decoding

Token Merging

拡散モデル高速化

9. 技術指標からビジネスインパクトへ

動的計算が企業のAIデプロイメントに与える影響は多面的です。

10. 導入パス：3段階デプロイメント戦略

  1. 即効性のある成果——既存の動的計算モデルとツールを活用：Mixtral 8x7BまたはDeepSeek-V3をLLM推論バックエンドとしてデプロイ（vLLM/SGLang経由）、画像生成にはtomesd + DeepCacheを追加（2行のコードで学習不要）。これらの操作はモデルの変更を必要とせず、1日で完了できます
  2. 段階的な検証——speculative decodingで既存モデルを高速化：既存のLLMに同じファミリーの小型ドラフトモデルをペアリングし（例：Phi-3-miniとPhi-3-small）、HuggingFaceのassistant_modelパラメータでspeculative decodingを有効化します。レイテンシの削減と出力の一貫性を測定し、ユースケースへの適合性を確認します
  3. 深層最適化——フルスタックの動的計算統合：標準的なspeculative decodingの代替としてMedusaやEAGLEを検討（より高い高速化）、MoEのファインチューニングを評価（例：MixtralでLoRAによる特定エキスパートのファインチューニング）、動的計算を量子化やプルーニングと組み合わせて完全な推論効率スタックを構築します。画像生成パイプラインでは、DeepCache + ToMe + INT8量子化をスタックし、5倍以上のエンドツーエンド高速化を目標にします

動的計算はモデル効率の「第4の柱」です——モデルのサイズや精度を変更せず、モデルに「文脈に応じて努力を調整する」ことを教えます。プルーニング（パラメータの恒久的除去）、蒸留（新しいモデルの学習）、量子化（精度の低下）とは異なり、動的計算はモデルにフル機能を維持させながら、計算リソースをよりインテリジェントに配分するだけです。これら4つの技術は完全に直交しスタック可能であり、AIをラボから大規模デプロイメントへと導くための完全なツールボックスを形成します。

モデル品質を犠牲にすることなく推論コストを劇的に削減する方法を評価しているチーム、またはレイテンシに敏感なシナリオで大型モデルの応答を高速化する必要がある場合は、深い技術的な議論を歓迎します。Meta Intelligenceのリサーチチームが、パフォーマンスボトルネックの診断からフルスタック最適化デプロイメントまでの完全な旅路をお手伝いします。