ニューラルネットワークプルーニング完全ガイド：Lottery TicketからSparseGPT

1. AIの隠れたコスト危機：「大きいほど良い」が企業に跳ね返る理由

2024年、世界の企業AIインフラ投資は600億ドルに迫り、その約60%がアプリケーションではなく計算とハードウェアに流れた。Harvard Business Reviewは^[1]、AIシステムのカーボンフットプリントが驚くべき速度で拡大していると指摘している——最適化なしでは、AIは2030年までに年間2,400万〜4,400万トンのCO2を排出し、これは500万〜1,000万台の自動車を追加するのと同等である。さらに重要なことに、ゴールドマン・サックスはAI駆動の電力需要が2030年までに160%増加すると予測しており、計算コストは上昇し続けることを意味する。

しかし、ほとんどの企業が見落としている事実がある。あなたは「仕事をしない」膨大な数のパラメータに対して費用を支払っている。Song HanらのNeurIPS 2015での先駆的研究^[2]は、AlexNetの6,100万パラメータの90%を精度に影響を与えることなく直接削除できることを確認した。VGG-16はさらに印象的な13倍の圧縮率を達成した——1億3,800万パラメータから1,030万パラメータへ、精度は完全に維持された。つまり、GPU代金の90%は「ノイズ」の計算に費やされている可能性がある。

MIT Sloan Management Reviewの研究^[3]は、経営の観点からこの洞察を裏付けている。より小さく、より精密なAIデプロイメントは、「大きいほど良い」戦略よりも高いビジネスリターンをもたらすことが多い。問題はモデルが十分に大きくないことではなく、モデルを「ちょうど良いサイズ」にする方法をまだ学んでいないことである。プルーニングはこの矛盾を解決する最も成熟した、最も直接的な技術的アプローチである。

2. 技術的進化：経験則から理論的ブレークスルーへ

2.1 マグニチュードプルーニング：最もシンプルで効果的な出発点

マグニチュードプルーニングのロジックは極めて直感的である。重みの絶対値が小さいほど、モデル出力への影響が小さいため、最初に削除できる。Song HanらはNeurIPS 2015の論文^[2]でこのアプローチを体系的に検証し、後にDeep Compression研究^[4]で量子化とハフマン符号化を組み合わせ、35〜49倍の圧縮率を達成した。Deep Compression論文はICLR 2016最優秀論文賞を受賞し、モデル圧縮分野のマイルストーンとなった。

マグニチュードプルーニングには2つの形式がある。

• 非構造化プルーニング：ネットワーク内の位置に関係なく個々の重みを削除する。極めて高いスパース率（90%以上）を達成できるが、結果として生じる不規則なスパース行列は、実際の高速化に変換するために専用ハードウェアのサポートが必要。
• 構造化プルーニング：畳み込みフィルタ、チャネル、またはアテンションヘッド全体を削除する。圧縮率は通常、非構造化プルーニングより低いが、モデルが実際に小さくなり、標準ハードウェアで直接的な推論高速化が得られる。

2.2 Lottery Ticket仮説：大規模ネットワーク内に隠された「当たりくじ」

2019年、MITのJonathan FrankleとMichael CarbinはLottery Ticket仮説（LTH）^[5]を提唱した。このICLR 2019最優秀論文賞を受賞した研究は、驚くべき発見を明らかにした。

ランダムに初期化された大規模ネットワーク内に、元の初期化値でゼロから学習した場合にフルネットワークの精度に匹敵、あるいは上回ることができるスパース部分ネットワーク（「当たりくじ」）が存在する。

MNISTとCIFAR-10での実験では、元のパラメータのわずか10〜20%を保持する部分ネットワーク内に「当たりくじ」が発見された。さらに興味深いことに、これらの部分ネットワークはフルネットワークよりも速く学習し、最終精度もより高かった。

LTHの意義は学術的領域を超えている。「まず大きなモデルを学習し、次に圧縮する」という従来のパラダイムに根本的に挑戦した——スパース構造は初期化の瞬間から存在しており、それを見つけるだけで良いのだ。SzeらはProceedings of the IEEEのサーベイ^[6]でさまざまな効率的推論戦略をさらに体系的に分析し、LTHのエンジニアリング実践のための理論的フレームワークを提供した。

2.3 LLM時代のプルーニング：SparseGPTとWanda

モデル規模が数百万から数千億パラメータに膨張すると、従来の「学習→プルーニング→ファインチューニング」の3ステッププロセスは実行不可能となる——1750億パラメータモデルの再学習だけで数百万ドルのコストがかかる。

2023年、FrantarとAlistarhはSparseGPT^[7]をICMLで発表し、大規模言語モデルの初の「ワンショット」プルーニングを達成した。再学習なしで、OPT-175BとBLOOM-176Bの両方が4.5時間以内に60%の非構造化プルーニングを完了し、パープレキシティはほぼ影響を受けなかった。

2024年、SunらはWanda^[8]（ICLR 2024で発表）を提案し、効率性をさらに新たな高みに押し上げた。Wandaのコアな洞察は、重みのマグニチュードだけでなく、対応する入力アクティベーションのマグニチュードも見るべきだということである——小さい重みだが大きいアクティベーションを持つ接続は、大きい重みだが小さいアクティベーションを持つ接続よりも重要かもしれない。このシンプルな改善によりWandaはSparseGPTの300倍高速になり、LLaMA-7Bの50%スパース率でパープレキシティはわずか7.26（マグニチュードプルーニングベースラインの17.29に対して）であった。

NVIDIAはさらに進み、Minitron^[9]をNeurIPS 2024で発表し、構造化プルーニングと知識蒸留を組み合わせて15Bモデルから8Bと4Bバージョンを導出した。ゼロから学習するのに必要なトークン数のわずか1/40で、MMLUベンチマークでは最大16%の改善を達成した。

3. 10年間の実証データ：CNNからLLMまでの圧縮率

4. 意思決定フレームワーク：プルーニングのメリット、コスト、適用範囲

技術的実現可能性は商業的実現可能性と同義ではない。プルーニングを技術戦略に組み込む前に、意思決定者は6つの主要な次元にわたるその影響を包括的に理解する必要がある。

戦略的優位性

• 即時のコスト削減：小さいモデル ＝ 小さいGPUインスタンス ＝ 低いクラウド料金。単一のA100で元の2〜5倍のリクエスト量を処理可能
• 極めて低い技術的障壁：PyTorchにはビルトインAPIがあり、3行のコードで開始できる。モデルアーキテクチャの変更や再学習は不要（特にSparseGPT/Wanda手法の場合）
• 他の圧縮技術との組み合わせが可能：プルーニング + 量子化 + 蒸留のパイプラインは35〜49倍の圧縮率を達成可能^[4]。単一の技術をはるかに超える
• 高い学術的成熟度：ICLR/ICMLの最優秀論文レベルの3つの出版物に裏打ちされている——これは実験的技術ではない

管理すべきリスク

• 精度-スパース率のトレードオフは非線形：50%スパース率はほぼ知覚できないが、90%を超えると精度が急落する可能性がある。各モデルの「スイートスポット」は異なり、実験で見つける必要がある
• 非構造化プルーニングの速度の幻想：重みの90%がゼロであっても、標準ハードウェア（CPU/GPU）では自動的に高速化されない——スパース計算ライブラリまたはNVIDIA Ampere以上のGPUの2:4スパースサポートが必要
• ファインチューニングコスト：高スパース率のプルーニングは通常、精度回復のためにファインチューニングが必要であり、追加の学習コストとデータ要件が発生する。LLMのファインチューニングコストは特に高い
• タスク汎化が低下する可能性：プルーニングされたモデルは学習タスクでは良好に機能するが、分布外（OOD）データに対するロバスト性が低下する場合がある
• デバッグの複雑さが増加：スパースモデルの挙動は説明やデバッグが困難になり、異常が発生した際のトラブルシューティングコストが増加する

プルーニングが適さないシナリオ

• モデルがすでに非常に小さい場合（パラメータ数 < 1M）——プルーニングのメリットは限定的だがリスクは同じ
• 精度が唯一の指標であり、一切の劣化が許容されない場合（例：医療診断、安全クリティカルシステム）
• チームにプルーニング後のモデル品質を評価・検証するMLエンジニアリング能力がない場合
• モデルが頻繁な更新や再学習を必要とする場合——更新のたびにプルーニングパイプラインの再実行が必要

5. ハンズオンラボ：Google Colabオンラインラボ（CVモデル）

理論とフレームワークの後、データに語らせよう。以下の実験ではResNet-18をCIFAR-10で学習し、50% / 70% / 90%のスパース率でプルーニングを行い、精度、推論速度、モデルサイズの変化を定量的に比較する。すべてのコードはGoogle Colabの無料GPUで直接実行可能。

Google Colabを開く。新しいNotebookを作成し、以下のコードを順番に貼り付ける。

5.1 ステップ1 — ベースラインモデルの学習（約3分）

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.utils.prune as prune
import torchvision
import torchvision.transforms as transforms
import torchvision.models as models
import time, os, copy

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Device: {device}")

# ---- Dataset ----
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)),
])
transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)),
])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform_test)
testloader = torch.utils.data.DataLoader(testset, batch_size=256,
                                         shuffle=False, num_workers=2)

# ---- Model: ResNet-18 (adapted for CIFAR-10's 32x32 input) ----
model = models.resnet18(weights=None, num_classes=10)
model.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
model.maxpool = nn.Identity()
model = model.to(device)

# ---- Train for 10 epochs (quick demo) ----
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)

for epoch in range(10):
    model.train()
    for inputs, targets in trainloader:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer.step()
    scheduler.step()
    if (epoch + 1) % 5 == 0:
        print(f"  Epoch {epoch+1}/10 complete")

print("Baseline model training complete")

5.2 ステップ2 — 評価ユーティリティ関数

def evaluate(model, dataloader, device):
    """Calculate test set accuracy"""
    model.eval()
    correct, total = 0, 0
    with torch.no_grad():
        for inputs, targets in dataloader:
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = model(inputs)
            _, predicted = outputs.max(1)
            total += targets.size(0)
            correct += predicted.eq(targets).sum().item()
    return 100. * correct / total

def measure_inference_speed(model, device, input_size=(1, 3, 32, 32), n_runs=200):
    """Measure average inference latency per image (ms)"""
    model.eval()
    dummy = torch.randn(*input_size).to(device)
    # Warmup
    for _ in range(50):
        with torch.no_grad():
            model(dummy)
    if device.type == 'cuda':
        torch.cuda.synchronize()
    start = time.perf_counter()
    for _ in range(n_runs):
        with torch.no_grad():
            model(dummy)
    if device.type == 'cuda':
        torch.cuda.synchronize()
    elapsed = (time.perf_counter() - start) / n_runs * 1000
    return elapsed

def get_model_size_mb(model):
    """Calculate model file size (MB)"""
    torch.save(model.state_dict(), "/tmp/_tmp_model.pth")
    size = os.path.getsize("/tmp/_tmp_model.pth") / 1024 / 1024
    os.remove("/tmp/_tmp_model.pth")
    return size

def count_nonzero(model):
    """Calculate non-zero parameter ratio"""
    total, nonzero = 0, 0
    for p in model.parameters():
        total += p.numel()
        nonzero += p.nonzero().size(0)
    return total, nonzero

# ---- Record baseline data ----
base_acc = evaluate(model, testloader, device)
base_speed = measure_inference_speed(model, device)
base_size = get_model_size_mb(model)
total_params, nz_params = count_nonzero(model)

print(f"{'='*55}")
print(f"  Baseline Model (ResNet-18 on CIFAR-10)")
print(f"{'='*55}")
print(f"  Accuracy:       {base_acc:.2f}%")
print(f"  Latency:        {base_speed:.2f} ms")
print(f"  Model Size:     {base_size:.2f} MB")
print(f"  Total Params:   {total_params:,}")
print(f"  Non-zero Params:{nz_params:,} (100%)")
print(f"{'='*55}")

5.3 ステップ3 — プルーニング実験：50% / 70% / 90%の比較

results = []
results.append({
    'name': 'Original',
    'sparsity': 0,
    'acc': base_acc,
    'speed': base_speed,
    'size': base_size,
    'nz': total_params,
})

for sparsity in [0.5, 0.7, 0.9]:
    # Deep copy to avoid contaminating the original model
    pruned = copy.deepcopy(model)

    # Collect prunable layers
    params_to_prune = []
    for name, module in pruned.named_modules():
        if isinstance(module, (nn.Conv2d, nn.Linear)):
            params_to_prune.append((module, 'weight'))

    # Global unstructured pruning — the core is just these 3 lines
    prune.global_unstructured(
        params_to_prune,
        pruning_method=prune.L1Unstructured,
        amount=sparsity,
    )

    # Make mask permanent
    for m, n in params_to_prune:
        prune.remove(m, n)

    # Evaluate
    pruned = pruned.to(device)
    acc = evaluate(pruned, testloader, device)
    speed = measure_inference_speed(pruned, device)
    size = get_model_size_mb(pruned)
    _, nz = count_nonzero(pruned)

    results.append({
        'name': f'{int(sparsity*100)}% Pruned',
        'sparsity': sparsity,
        'acc': acc,
        'speed': speed,
        'size': size,
        'nz': nz,
    })

# ---- Print full comparison table ----
print(f"\n{'='*70}")
print(f"  Full Comparison Before and After Pruning (ResNet-18 / CIFAR-10)")
print(f"{'='*70}")
print(f"{'Model':<12} {'Accuracy':>8} {'Acc Change':>10} {'Latency(ms)':>11} "
      f"{'Speedup':>8} {'Size(MB)':>9} {'Non-zero':>12}")
print(f"{'-'*70}")

for r in results:
    acc_delta = r['acc'] - base_acc
    speedup = base_speed / r['speed'] if r['speed'] > 0 else 0
    print(f"{r['name']:<12} {r['acc']:>7.2f}% {acc_delta:>+9.2f}% "
          f"{r['speed']:>10.2f}  {speedup:>7.2f}x "
          f"{r['size']:>8.2f}  {r['nz']:>11,}")

print(f"{'='*70}")
print("\nKey Observations:")
print(f"  - 50% pruning: accuracy change only {results[1]['acc']-base_acc:+.2f}%, nearly imperceptible")
print(f"  - 90% pruning: removed 9/10 of parameters, accuracy change {results[3]['acc']-base_acc:+.2f}%")
print(f"  - Unstructured pruning inference speed shows limited change on standard GPUs (see explanation below)")

5.4 ステップ4 — ファインチューニングによる精度回復（オプション）

# Fine-tune the 90% pruned model for 5 epochs, observe accuracy recovery
pruned_ft = copy.deepcopy(model)

# Prune
params_to_prune = []
for name, module in pruned_ft.named_modules():
    if isinstance(module, (nn.Conv2d, nn.Linear)):
        params_to_prune.append((module, 'weight'))

prune.global_unstructured(
    params_to_prune,
    pruning_method=prune.L1Unstructured,
    amount=0.9,
)

# Fine-tune (freeze mask, only update non-zero weights)
pruned_ft = pruned_ft.to(device)
optimizer_ft = optim.SGD(pruned_ft.parameters(), lr=0.01, momentum=0.9, weight_decay=5e-4)

acc_before_ft = evaluate(pruned_ft, testloader, device)
print(f"\nAccuracy before fine-tuning: {acc_before_ft:.2f}%")

for epoch in range(5):
    pruned_ft.train()
    for inputs, targets in trainloader:
        inputs, targets = inputs.to(device), targets.to(device)
        optimizer_ft.zero_grad()
        outputs = pruned_ft(inputs)
        loss = criterion(outputs, targets)
        loss.backward()
        optimizer_ft.step()
        # Re-apply mask (ensure pruned weights stay zero)
        for m, n in params_to_prune:
            mask = getattr(m, n + '_mask', None)
            if mask is not None:
                m.weight.data *= mask

acc_after_ft = evaluate(pruned_ft, testloader, device)
print(f"Accuracy after fine-tuning: {acc_after_ft:.2f}% (recovered {acc_after_ft - acc_before_ft:+.2f}%)")
print(f"\n-> Fine-tuning recovered the 90% pruned model from {acc_before_ft:.2f}% to {acc_after_ft:.2f}%")

5.5 典型的な出力結果

======================================================================
  Full Comparison Before and After Pruning (ResNet-18 / CIFAR-10)
======================================================================
Model        Accuracy  Acc Change  Latency(ms)  Speedup  Size(MB)    Non-zero
----------------------------------------------------------------------
Original      91.45%     +0.00%        0.42     1.00x    42.65   11,173,962
50% Pruned    91.12%     -0.33%        0.41     1.02x    42.65    5,586,982
70% Pruned    89.87%     -1.58%        0.40     1.05x    42.65    3,352,189
90% Pruned    85.23%     -6.22%        0.39     1.08x    42.65    1,117,397
======================================================================

Accuracy before fine-tuning: 85.23%
Accuracy after fine-tuning: 89.91% (recovered +4.68%)

注目すべきポイント：

• 50%プルーニングはほぼ無料：精度の損失は通常0.5%未満——これが最も安全なエントリーポイント
• 90%プルーニングにはファインチューニングが必要：パラメータの90%を直接削除すると目立つ精度低下が生じるが、5エポックのファインチューニングでほとんどの損失を回復できる
• モデルファイルサイズが変わらない？これは非構造化プルーニングの特性——ゼロ値が依然としてストレージスペースを占有する。ファイルを実際に縮小するには、スパースストレージフォーマットまたは構造化プルーニングが必要
• 推論速度がほとんど変わらない？これがまさに非構造化 vs 構造化プルーニングの核心的な違い（以下の説明を参照）

5.6 なぜ速度が変わらないのか？非構造化 vs 構造化の真実

上記の実験は一般的な誤解を明らかにしている。非構造化プルーニングは標準GPUでの推論を自動的には高速化しない。その理由は、GPUの並列アーキテクチャが規則的な行列演算を必要とするため——不規則なスパースパターンは実際にはむしろ遅くなる可能性がある。

結論：目標が実際の速度向上であれば、構造化プルーニングまたはNVIDIA 2:4半構造化スパースを選択する。目標が最大限のモデル圧縮（例：スパース推論エンジンによるエッジデプロイ）であれば、非構造化プルーニングがより良い選択である。

6. ハンズオンラボ：LLMプルーニングオンラインラボ（言語モデル）

上記のResNet-18の例はCVモデルのプルーニングを実演した。次は言語モデルを直接扱う——GPT-2（1億2,400万パラメータ）を使用し、無料のGoogle ColabでA100なしで実行可能。

Google Colabを開く。新しいNotebookを作成し、以下のコードを順番に貼り付ける。

6.1 インストールとGPT-2の読み込み

!pip install Transformerアーキテクチャs accelerate -q

import torch
import torch.nn as nn
import torch.nn.utils.prune as prune
from transformers import GPT2LMHeadModel, GPT2Tokenizer
import time, copy

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Device: {device}")

# Load GPT-2 (124M parameters, more than enough for free Colab)
tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2").to(device)
model.eval()

total_params = sum(p.numel() for p in model.parameters())
print(f"GPT-2 total parameters: {total_params:,}")

6.2 評価関数の定義

def generate_text(model, prompt, max_new_tokens=60):
    """Generate text with the model to visually compare quality before and after pruning"""
    inputs = tokenizer(prompt, return_tensors="pt").to(device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            pad_token_id=tokenizer.eos_token_id,
        )
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

def measure_perplexity(model, text):
    """Calculate perplexity (lower is better)"""
    inputs = tokenizer(text, return_tensors="pt").to(device)
    with torch.no_grad():
        outputs = model(**inputs, labels=inputs["input_ids"])
    return torch.exp(outputs.loss).item()

def count_sparsity(model):
    """Calculate overall model sparsity"""
    total, zeros = 0, 0
    for p in model.parameters():
        total += p.numel()
        zeros += (p == 0).sum().item()
    return zeros / total * 100

def measure_speed(model, n_runs=50):
    """Measure generation speed (tokens/sec)"""
    prompt = tokenizer("The future of artificial intelligence", return_tensors="pt").to(device)
    # Warmup
    for _ in range(5):
        with torch.no_grad():
            model.generate(**prompt, max_new_tokens=20, pad_token_id=tokenizer.eos_token_id)
    if device.type == 'cuda':
        torch.cuda.synchronize()
    start = time.perf_counter()
    for _ in range(n_runs):
        with torch.no_grad():
            model.generate(**prompt, max_new_tokens=20, pad_token_id=tokenizer.eos_token_id)
    if device.type == 'cuda':
        torch.cuda.synchronize()
    elapsed = time.perf_counter() - start
    return (20 * n_runs) / elapsed  # tokens per second

6.3 プルーニング前：ベースライン性能の記録

test_prompts = [
    "Artificial intelligence will transform",
    "The key to successful machine learning is",
    "In the next decade, technology companies will",
]

eval_text = (
    "Machine learning is a subset of artificial intelligence that focuses on "
    "building systems that learn from data. Deep learning, a further subset, "
    "uses neural networks with many layers to model complex patterns."
)

print("=" * 60)
print("  GPT-2 Baseline Performance (Before Pruning)")
print("=" * 60)

base_ppl = measure_perplexity(model, eval_text)
base_sparsity = count_sparsity(model)
base_speed = measure_speed(model)

print(f"  Perplexity (PPL):  {base_ppl:.2f}")
print(f"  Sparsity:          {base_sparsity:.1f}%")
print(f"  Generation Speed:  {base_speed:.1f} tokens/sec")
print(f"\n  Generation Examples:")
for p in test_prompts:
    print(f"  Prompt: {p}")
    print(f"  Output: {generate_text(model, p)}\n")

6.4 プルーニング実験：30% / 50% / 70%の比較

results = [{'name': 'Original', 'sparsity': 0, 'ppl': base_ppl, 'speed': base_speed}]

for sparsity in [0.3, 0.5, 0.7]:
    pruned = copy.deepcopy(model)

    # Collect all Linear layers (the core of GPT-2)
    params_to_prune = []
    for name, module in pruned.named_modules():
        if isinstance(module, nn.Linear):
            params_to_prune.append((module, 'weight'))

    # Global magnitude pruning
    prune.global_unstructured(
        params_to_prune,
        pruning_method=prune.L1Unstructured,
        amount=sparsity,
    )
    for m, n in params_to_prune:
        prune.remove(m, n)

    pruned = pruned.to(device)
    pruned.eval()

    ppl = measure_perplexity(pruned, eval_text)
    speed = measure_speed(pruned)
    actual_sparsity = count_sparsity(pruned)

    results.append({
        'name': f'{int(sparsity*100)}% Pruned',
        'sparsity': actual_sparsity,
        'ppl': ppl,
        'speed': speed,
    })

    print(f"\n{'='*60}")
    print(f"  GPT-2 — After {int(sparsity*100)}% Pruning")
    print(f"{'='*60}")
    print(f"  Perplexity: {ppl:.2f} (baseline {base_ppl:.2f}, change {ppl-base_ppl:+.2f})")
    print(f"  Sparsity: {actual_sparsity:.1f}%")
    print(f"  Generation Example:")
    for p in test_prompts[:1]:
        print(f"  Prompt: {p}")
        print(f"  Output: {generate_text(pruned, p)}")

    del pruned
    if device.type == 'cuda':
        torch.cuda.empty_cache()

6.5 結果概要

print(f"\n{'='*65}")
print(f"  GPT-2 Full Comparison Before and After Pruning")
print(f"{'='*65}")
print(f"{'Model':<12} {'PPL':>12} {'PPL Change':>11} {'Speed(tok/s)':>13} {'Sparsity':>9}")
print(f"{'-'*65}")
for r in results:
    delta = r['ppl'] - base_ppl
    print(f"{r['name']:<12} {r['ppl']:>11.2f} {delta:>+10.2f} "
          f"{r['speed']:>12.1f} {r['sparsity']:>8.1f}%")
print(f"{'='*65}")
print(f"\nKey Findings:")
print(f"  - 30% pruning: perplexity barely changes, ready for production use")
print(f"  - 50% pruning: perplexity slightly increases, generation quality still acceptable")
print(f"  - 70% pruning: quality begins to noticeably degrade, recommend using with fine-tuning")
print(f"\n-> Try modifying test_prompts with your own sentences to observe generation quality at different pruning levels!")

自分の目で確認できること：30%プルーニングのGPT-2が生成するテキストはオリジナルとほぼ同一。50%プルーニングでも流暢で一貫性がある。70%プルーニングでは文法エラーや意味のドリフトが現れ始める。これがプルーニングのトレードオフである——sparsityの値を自分で調整して「スイートスポット」を見つけてみよう。

6.6 上級編：Wandaを使用した大規模モデルのプルーニング

上記のGPT-2デモでは最も基本的なマグニチュードプルーニングを使用した。より大きなLLM（LLaMA-7B以上）には、Wanda^[8]の使用を推奨する——重みとアクティベーションの結合重要度を考慮し、単純なマグニチュードプルーニングよりもはるかに優れたプルーニング品質を提供する。

# On Colab Pro (A100 GPU) or local environment:
!git clone https://github.com/locuslab/wanda.git
%cd wanda
!pip install -r requirements.txt -q

# 50% unstructured pruning on LLaMA-7B
!python main.py \
    --model meta-llama/Llama-2-7b-hf \
    --prune_method wanda \
    --sparsity_ratio 0.5 \
    --save out/llama7b_wanda_50

# Or enable 2:4 semi-structured sparsity (NVIDIA Ampere+ GPU hardware acceleration)
!python main.py \
    --model meta-llama/Llama-2-7b-hf \
    --prune_method wanda \
    --sparsity_type 2:4 \
    --save out/llama7b_wanda_2to4

Wandaは単一のA100 GPUでLLaMA-7Bのプルーニングをわずか数分で完了する。SparseGPTの300倍高速。

7. 拡散モデルプルーニング：Stable DiffusionとFluxの圧縮フロンティア

プルーニングの価値は分類モデルと言語モデルに限られない。生成AIのコア戦場であるテキストから画像への生成においても、モデル圧縮は現実の問題を解決している。120億パラメータのFLUX.1は24GBのVRAMを必要とし、ほとんどのコンシューマーGPUでは動作しない。過去2年間で、学術界と産業界の両方が拡散モデル専用の一連の圧縮技術を開発してきた。

7.1 Stable Diffusion：4つの圧縮パス

BK-SDMは特に注目に値する。Nota AIチームはSD v1.4のU-Netから残差ブロックとアテンションブロックを直接削除し、知識蒸留で品質を回復させた。結果、BK-SDM-Base（5.8億パラメータ）はFIDスコア15.76を達成し、元のSD v1.4を実際に上回った。学習全体に必要なのはA100 13日分で、元のSDの6,000日以上と比較すると、コストは460分の1に削減された。

ToMe（Token Merging）は異なるアプローチを取る。モデルアーキテクチャを変更するのではなく、推論時にU-Net Transformer内の冗長なトークンをマージする。完全に学習不要でプラグアンドプレイ——2行のコードで2倍の高速化。

import tomesd
tomesd.apply_patch(pipe, ratio=0.5)  # Merge 50% of redundant tokens
# Use pipe normally afterward, automatic speedup

7.2 Flux：量子化主導、蒸留補助

Fluxの圧縮パスはSDとは異なる。まず、Flux.1-schnell自体が蒸留モデルである——Flux.1-proからタイムステップ蒸留され、生成ステップを20〜50から1〜4に圧縮しており、オープンソースコミュニティで利用可能（Apache 2.0ライセンス）。

さらなる圧縮には、量子化技術が主要なアプローチとなる。

MIT Han LabのSVDQuantは特に印象的である。まずアクティベーションの外れ値を重みに移し、次にSVDを使用して重みを高精度の低ランク分岐（外れ値を処理）と4ビット量子化分岐（残りを処理）に分解する。カスタムNunchaku推論エンジンと組み合わせることで、FLUX.1の12Bモデルが16GB RTX 4090でスムーズに動作する。

7.3 Pruna AI：1行のコードでSD / Fluxを圧縮

各圧縮アルゴリズムの詳細に踏み込みたくない場合、Pruna AI^[15]がより高レベルのソリューションを提供する。ミュンヘンのこのスタートアップ（2023年設立、EQT Ventures主導の650万ドルシードラウンド）は、30以上の圧縮アルゴリズムを単一のsmash()関数にラップしている——モデルを入力し、圧縮バージョンが返され、APIは完全に互換。

from pruna import smash, SmashConfig

# Load your Stable Diffusion / Flux pipeline
smash_config = SmashConfig()
smash_config["cacher"] = "deepcache"       # Cache intermediate computations
smash_config["compiler"] = "stable_fast"   # JIT compilation acceleration

smashed_model = smash(model=pipe, smash_config=smash_config)
# Use it just like the original model, but faster and more memory-efficient

拡散モデルにおけるPrunaのベンチマーク結果：

Prunaのコアフレームワークは2025年3月にオープンソース化された（Apache-2.0）。HuggingFace上に400以上の「smashed」圧縮モデルを公開している。またComfyUIプラグインも提供しており、エンジニアでなくても拡散モデルワークフローをワンクリックで最適化できる。

企業への示唆：拡散モデルの圧縮はもはや修士・博士レベルのMLエンジニアリング能力を必要としない。学術フロンティア（BK-SDM、SVDQuant）からワンクリックツール（Pruna、ToMe）まで、圧縮技術の民主化により、コンシューマーGPUしか持たない小規模スタジオを含む、より多くのチームがAI生成コンテンツの競争に参加できるようになっている。

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

PyTorchネイティブAPIからエンタープライズグレードプラットフォームまで、プルーニングとモデル圧縮のツールエコシステムは完全な技術スタックをカバーしている。

ローレベルフレームワーク

• PyTorch torch.nn.utils.prune^[16]：ビルトインAPI、3行のコードでプルーニングを開始。学習と概念実証に最適
• Intel Neural Compressor（GitHub）：PyTorch / TensorFlow / ONNXをサポート。マグニチュードプルーニング、勾配プルーニング、SNIPなどの戦略を提供し、量子化と蒸留と組み合わせて完全なパイプラインを構成可能
• NVIDIA ASP（GitHub）：2行のコードで2:4構造化スパースを有効化。Ampere GPUで最大2倍のスループット向上
• NVIDIA ModelOpt（GitHub）：量子化、プルーニング、蒸留、投機的デコーディングを統合した統一モデル最適化ライブラリ

LLM専用

• Wanda（GitHub）：ICLR 2024。重み × アクティベーション結合プルーニング。SparseGPTの300倍高速
• SparseGPT（GitHub）：ICML 2023。ワンショット事後学習LLMプルーニングのパイオニア

拡散モデル専用

• ToMe for SD（GitHub）：学習不要のトークンマージング。プラグアンドプレイで2倍高速化
• Diff-Pruning（GitHub）：NeurIPS 2023。拡散モデル用構造化プルーニング
• Nunchaku（GitHub）：SVDQuantの推論エンジン。コンシューマーGPUで4ビットFLUX

オールインワンプラットフォーム

• Pruna AI^[15]（GitHub）：オープンソースフレームワーク。30以上のアルゴリズム、1行のコードであらゆるモデルを圧縮。ComfyUIプラグイン付き
• Awesome-Pruning（GitHub）：継続的に更新されるプルーニング論文のキュレーションリスト。最新動向の追跡に最適

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

プルーニングは単なるエンジニアのおもちゃではない——企業の収益に直接影響する。金融業界のケーススタディでは、MIT Sloan Management Review^[17]が、AI駆動のプロセス最適化によりワークロードの59%削減とコストの40%削減を達成したことを明らかにした。AIモデル最適化のコア技術の1つとして、プルーニングは以下の次元で具体的な価値を創出する。

• 推論コスト：GPU推論コストはモデルサイズに正比例する。パラメータの50〜90%をプルーニングすることは、比例したメモリ節約を意味し、より小さなGPUインスタンスの使用、または同じGPUでより多くのリクエストの処理が可能になる
• レイテンシ：構造化プルーニングは2〜5.5倍の推論高速化を実現でき、リアルタイムアプリケーション（リスク管理システム、レコメンデーションエンジン、自動運転）にとって極めて重要
• エッジデプロイ：プルーニングされたモデルはスマートフォン、IoTデバイス、組み込みシステムにデプロイでき、オフライン推論を可能にしながらデータ伝送コストとプライバシーリスクを低減
• サステナブルAI：モデル圧縮は推論1回あたりのエネルギー消費を最大90%削減できる^[1]——ESG報告が投資家からますます厳しく精査される時代において、これは企業の戦略的優先事項となっている

10. 導入パス：3フェーズ実装戦略

1. 既存モデルの棚卸し：推論コストが最も高いモデルを主要なプルーニング対象として特定する。これらは通常、オンラインサービスにおいてパラメータ数が最大で呼び出し頻度が最も高いモデル
2. シンプルに始める：本記事のセクション5のPyTorchグローバルプルーニングコードを使用して概念実証を行い、異なるスパース率での精度変化を観察する。ほとんどのモデルは50%スパース率でほぼ精度を失わない
3. 段階的に深める：初期結果の検証後、構造化プルーニング、量子化、蒸留の組み合わせパイプラインを導入する。LLMシナリオでは、WandaまたはSparseGPTを直接使用する

プルーニングはフロンティアの実験的技術ではなく、NVIDIA、Meta、Googleなどの企業で大規模に検証されたエンジニアリングプラクティスである。車輪の再発明は不要——PyTorchを開き、3行のコードを実行し、自分のモデルがどれだけの「余分な体重」を落とせるか確認しよう。

チームがモデル最適化戦略を評価している場合、またはレイテンシ、コスト、精度の最適なバランスを見つける必要がある場合、深い技術的な議論を歓迎します。Meta Intelligenceの研究チームが、モデル診断から本番デプロイまでの完全な旅にお付き合いします。