Der vollstandige Leitfaden zu Neural Network Pruning: Lottery Ticket bis SparseGPT

I. Die versteckte Kostenkrise der KI: Warum „groesser ist besser" auf Unternehmen zurueckschlaegt

Im Jahr 2024 investierten Unternehmen weltweit nahezu 60 Milliarden US-Dollar in KI-Infrastruktur, wobei fast 60 % in Rechenleistung und Hardware flossen -- nicht in die Anwendungsebene. Harvard Business Review weist darauf hin^[1], dass der CO₂-Fussabdruck von KI-Systemen in alarmierendem Tempo waechst -- ohne Optimierung wird KI bis 2030 jaehrlich 24-44 Millionen Tonnen CO₂ ausstossen, was 5-10 Millionen zusaetzlichen Autos auf der Strasse entspricht. Noch entscheidender ist die Goldman-Sachs-Prognose, dass der KI-bedingte Strombedarf bis 2030 um 160 % steigen wird -- die Rechenkosten werden also weiter klettern.

Dabei wird eine Tatsache von den meisten Unternehmen uebersehen: Sie bezahlen fuer eine grosse Menge an Parametern, die keine Arbeit leisten. Stanfords Song Han und Kollegen belegten in ihrer bahnbrechenden NeurIPS-2015-Studie^[2], dass 90 % der 61 Millionen Parameter von AlexNet direkt entfernt werden koennen, ohne die Genauigkeit zu beeintraechtigen. VGG-16 erreichte sogar ein Komprimierungsverhaeltnis von 13x -- von 138 Millionen Parametern auf 10,3 Millionen, bei voellig unveraenderter Praezision. Anders ausgedrueckt: Neun Zehntel Ihrer GPU-Rechnung koennten fuer die Berechnung von „Rauschen" ausgegeben werden.

Eine Studie des MIT Sloan Management Review^[3] bestaetigt diese Erkenntnis aus der Management-Perspektive: Kleinere, praezisere KI-Deployments erzielen haeufig einen hoeheren Geschaeftswert als die „groesser ist besser"-Strategie. Das Problem ist nicht, dass die Modelle nicht gross genug sind -- sondern dass wir noch nicht gelernt haben, wie wir Modelle „genau passend" dimensionieren. Pruning ist die ausgereifteste und direkteste technische Methode, um diesen Widerspruch aufzuloesen.

II. Technische Evolution: Von Faustregeln zum theoretischen Durchbruch

2.1 Magnitude Pruning: Der einfachste und effektivste Ausgangspunkt

Die Logik von Magnitude Pruning ist denkbar einfach: Je kleiner der Absolutwert eines Gewichts, desto geringer sein Einfluss auf die Modellausgabe -- daher kann es bevorzugt entfernt werden. Song Han und Kollegen verifizierten diese Methode systematisch in ihrem NeurIPS-2015-Paper^[2] und kombinierten sie in der nachfolgenden Arbeit zu Deep Compression^[4] mit Quantisierung und Huffman-Kodierung, um Komprimierungsverhaeltnisse von 35-49x zu erreichen. Das Deep-Compression-Paper erhielt den ICLR 2016 Best Paper Award und wurde zum Meilenstein der Modellkomprimierung.

Magnitude Pruning laesst sich in zwei Formen unterteilen:

• Unstrukturiertes Pruning (Unstructured Pruning): Einzelne Gewichte werden entfernt, unabhaengig von ihrer Position im Netzwerk. Es kann eine extrem hohe Sparsity (90 %+) erreicht werden, doch die resultierenden unregelmaessigen Sparse-Matrizen erfordern spezielle Hardware-Unterstuetzung, um sich in tatsaechliche Geschwindigkeitsgewinne umzusetzen.
• Strukturiertes Pruning (Structured Pruning): Ganze Faltungsfilter, Kanaele oder Attention Heads werden entfernt. Das Komprimierungsverhaeltnis ist typischerweise geringer als beim unstrukturierten Pruning, aber das Modell wird tatsaechlich kleiner und erzielt auf Standard-Hardware direkte Inferenzbeschleunigung.

2.2 Lottery Ticket Hypothesis: Im grossen Netzwerk steckt ein „Gewinnlos"

2019 stellten Jonathan Frankle und Michael Carlin vom MIT die bahnbrechende Lottery Ticket Hypothesis (LTH)^[5] auf. Diese mit dem ICLR 2019 Best Paper Award ausgezeichnete Forschung offenbarte eine erstaunliche Entdeckung:

In zufaellig initialisierten grossen Netzwerken existieren sparse Subnetzwerke („Gewinnlose"), die -- wenn sie mit ihren urspruenglichen Initialisierungswerten von Grund auf trainiert werden -- die gleiche oder sogar bessere Genauigkeit als das vollstaendige Netzwerk erreichen.

In Experimenten mit MNIST und CIFAR-10 fanden die Forscher „Gewinnlose" in Subnetzwerken, die nur 10-20 % der Parameter des Originalnetzwerks enthielten. Noch interessanter: Diese Subnetzwerke lernten schneller als das vollstaendige Netzwerk und erreichten eine hoehere Endgenauigkeit.

Die Bedeutung der LTH geht weit ueber die Wissenschaft hinaus. Sie stellt das traditionelle Paradigma „erst grosses Modell trainieren, dann komprimieren" grundlegend in Frage -- die sparse Struktur existiert bereits ab dem Moment der Initialisierung, wir muessen sie nur finden. Sze et al. analysieren in ihrem Ueberblicksartikel in den Proceedings of the IEEE^[6] verschiedene Strategien fuer effiziente Inferenz systematisch und liefern damit den theoretischen Rahmen fuer die praktische Umsetzung der LTH.

2.3 Pruning im LLM-Zeitalter: SparseGPT und Wanda

Wenn die Modellgroesse von Millionen auf Hunderte von Milliarden Parametern anwaechst, wird der traditionelle dreistufige Prozess „Trainieren → Prunen → Feintunen" unpraktikabel -- allein das einmalige Nachtrainieren eines 175B-Parameter-Modells kostet mehrere Millionen Dollar.

2023 veroeffentlichten Frantar und Alistarh auf der ICML SparseGPT^[7] und realisierten damit erstmals das „One-Shot"-Pruning fuer grosse Sprachmodelle: Ohne erneutes Training koennen OPT-175B und BLOOM-176B innerhalb von 4,5 Stunden ein 60 %iges unstrukturiertes Pruning durchlaufen, wobei die Perplexity nahezu unbeeinflusst bleibt.

2024 trieben Sun et al. mit Wanda^[8] (veroeffentlicht auf der ICLR 2024) die Effizienz auf ein neues Niveau. Wandas zentrale Erkenntnis: Man sollte nicht nur die Gewichtsgroesse betrachten, sondern auch die zugehoerige Eingabe-Aktivierung -- eine Verbindung mit kleinem Gewicht aber grosser Aktivierung kann wichtiger sein als eine mit grossem Gewicht aber kleiner Aktivierung. Diese einfache Verbesserung macht Wanda 300-mal schneller als SparseGPT und erreicht bei 50 % Sparsity auf LLaMA-7B eine Perplexity von nur 7,26 (Magnitude-Pruning-Baseline: 17,29).

NVIDIA ging noch einen Schritt weiter und veroeffentlichte auf der NeurIPS 2024 Minitron^[9], das strukturiertes Pruning mit Knowledge Distillation kombiniert. Aus einem 15B-Modell werden 8B- und 4B-Varianten abgeleitet -- mit nur 1/40 des Trainings-Token-Verbrauchs und einer MMLU-Verbesserung von bis zu 16 %.

III. Zehn Jahre empirische Daten: Komprimierungsverhaeltnisse von CNN bis LLM im Ueberblick

IV. Entscheidungsrahmen: Nutzen, Kosten und Anwendungsgrenzen des Prunings

Technische Machbarkeit bedeutet nicht automatisch geschaeftliche Machbarkeit. Bevor Sie Pruning in Ihre Technologiestrategie aufnehmen, muessen Entscheidungstraeger die Auswirkungen in sechs Schluesseldimensionen umfassend verstehen:

Strategische Vorteile

• Sofortige Kosteneinsparungen: Kleineres Modell = kleinere GPU-Instanz = niedrigere Cloud-Rechnung. Dieselbe A100 kann das 2-5-Fache der urspruenglichen Anfragenmenge verarbeiten
• Extrem niedrige technische Einstiegshuerde: PyTorch bietet eine integrierte API -- drei Zeilen Code genuegen fuer den Einstieg. Keine Aenderung der Modellarchitektur erforderlich, kein erneutes Training noetig (insbesondere bei SparseGPT/Wanda-Methoden)
• Kombinierbar mit anderen Komprimierungstechniken: Eine Pipeline aus Pruning + Quantisierung + Distillation kann Komprimierungsverhaeltnisse von 35-49x erreichen^[4] -- weit ueber dem, was eine einzelne Technik leistet
• Hoher akademischer Reifegrad: Drei ICLR/ICML Best-Paper-Auszeichnungen belegen: Dies ist keine experimentelle Technologie

Risiken, die gemanagt werden muessen

• Der Trade-off zwischen Genauigkeit und Sparsity ist nichtlinear: 50 % Sparsity ist kaum spuerbar, aber jenseits von 90 % kann die Genauigkeit rapide sinken. Der „Sweet Spot" ist bei jedem Modell anders und muss experimentell bestimmt werden
• Die Geschwindigkeitsillusion des unstrukturierten Prunings: Obwohl 90 % der Gewichte null sind, gibt es auf Standard-Hardware (CPU/GPU) keine automatische Beschleunigung -- es braucht Sparse-Computing-Bibliotheken oder NVIDIA Ampere+ GPUs mit 2:4-Sparse-Unterstuetzung
• Feintuning-Kosten: Pruning mit hoher Sparsity erfordert in der Regel Feintuning (Fine-Tuning) zur Wiederherstellung der Genauigkeit -- das bedeutet zusaetzliche Trainingskosten und Datenanforderungen. Gerade bei LLMs sind die Feintuning-Kosten besonders hoch
• Die Generalisierungsfaehigkeit auf neue Aufgaben kann sinken: Geprunte Modelle zeigen gute Leistung auf der Trainingsaufgabe, aber die Robustheit gegenueber Out-of-Distribution-Daten (OOD) kann abnehmen
• Erhoehte Debugging-Komplexitaet: Das Verhalten sparser Modelle ist schwieriger zu interpretieren und zu debuggen; die Fehlersuche bei Anomalien wird aufwaendiger

Ungeeignete Szenarien

• Das Modell ist bereits sehr klein (Parameterzahl < 1M) -- der Nutzen des Prunings ist begrenzt, das Risiko bleibt gleich
• Genauigkeit ist das einzige Kriterium und jeglicher Verlust ist inakzeptabel (z. B. medizinische Diagnostik, sicherheitskritische Systeme)
• Dem Team fehlt die ML-Engineering-Kompetenz, um die Qualitaet des geprunten Modells zu bewerten und zu validieren
• Das Modell muss haeufig aktualisiert oder neu trainiert werden -- jede Aktualisierung erfordert einen erneuten Pruning-Durchlauf

V. Hands-on Lab: Google Colab Online-Labor (CV-Modell)

Nach Theorie und Framework lassen wir die Daten sprechen. Im folgenden Experiment wird ResNet-18 auf CIFAR-10 trainiert und anschliessend mit 50 % / 70 % / 90 % Sparsity gepruned -- mit quantitativem Vergleich der Veraenderungen bei Genauigkeit, Inferenzgeschwindigkeit und Modellgroesse. Der gesamte Code kann direkt auf der kostenlosen GPU von Google Colab ausgefuehrt werden.

Google Colab oeffnen, ein neues Notebook erstellen und die folgenden Code-Abschnitte der Reihe nach einfuegen:

5.1 Step 1 -- Basismodell trainieren (ca. 3 Minuten)

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}")

# ---- 資料集 ----
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)

# ---- 模型：ResNet-18（適配 CIFAR-10 的 32x32 輸入）----
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)

# ---- 訓練 10 epochs（快速 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 完成")

print("✓ 基準模型訓練完成")

5.2 Step 2 -- Evaluierungsfunktionen

def evaluate(model, dataloader, device):
    """計算測試集準確率"""
    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):
    """測量單張圖片的平均推論延遲（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):
    """計算模型檔案大小（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):
    """計算非零參數比例"""
    total, nonzero = 0, 0
    for p in model.parameters():
        total += p.numel()
        nonzero += p.nonzero().size(0)
    return total, nonzero

# ---- 記錄基準數據 ----
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"  基準模型（ResNet-18 on CIFAR-10）")
print(f"{'='*55}")
print(f"  準確率:       {base_acc:.2f}%")
print(f"  推論延遲:     {base_speed:.2f} ms")
print(f"  模型大小:     {base_size:.2f} MB")
print(f"  總參數:       {total_params:,}")
print(f"  非零參數:     {nz_params:,} (100%)")
print(f"{'='*55}")

5.3 Step 3 -- Pruning-Experiment: 50 % / 70 % / 90 % im Vergleich

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

for sparsity in [0.5, 0.7, 0.9]:
    # 深拷貝，避免汙染原始模型
    pruned = copy.deepcopy(model)

    # 收集可剪枝的層
    params_to_prune = []
    for name, module in pruned.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=sparsity,
    )

    # 永久化 mask
    for m, n in params_to_prune:
        prune.remove(m, n)

    # 評估
    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)}% 剪枝',
        'sparsity': sparsity,
        'acc': acc,
        'speed': speed,
        'size': size,
        'nz': nz,
    })

# ---- 印出完整比較表 ----
print(f"\n{'='*70}")
print(f"  剪枝前後完整比較（ResNet-18 / CIFAR-10）")
print(f"{'='*70}")
print(f"{'模型':<12} {'準確率':>8} {'精度變化':>8} {'延遲(ms)':>9} "
      f"{'加速比':>7} {'大小(MB)':>9} {'非零參數':>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:>+7.2f}% "
          f"{r['speed']:>8.2f}  {speedup:>6.2f}x "
          f"{r['size']:>8.2f}  {r['nz']:>11,}")

print(f"{'='*70}")
print("\n★ 關鍵觀察:")
print(f"  • 50% 剪枝：精度變化僅 {results[1]['acc']-base_acc:+.2f}%，幾乎無感")
print(f"  • 90% 剪枝：砍掉 9/10 的參數，精度變化 {results[3]['acc']-base_acc:+.2f}%")
print(f"  • 非結構化剪枝的推論速度在標準 GPU 上變化有限（見下方說明）")

5.4 Step 4 -- Feintuning zur Genauigkeitswiederherstellung (optional)

# 對 90% 剪枝模型進行 5 epochs 微調，觀察精度恢復
pruned_ft = copy.deepcopy(model)

# 剪枝
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,
)

# 微調（凍結 mask，只更新非零權重）
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"\n微調前精度: {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()
        # 重新套用 mask（確保被剪掉的權重保持為零）
        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"微調後精度: {acc_after_ft:.2f}% (恢復 {acc_after_ft - acc_before_ft:+.2f}%)")
print(f"\n→ 微調讓 90% 剪枝模型的精度從 {acc_before_ft:.2f}% 恢復至 {acc_after_ft:.2f}%")

5.5 Erwartete Ergebnisse (typische Ausgabe)

======================================================================
  剪枝前後完整比較（ResNet-18 / CIFAR-10）
======================================================================
模型           準確率   精度變化  延遲(ms)   加速比  大小(MB)      非零參數
----------------------------------------------------------------------
原始模型       91.45%   +0.00%     0.42    1.00x    42.65   11,173,962
50% 剪枝      91.12%   -0.33%     0.41    1.02x    42.65    5,586,982
70% 剪枝      89.87%   -1.58%     0.40    1.05x    42.65    3,352,189
90% 剪枝      85.23%   -6.22%     0.39    1.08x    42.65    1,117,397
======================================================================

微調前精度: 85.23%
微調後精度: 89.91% (恢復 +4.68%)

Einige bemerkenswerte Punkte:

• 50 % Pruning ist nahezu kostenlos: Der Genauigkeitsverlust liegt typischerweise unter 0,5 % -- dies ist der sicherste Einstiegspunkt
• 90 % Pruning erfordert Feintuning: Das direkte Entfernen von 90 % der Parameter fuehrt zu einem deutlichen Genauigkeitsverlust, doch 5 Epochen Feintuning koennen den Grossteil des Verlusts wiederherstellen
• Die Modelldateigroesse bleibt unveraendert? Das ist eine Eigenschaft des unstrukturierten Prunings -- Nullwerte belegen weiterhin Speicherplatz. Um die Dateigroesse tatsaechlich zu reduzieren, muss man ein Sparse-Speicherformat verwenden oder auf strukturiertes Pruning setzen
• Die Inferenzgeschwindigkeit hat sich kaum veraendert? Genau das ist der Kernunterschied zwischen unstrukturiertem und strukturiertem Pruning (siehe Erklaerung unten)

5.6 Warum hat sich die Geschwindigkeit nicht veraendert? Die Wahrheit ueber unstrukturiertes vs. strukturiertes Pruning

Das obige Experiment deckt ein haeufiges Missverstaendnis auf: Unstrukturiertes Pruning fuehrt auf Standard-GPUs nicht automatisch zu einer Beschleunigung. Der Grund liegt darin, dass die parallele Architektur von GPUs regelmaessige Matrixoperationen erfordert -- unregelmaessige Sparse-Muster koennen sogar langsamer sein.

Fazit: Wenn Ihr Ziel eine tatsaechliche Geschwindigkeitssteigerung ist, waehlen Sie strukturiertes Pruning oder NVIDIA 2:4 Semi-Structured Sparsity. Wenn Ihr Ziel die maximale Modellkomprimierung ist (z. B. Edge-Deployment mit einer Sparse-Inferenz-Engine), ist unstrukturiertes Pruning die bessere Wahl.

VI. Hands-on Lab: LLM-Pruning Online-Labor (Sprachmodell)

Das vorangegangene ResNet-18-Beispiel demonstrierte Pruning fuer CV-Modelle. Nun arbeiten wir direkt an einem Sprachmodell -- mit GPT-2 (124M Parameter), das auf der kostenlosen Google Colab-Umgebung lauffaehig ist, ohne eine A100 zu benoetigen.

Google Colab oeffnen, ein neues Notebook erstellen und die folgenden Code-Abschnitte der Reihe nach einfuegen:

6.1 Installation und Laden von GPT-2

!pip install Transformer-Architekturs 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}")

# 載入 GPT-2（124M 參數，免費 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_params:,}")

6.2 Evaluierungsfunktionen definieren

def generate_text(model, prompt, max_new_tokens=60):
    """用模型生成文字，直觀觀察剪枝前後的品質差異"""
    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):
    """計算困惑度（越低越好）"""
    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):
    """計算模型整體稀疏度"""
    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):
    """測量生成速度（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 Vor dem Pruning: Basisleistung dokumentieren

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 基準表現（剪枝前）")
print("=" * 60)

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

print(f"  困惑度 (PPL):  {base_ppl:.2f}")
print(f"  稀疏度:        {base_sparsity:.1f}%")
print(f"  生成速度:      {base_speed:.1f} tokens/sec")
print(f"\n  生成範例:")
for p in test_prompts:
    print(f"  Prompt: {p}")
    print(f"  Output: {generate_text(model, p)}\n")

6.4 Pruning-Experiment: 30 % / 50 % / 70 % im Vergleich

results = [{'name': '原始模型', 'sparsity': 0, 'ppl': base_ppl, 'speed': base_speed}]

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

    # 收集所有 Linear 層（GPT-2 的核心）
    params_to_prune = []
    for name, module in pruned.named_modules():
        if isinstance(module, nn.Linear):
            params_to_prune.append((module, 'weight'))

    # ★ 全域幅度剪枝 ★
    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)}% 剪枝',
        'sparsity': actual_sparsity,
        'ppl': ppl,
        'speed': speed,
    })

    print(f"\n{'='*60}")
    print(f"  GPT-2 — {int(sparsity*100)}% 剪枝後")
    print(f"{'='*60}")
    print(f"  困惑度: {ppl:.2f} (基線 {base_ppl:.2f}, 變化 {ppl-base_ppl:+.2f})")
    print(f"  稀疏度: {actual_sparsity:.1f}%")
    print(f"  生成範例:")
    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 Ergebnisuebersicht

print(f"\n{'='*65}")
print(f"  GPT-2 剪枝前後完整比較")
print(f"{'='*65}")
print(f"{'模型':<12} {'困惑度(PPL)':>12} {'PPL變化':>9} {'速度(tok/s)':>12} {'稀疏度':>8}")
print(f"{'-'*65}")
for r in results:
    delta = r['ppl'] - base_ppl
    print(f"{r['name']:<12} {r['ppl']:>11.2f} {delta:>+8.2f} "
          f"{r['speed']:>11.1f} {r['sparsity']:>7.1f}%")
print(f"{'='*65}")
print(f"\n★ 關鍵發現:")
print(f"  • 30% 剪枝：困惑度幾乎不變，可直接用於生產環境")
print(f"  • 50% 剪枝：困惑度略增，生成品質仍然可接受")
print(f"  • 70% 剪枝：品質開始明顯下降，建議搭配微調使用")
print(f"\n→ 試試修改 test_prompts 換成你自己的句子，觀察不同剪枝程度的生成品質！")

Was Sie mit eigenen Augen sehen werden: Der mit 30 % geprunte GPT-2 generiert Text, der nahezu identisch mit dem Original ist; bei 50 % Pruning ist der Text immer noch fluessig und koharent; bei 70 % Pruning treten Grammatikfehler und semantische Abweichungen auf. Das ist der Trade-off des Prunings -- Sie koennen den sparsity-Wert selbst anpassen, um den „Sweet Spot" zu finden.

6.6 Fortgeschritten: Groessere Modelle mit Wanda prunen

Das obige GPT-2-Demo verwendet einfachstes Magnitude Pruning. Fuer groessere LLMs (LLaMA-7B+) empfiehlt sich Wanda^[8] -- es beruecksichtigt die gemeinsame Bedeutung von Gewichten und Aktivierungen und liefert eine deutlich bessere Pruning-Qualitaet als reines Magnitude Pruning.

# 在 Colab Pro（A100 GPU）或本地環境中：
!git clone https://github.com/locuslab/wanda.git
%cd wanda
!pip install -r requirements.txt -q

# 對 LLaMA-7B 執行 50% 非結構化剪枝
!python main.py \
    --model meta-llama/Llama-2-7b-hf \
    --prune_method wanda \
    --sparsity_ratio 0.5 \
    --save out/llama7b_wanda_50

# 或啟用 2:4 半結構化稀疏（NVIDIA Ampere+ GPU 硬體加速）
!python main.py \
    --model meta-llama/Llama-2-7b-hf \
    --prune_method wanda \
    --sparsity_type 2:4 \
    --save out/llama7b_wanda_2to4

Wanda benoetigt auf einer einzelnen A100-GPU nur wenige Minuten fuer das Pruning von LLaMA-7B -- 300-mal schneller als SparseGPT.

VII. Pruning von Diffusionsmodellen: Die Komprimierungsfront bei Stable Diffusion und Flux

Der Wert des Prunings beschraenkt sich nicht auf Klassifikationsmodelle und Sprachmodelle. Auf dem Kernschlachtfeld der generativen KI -- Text-zu-Bild (Text-to-Image) -- loest Modellkomprimierung ein ganz reales Problem: Das 12B-Parameter-Modell FLUX.1 benoetigt 24 GB VRAM -- die allermeisten Consumer-Grafikkarten koennen das nicht bewerkstelligen. In den vergangenen zwei Jahren hat die Forschung eine Reihe von Komprimierungstechniken speziell fuer Diffusionsmodelle entwickelt.

7.1 Stable Diffusion: Vier Komprimierungspfade

Besonders erwaehnenswert ist BK-SDM: Das Team von Nota AI entfernte direkt Residual- und Attention-Blocks aus dem U-Net von SD v1.4 und stellte die Qualitaet mittels Knowledge Distillation wieder her. Das Ergebnis: BK-SDM-Base (0,58B Parameter) erreicht einen FID-Score von 15,76 -- sogar besser als das originale SD v1.4. Das gesamte Training erforderte nur 13 Tage A100-Zeit; verglichen mit den ueber 6.000 A100-Tagen fuer das originale SD sind die Kosten um den Faktor 460 gesunken.

ToMe (Token Merging) verfolgt einen anderen Ansatz: Es veraendert die Modellarchitektur nicht, sondern fuehrt waehrend der Inferenz redundante Token im U-Net-Transformer zusammen. Es ist voellig trainingsfrei und Plug-and-Play -- zwei Zeilen Code bringen eine 2-fache Beschleunigung:

import tomesd
tomesd.apply_patch(pipe, ratio=0.5)  # 合併 50% 的冗餘 token
# 之後正常使用 pipe 即可，自動加速

7.2 Flux: Quantisierung als Hauptstrategie, Distillation als Ergaenzung

Der Komprimierungspfad von Flux unterscheidet sich von SD. Zunaechst ist Flux.1-schnell selbst ein destilliertes Modell -- es wurde durch Timestep-Distillation von Flux.1-pro abgeleitet, wobei die Generierungsschritte von 20-50 auf 1-4 komprimiert wurden. Die Open-Source-Community kann es direkt nutzen (Apache 2.0 Lizenz).

Fuer weitere Komprimierung sind primaer Quantisierungstechniken relevant:

SVDQuant aus dem MIT Han Lab sticht besonders hervor: Es verlagert zunaechst Ausreisser (Outliers) in den Aktivierungen in die Gewichte und zerlegt die Gewichte dann mittels SVD in einen hochpraezisen Low-Rank-Zweig (fuer Ausreisser) und einen 4-Bit-quantisierten Zweig (fuer den Rest). In Kombination mit der hauseigenen Nunchaku-Inferenz-Engine laeuft das 12B-Modell von FLUX.1 fluessig auf einer RTX 4090 mit nur 16 GB.

7.3 Pruna AI: Eine Zeile Code zum Komprimieren von SD / Flux

Wenn Sie nicht in die Details jedes einzelnen Komprimierungsalgorithmus eintauchen moechten, bietet Pruna AI^[15] eine uebergeordnete Loesung. Das Muenchner Startup (gegruendet 2023, $6,5M Seed-Runde, EQT Ventures als Lead-Investor) kapselt ueber 30 Komprimierungsalgorithmen in einer einzigen smash()-Funktion -- geben Sie ein Modell hinein, heraus kommt die komprimierte Version mit vollstaendig kompatibler API:

from pruna import smash, SmashConfig

# 載入你的 Stable Diffusion / Flux pipeline
smash_config = SmashConfig()
smash_config["cacher"] = "deepcache"       # 快取中間計算
smash_config["compiler"] = "stable_fast"   # JIT 編譯加速

smashed_model = smash(model=pipe, smash_config=smash_config)
# 直接當原模型用，但更快、更省記憶體

Prunas Benchmarks fuer Diffusionsmodelle:

Das Kern-Framework von Pruna wurde im Maerz 2025 als Open Source veroeffentlicht (Apache-2.0) und hat ueber 400 „smashed" komprimierte Modelle auf HuggingFace publiziert. Zudem bietet es ein ComfyUI-Plugin, mit dem auch Nicht-Ingenieure Diffusionsmodell-Workflows mit einem Klick optimieren koennen.

Bedeutung fuer Unternehmen: Die Komprimierung von Diffusionsmodellen erfordert keine ML-Engineering-Kompetenzen auf Doktorats-Niveau mehr. Von der akademischen Forschungsfront (BK-SDM, SVDQuant) bis hin zu Ein-Klick-Tools (Pruna, ToMe) -- die Demokratisierung der Komprimierungstechnologie ermoeglicht es immer mehr Teams -- einschliesslich kleiner Studios mit nur Consumer-GPUs -- am Wettlauf um KI-generierte Inhalte teilzunehmen.

VIII. Das Oekosystem der Werkzeuge im Ueberblick

Von PyTorch-nativen APIs bis hin zu Enterprise-Plattformen deckt das Tool-Oekosystem fuer Pruning und Modellkomprimierung den gesamten Technologie-Stack ab:

Basis-Frameworks

• PyTorch torch.nn.utils.prune^[16]: Integrierte API, drei Zeilen Code genuegen fuer den Einstieg. Geeignet fuer Lernen und Proof-of-Concept
• Intel Neural Compressor (GitHub): Unterstuetzt PyTorch / TensorFlow / ONNX, bietet Magnitude Pruning, Gradient Pruning, SNIP und weitere Strategien, kombinierbar mit Quantisierung und Distillation zu einer vollstaendigen Pipeline
• NVIDIA ASP (GitHub): Zwei Zeilen Code aktivieren 2:4 Structured Sparsity -- auf Ampere-GPUs bis zu 2x Durchsatzsteigerung
• NVIDIA ModelOpt (GitHub): Einheitliche Modelloptimierungsbibliothek, die Quantisierung, Pruning, Distillation und Speculative Decoding integriert

LLM-spezifisch

• Wanda (GitHub): ICLR 2024, Pruning anhand der gemeinsamen Gewichts-x-Aktivierungs-Wichtigkeit, 300-mal schneller als SparseGPT
• SparseGPT (GitHub): ICML 2023, Pionier des One-Shot Post-Training Prunings fuer LLMs

Diffusionsmodell-spezifisch

• ToMe for SD (GitHub): Trainingsfreies Token Merging, Plug-and-Play mit 2x Beschleunigung
• Diff-Pruning (GitHub): NeurIPS 2023, strukturiertes Pruning fuer Diffusionsmodelle
• Nunchaku (GitHub): Inferenz-Engine fuer SVDQuant, 4-Bit FLUX auf Consumer-GPUs

All-in-One-Plattformen

• Pruna AI^[15] (GitHub): Open-Source-Framework, ueber 30 Algorithmen, eine Zeile Code zum Komprimieren jedes Modells. Inkl. ComfyUI-Plugin
• Awesome-Pruning (GitHub): Laufend aktualisierte kuratierte Liste von Pruning-Papern, ideal um die neuesten Entwicklungen im Bereich zu verfolgen

IX. Von technischen Kennzahlen zum geschaeftlichen Einfluss

Pruning ist nicht nur ein Werkzeug fuer Ingenieure -- es beeinflusst direkt das Unternehmensergebnis. Eine Fallstudie des MIT Sloan Management Review aus der Finanzbranche^[17] zeigt, dass KI-getriebene Prozessoptimierung eine 59 %ige Arbeitslastreduktion und 40 % Kosteneinsparung ermoeglicht. Pruning als eine der Kerntechniken der KI-Modelloptimierung schafft in folgenden Dimensionen konkreten Mehrwert:

• Inferenzkosten: GPU-Inferenzkosten korrelieren direkt mit der Modellgroesse. Das Pruning von 50-90 % der Parameter bedeutet proportionale Speichereinsparungen und ermoeglicht kleinere GPU-Instanzen oder mehr Anfragen pro GPU
• Latenz: Strukturiertes Pruning kann eine 2-5,5-fache Inferenzbeschleunigung erzielen -- unverzichtbar fuer Echtzeitanwendungen (Risikomanagementsysteme, Empfehlungs-Engines, autonomes Fahren)
• Edge Deployment: Geprunte Modelle koennen auf Smartphones, IoT-Geraeten und Embedded-Systemen bereitgestellt werden, ermoeglichen Offline-Inferenz und senken gleichzeitig Datenuebertragungskosten und Datenschutzrisiken
• Nachhaltige KI: Modellkomprimierungstechniken koennen den Energieverbrauch pro Inferenz um bis zu 90 % senken^[1] -- in einer Zeit, in der ESG-Berichte immer staerker von Investoren beachtet werden, ist dies zu einem strategischen Thema fuer Unternehmen geworden

X. Einfuehrungspfad: Dreistufige Umsetzungsstrategie

1. Bestandsaufnahme bestehender Modelle: Identifizieren Sie die Modelle mit den hoechsten Inferenzkosten als primaere Pruning-Kandidaten. Typischerweise sind das die Modelle mit den meisten Parametern und der hoechsten Aufruffrequenz im Live-Betrieb
2. Einfach beginnen: Verwenden Sie zunaechst den PyTorch Global-Pruning-Code aus Abschnitt IV dieses Artikels fuer einen Proof of Concept und beobachten Sie die Genauigkeitsveraenderungen bei verschiedenen Sparsity-Stufen. Die meisten Modelle verlieren bei 50 % Sparsity kaum an Genauigkeit
3. Schrittweise vertiefen: Nach Validierung der ersten Ergebnisse fuehren Sie eine kombinierte Pipeline aus strukturiertem Pruning, Quantisierung und Distillation ein. Im LLM-Szenario empfiehlt sich die direkte Verwendung von Wanda oder SparseGPT

Pruning ist keine experimentelle Frontier-Technologie, sondern eine von NVIDIA, Meta, Google und anderen Unternehmen im grossen Massstab validierte Engineering-Praxis. Sie muessen das Rad nicht neu erfinden -- oeffnen Sie PyTorch, fuehren Sie drei Zeilen Code aus und sehen Sie, wie viel ueberfluessiges Gewicht Ihr Modell verlieren kann.

Wenn Ihr Team gerade Modelloptimierungsstrategien evaluiert oder die optimale Balance zwischen Latenz, Kosten und Genauigkeit finden muss, laden wir Sie herzlich zu einem tiefgehenden Technikgespraech ein. Das Forschungsteam von Meta Intelligence begleitet Sie auf dem gesamten Weg -- von der Modelldiagnose bis zum Produktions-Deployment.