Key Findings
  • Die MoE-Architektur (z. B. das 671B-Modell von DeepSeek-V3) aktiviert pro Inferenz nur 37B Parameter – eine Strategie der „Gehirnpartitionierung", die wirtschaftliche Inferenz bei uebergrossen Modellen ermoeglicht
  • Speculative Decoding laesst ein kleines Modell fuer das grosse „Entwuerfe schreiben" – 2-3x Beschleunigung bei mathematisch vollstaendig aequivalenter Ausgabe – die einzige Beschleunigungstechnik, die null Genauigkeitsverlust garantiert
  • Token Merging halbiert die Token-Anzahl in ViT bei weniger als 0,2 % Genauigkeitsverlust; angewandt auf Stable Diffusion erzielt es eine 2x-Beschleunigung, die mit blossem Auge kaum erkennbar ist
  • DeepCache ueberspringt redundante U-Net-Berechnungen in Diffusionsmodellen und erreicht training-frei eine 2,3x-Beschleunigung – in Kombination mit Token Merging ueber 4x

1. Das „Einheitsgroesse"-Rechenproblem der KI: Sie bezahlen fuer jeden Token die gleiche Rechenleistung

Pruning, Distillation, Quantisierung – diese drei grossen Modellkomprimierungstechniken haben eine gemeinsame Eigenschaft: Sie veraendern die Groesse oder Praezision des Modells dauerhaft vor dem Deployment. Sobald die Komprimierung abgeschlossen ist, investiert das Modell fuer jede Eingabe den gleichen Rechenaufwand. Die Realitaet sieht jedoch anders aus: Nicht alle Eingaben sind gleich schwierig.

Stellen Sie sich ein Uebersetzungssystem vor, das einen Vertrag bearbeitet: Das Wort „The" erfordert kaum Nachdenken, aber „indemnification" koennte verlangen, dass das Modell alle Parameter nutzt, um es praezise zu uebersetzen. Traditionelle Modelle investieren fuer beide Woerter exakt die gleiche Rechenleistung – eine systematische Verschwendung. Harvard Business Review weist darauf hin[1], dass der Energieverbrauch der globalen KI-Infrastruktur mit alarmierender Geschwindigkeit waechst, wobei ein erheblicher Teil der Rechenleistung fuer „unnoetige Berechnungen" aufgewendet wird.

Die Forschung des MIT Sloan Management Review[2] zeigt ferner, dass effizienter KI-Einsatz oft einen hoeheren geschaeftlichen Ertrag bringt als das Streben nach dem groessten Modell. Dynamic Computation ist genau das technische Paradigma zur Loesung dieses Problems: Das Modell passt den eingesetzten Rechenaufwand automatisch an die Schwierigkeit der Eingabe an. Einfache Eingaben werden schnell verarbeitet, komplexe Eingaben erhalten die vollen Ressourcen.

Im Gegensatz zur statischen Komprimierung veraendert Dynamic Computation weder die Groesse noch die Praezision des Modells – das Modell behaelt seine vollstaendigen Faehigkeiten, setzt sie aber nur bei Bedarf ein. Damit wird es zur vierten Saeule der Modelleffizienz – vollstaendig orthogonal zu Pruning, Distillation und Quantisierung und mit diesen kombinierbar.

2. Technische Entwicklung: Von adaptiver Berechnung zu bedingter Inferenz

2.1 Adaptive Computation Time: Das Netzwerk entscheidet selbst, wie lange es „nachdenkt"

Die theoretischen Wurzeln von Dynamic Computation reichen bis ins Jahr 2016 zurueck. Alex Graves schlug die Adaptive Computation Time (ACT)[3] vor: Rekurrente neuronale Netze (RNN) lernen selbst, wie viele Berechnungsschritte jede Eingabe benoetigt. Das Netzwerk entscheidet ueber eine „Stoppwahrscheinlichkeit", wann die Berechnung beendet wird – einfache Eingaben benoetigen nur einen Schritt, komplexe Eingaben koennen „laenger nachdenken".

Die zentrale Erkenntnis von ACT ist revolutionaer: Der Rechenaufwand selbst kann ein lernbarer Output des Modells sein. Dieses Konzept legte den Grundstein fuer alle nachfolgenden Dynamic-Computation-Techniken – von Early Exit bis Mixture of Experts sind alle unterschiedliche technische Umsetzungen dieses Gedankens.

2.2 Early Exit: Einfache Token fruehzeitig „abschliessen" lassen

Moderne Transformer-Architektur-Modelle haben typischerweise Dutzende von Schichten. Aber muss jede Eingabe alle Schichten durchlaufen? Googles CALM (Confident Adaptive Language Modeling)[4], veroeffentlicht auf der NeurIPS 2022, bewies, dass die Antwort Nein lautet.

Der Mechanismus von CALM ist intuitiv und elegant: An den Output jeder Schicht wird ein leichtgewichtiger „Konfidenzklassifikator" angehaengt. Wenn die Vorhersagekonfidenz eines Tokens den Schwellenwert ueberschreitet, kann es vorzeitig austreten – ohne die verbleibenden Schichten zu durchlaufen. CALM zeigte auf dem T5-Modell erstaunliche Ergebnisse: Der durchschnittliche Rechenaufwand sank auf ein Drittel des Originals, waehrend die Ausgabequalitaet nahezu unveraendert blieb.

Microsofts SkipDecode[5] loeste darueber hinaus einen zentralen Schmerzpunkt von Early Exit im praktischen Einsatz – die Effizienz der Batch-Inferenz. In einem Batch benoetigen verschiedene Sequenzen unterschiedliche Berechnungstiefen. SkipDecode nutzt eine Token-basierte Schicht-Sprung-Strategie und adaptiven KV-Cache, damit verschiedene Sequenzen bei unterschiedlichen Schichten austreten koennen und gleichzeitig die Hardware-Effizienz der Batch-Inferenz erhalten bleibt.

2.3 Mixture of Experts: Nur die benoetigten Experten aktivieren

Wenn Early Exit die „vertikale" Dynamic Computation darstellt (Auswahl, wie viele Schichten durchlaufen werden), dann ist Mixture of Experts (MoE) die „horizontale" Dynamic Computation – in jeder Schicht wird nur ein Teil der Parameter aktiviert.

Switch Transformer[6] (JMLR 2022) ist ein Meilenstein der MoE-Architektur. William Fedus und Kollegen bei Google ersetzten jede FFN-Schicht durch mehrere „Experten"-Subnetzwerke, wobei jeder Token nur an einen Experten weitergeleitet wird (Top-1-Routing). Dieses scheinbar einfache Design ermoeglichte die Skalierung der Modellparameter auf 1,6 Billionen – wobei bei jeder Inferenz nur ein kleiner Teil davon genutzt wird.

Mistral AIs Mixtral 8x7B[7] machte MoE praxistauglich. Aus 8 Experten werden jeweils 2 ausgewaehlt (Top-2-Routing); die Gesamtparameterzahl betraegt 46,7B, aber pro Token werden nur 12,9B aktiviert – mit weniger als einem Fuenftel der Rechenleistung von LLaMA-2 70B wird eine vergleichbare Leistung erzielt. Mixtral bewies, dass MoE nicht nur ein Forschungskonzept ist, sondern ein direkt einsetzbares effizientes Architekturdesign.

DeepSeek-V3[8] ist derzeit das Spitzenwerk der MoE-Architektur. Von den 671B Gesamtparametern umfasst es 256 Routing-Experten und 1 gemeinsam genutzten Experten; pro Token werden Top-8 ausgewaehlt, wodurch tatsaechlich etwa 37B Parameter aktiviert werden. In Kombination mit Multi-head Latent Attention (MLA) zur Komprimierung des KV-Cache konkurriert DeepSeek-V3 in mehreren Benchmarks mit GPT-4o und Claude 3.5 Sonnet – bei Trainingskosten von nur etwa 5,57 Millionen US-Dollar (ca. zwei Monate Training auf 2.048 H800-GPUs), weniger als ein Zehntel eines vergleichbaren dichten Modells.

ModellGesamtparameterAktive ParameterAktivierungsrateRouting-Strategie
Switch Transformer1.6T~einige B<1%Top-1
Mixtral 8x7B46.7B12.9B28%Top-2 / 8 experts
DeepSeek-V3671B37B5.5%Top-8 / 256 experts

2.4 Speculative Decoding: Ein kleines Modell erstellt „Entwuerfe" fuer das grosse

Autoregressive Sprachmodelle haben einen fundamentalen Engpass: Jeder Token muss warten, bis der vorherige Token generiert ist, bevor er beginnen kann. Das bedeutet, dass die Generierung von N Token N Forward-Passes erfordert, die nicht parallelisiert werden koennen. Speculative Decoding durchbricht diesen Engpass mit einem geschickten „Entwurf-und-Validierung"-Mechanismus.

In den Jahren 2022-2023 schlugen Leviathan et al. bei Google[9] und Chen et al. bei DeepMind[10] unabhaengig voneinander die gleiche Kernidee vor:

  1. Ein kleines Entwurfsmodell (z. B. OPT-125M) generiert schnell K Kandidaten-Token
  2. Diese K Token werden auf einmal an das grosse Modell zur Validierung gesendet (das grosse Modell kann parallel verarbeiten)
  3. Rejection Sampling entscheidet, ob jeder Kandidaten-Token akzeptiert oder abgelehnt wird

Der entscheidende Durchbruch liegt in der mathematischen Garantie: Die Wahrscheinlichkeitsverteilung der endgueltigen Ausgabe ist mit der des reinen grossen Modells vollstaendig identisch. Dies ist keine „Approximation" – es ist mathematisch streng aequivalent. Dadurch wird Speculative Decoding zur einzigen Inferenzbeschleunigungstechnik mit null Genauigkeitsverlust. In der Praxis wird eine 2-3x-Beschleunigung erreicht, besonders effektiv bei moderatem Faehigkeitsunterschied zwischen grossem und kleinem Modell.

Medusa[11] von der ICML 2024 schlaegt einen noch eleganteren Ansatz vor: Es wird kein separates Entwurfsmodell benoetigt, stattdessen werden mehrere Dekodierkoepfe direkt auf dem Originalmodell installiert. Jeder Kopf sagt Token an verschiedenen zukuenftigen Positionen vorher und validiert sie auf einmal ueber einen Tree-Attention-Mechanismus. Der Vorteil von Medusa liegt im einfacheren Deployment (nur ein Modell erforderlich), wobei die Dekodierkoepfe nur wenig Feinabstimmung benoetigen.

2.5 Token Merging: Redundante Token zusammenfuehren

Vision Transformer (ViT) teilt Bilder in N Patch-Token zur Verarbeitung auf. Viele Patches sind jedoch hochgradig redundant – benachbarte Patches in einem blauen Himmel tragen nahezu identische Informationen. Token Merging (ToMe)[12] (ICLR 2023) verfolgt die Strategie, in jeder Transformer-Schicht die aehnlichsten Token zusammenzufuehren.

ToMe verwendet bipartites Soft-Matching, um die optimalen Zusammenfuehrungs-Paare zu finden. Dieser Algorithmus erfordert weder das Erlernen neuer Parameter noch ein erneutes Training – er kann direkt auf vortrainierte ViT-Modelle angewendet werden. Auf ImageNet steigerte ToMe den Durchsatz von ViT-L/16 um das Doppelte, bei einem Genauigkeitsverlust von nur 0,2 %.

Noch spannender ist die Anwendung von ToMe auf Diffusionsmodelle[13]. Jeder Entrauschungsschritt von Stable Diffusion durchlaeuft ein U-Net (das Attention-Schichten enthaelt), und ToMe kann in jedem Schritt redundante Token zusammenfuehren. Die tomesd[14]-Bibliothek ermoeglicht es, SD mit einer einzigen Codezeile um 2x zu beschleunigen, wobei die Qualitaet der generierten Bilder mit blossem Auge kaum unterscheidbar ist. Noch wichtiger: ToMe laesst sich mit anderen Beschleunigungstechniken kombinieren – das Paper berichtet von bis zu 5,4x Beschleunigung.

2.6 Mixture-of-Depths: Jede Schicht entscheidet, ob sie rechnen soll

Waehrend MoE auswaehlt, „welcher Experte verwendet wird", geht Google DeepMinds Mixture-of-Depths (MoD)[15] noch radikaler vor – Token waehlen selbst, „ob sie diese Schicht durchlaufen".

MoD fuegt in jeder Schicht einen leichtgewichtigen Router hinzu, der basierend auf der Bedeutung des Tokens entscheidet, ob dieser die aktuelle Schicht „ueberspringen" soll. Uebersprungene Token werden direkt ueber die Residualverbindung zur naechsten Schicht weitergeleitet, ganz ohne Berechnung. Das Paper kam zu einer erstaunlichen Erkenntnis: Selbst bei nur 12,5 % der Rechenkapazitaet (jede Schicht verarbeitet nur 1/8 der Token) kann das Modell die Leistung der Vollkapazitaetsversion erreichen. Das bedeutet, dass MoD theoretisch die Inferenz um ueber 50 % beschleunigen kann, bei vergleichbarer Modellqualitaet.

Die Bedeutung von MoD liegt darin, dass es die erstaunliche Redundanz in Transformer-Berechnungen offenbart – die meisten Token muessen in den meisten Schichten gar nicht verarbeitet werden.

2.7 Feature Caching: Redundante Entrauschungsberechnungen ueberspringen

Die Inferenz von Diffusionsmodellen erfordert Dutzende von Entrauschungs-Iterationen, wobei jeder Schritt das vollstaendige U-Net durchlaeuft. Zwischen benachbarten Schritten aendern sich die hochrangigen Features des U-Net jedoch nur minimal. DeepCache[16] (CVPR 2024) nutzt diese Beobachtung: Hochrangige Features werden gecacht und nur die staerker veraenderten niedrigrangigen Features aktualisiert.

Konkret wird alle N Schritte das U-Net vollstaendig ausgefuehrt; in den Zwischenschritten werden nur die niedrigrangigen Zweige berechnet und die hochrangigen Features direkt aus dem Cache gelesen. Auf Stable Diffusion 1.5 erreicht DeepCache eine 2,3x-Beschleunigung, wobei CLIP Score und FID nahezu unveraendert bleiben. Darueber hinaus gilt:

3. Praktische Anwendungen in der textgenerativen KI

Die Anwendung von Dynamic Computation in textgenerativer KI hat den Weg von der Forschung in die Produktion bereits geschafft. Im Folgenden die drei wirkungsvollsten Praxisszenarien:

Szenario 1: Grossangelegte LLM-Services – MoE-Architektur

Der Erfolg von DeepSeek-V3 beweist eine wichtige These: Die naechste Generation von Frontier-Modellen benoetigt nicht unbedingt mehr Rechenleistung, sondern eine intelligentere Verteilung der Rechenressourcen. Ein Modell mit 671B Parametern klingt teuer, aber bei jeder Inferenz werden nur 37B aktiviert – die Inferenzkosten naehern sich damit denen eines dichten 30-40B-Modells. Die kommerzielle Version von Mixtral 8x7B (bereitgestellt ueber die Mistral-API oder AWS Bedrock) wird bereits von zahlreichen Unternehmen eingesetzt, da sie bei Qualitaet auf LLaMA-2-70B-Niveau eine ueber 6-fach hoehere Inferenzgeschwindigkeit bietet.

Szenario 2: Latenzempfindliche Anwendungen – Speculative Decoding

Konversationelle KI, Echtzeituebersetzung, automatische Code-Vervollstaendigung und aehnliche Anwendungen sind aeusserst latenzempfindlich. Speculative Decoding steigert die Antwortgeschwindigkeit grosser Modelle um 2-3x, ohne jegliche Qualitaetseinbussen. HuggingFace bietet ab Transformers v4.29+ native Unterstuetzung[17] – ein einziger assistant_model-Parameter genuegt zur Aktivierung. Auch Googles Gemini und Anthropics Claude nutzen in ihren Inferenz-Engines vergleichbare Techniken in grossem Umfang.

Szenario 3: Klassifikation und Verstehen – Early Exit

Fuer Aufgaben wie Textklassifikation, Sentimentanalyse und Named Entity Recognition benoetigen die meisten Eingaben nicht die volle Tiefe des Modells. Der Early-Exit-Mechanismus von CALM ermoeglicht es dem Modell, 80 % der einfachen Eingaben bereits in den ersten Schichten zu verarbeiten; nur die schwierigsten 20 % muessen alle Schichten durchlaufen. Dies eignet sich besonders fuer API-Dienste mit hohem Anfragevolumen – die durchschnittliche Latenz kann um das 2-3-Fache gesenkt werden.

4. Praktische Anwendungen in der bildgenerativen KI

Die Inferenzkosten von Diffusionsmodellen sind hoeher als die von LLMs (Dutzende Entrauschungsschritte x grosses U-Net), wodurch Dynamic Computation in diesem Bereich besonders wertvoll ist:

Szenario 1: Token Merging zur Generierungsbeschleunigung

tomesd[14] fuehrt in jedem Entrauschungsschritt von Stable Diffusion redundante Token zusammen. Bei einer Zusammenfuehrungsrate von 50 % steigt die Generierungsgeschwindigkeit von SD 1.5 um ca. 2x, der VRAM-Verbrauch sinkt, und die Qualitaetsunterschiede sind mit blossem Auge kaum erkennbar. Dies ist besonders wertvoll fuer E-Commerce-, Werbe- und Design-Workflows, die eine Massengenerierung von Bildern erfordern.

Szenario 2: DeepCache-Caching-Beschleunigung

DeepCache[18] zeigt bei SD, SDXL und Stable Video Diffusion durchweg eine Beschleunigung von ueber 2x. Fuer SDXL (das mehr VRAM benoetigt) sind die Einsparungen durch DeepCache besonders deutlich – Modelle, die zuvor High-End-GPUs erforderten, laufen nun fluessig auf Mittelklasse-Hardware.

Szenario 3: Technologie-Stacking – maximale Beschleunigung

Eine der staerksten Eigenschaften von Dynamic-Computation-Techniken ist ihre Kombinierbarkeit. Auf Stable Diffusion gleichzeitig eingesetzt:

Die Kombination aller drei kann eine 4-8x End-to-End-Beschleunigung erzielen und Stable Diffusion auf Consumer-GPUs nahe an Echtzeit-Generierung bringen.

5. Hands-on Lab: Token Merging (Computer Vision)

Wir beginnen mit der intuitivsten Technik – Token Merging auf ViT – und erleben praxisnah, wie das „Zusammenfuehren redundanter Token" die Inferenz beschleunigt.

Google Colab oeffnen (CPU genuegt, T4 ist schneller), neues Notebook erstellen und den folgenden Code der Reihe nach einfuegen:

5.1 Step 1 — Umgebungseinrichtung und Modell laden

!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

# Beispielbild herunterladen (Katze von 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")

# Vortrainiertes ViT-Base/16 laden (~86M Parameter)
model = timm.create_model("vit_base_patch16_224", pretrained=True)
model.eval()

# Bild-Vorverarbeitung
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
labels_url = "https://storage.googleapis.com/bit_models/ilsvrc2012_wordnet_lemmas.txt"
labels = requests.get(labels_url).text.strip().split("\n")

print(f"✓ Modell geladen: ViT-Base/16")
print(f"  Parameter: {sum(p.numel() for p in model.parameters()) / 1e6:.1f}M")
print(f"  Input-Token: {(224//16)**2 + 1} = 196 Patch-Token + 1 CLS-Token")

5.2 Step 2 — Benchmark-Tool

def benchmark(model, x, n_warmup=20, n_runs=200):
    """CPU-Inferenzlatenz messen (ms)"""
    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):
    """Vorhersageergebnis abrufen"""
    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

# ---- Basisdaten ----
pred, conf = predict(model, x, labels)
base_ms = benchmark(model, x)

print(f"{'='*60}")
print(f"  Basismodell (ViT-Base/16, ohne Token Merging)")
print(f"{'='*60}")
print(f"  Vorhersage: {pred}")
print(f"  Konfidenz: {conf:.1f}%")
print(f"  Inferenzlatenz: {base_ms:.2f} ms")
print(f"{'='*60}")

5.3 Step 3 — Token Merging anwenden

# ★ Token Merging: Mit einer Zeile anwenden ★
# tome.patch.timm modifiziert den Forward-Pass des Modells und fuehrt in jeder Schicht r Token zusammen
tome.patch.timm(model)

print(f"\n{'='*60}")
print(f"  Token Merging Vergleich")
print(f"{'='*60}")
print(f"{'r-Wert':<8} {'Latenz(ms)':<10} {'Speedup':<8} {'Vorhersage':<25} {'Konfidenz'}")
print(f"{'-'*60}")

for r in [0, 4, 8, 16, 24, 32]:
    model.r = r  # Pro Schicht r Token zusammenfuehren
    pred, conf = predict(model, x, labels)
    ms = benchmark(model, x)
    speedup = base_ms / ms
    marker = " ★ Empfohlen" if r == 16 else ""
    print(f"r={r:<5} {ms:<9.2f} {speedup:<7.2f}x {pred:<25} {conf:.1f}%{marker}")

print(f"{'='*60}")
print(f"\n★ Zentrale Beobachtungen:")
print(f"  • r=0 entspricht dem Originalmodell (keine Zusammenfuehrung)")
print(f"  • r=16 ist der optimale Kompromiss zwischen Qualitaet und Geschwindigkeit")
print(f"  • Selbst bei r=32 (starke Zusammenfuehrung) bleibt die Vorhersage meist korrekt")
print(f"  • ViT-Base hat 12 Schichten → r=16 bedeutet 16 Token-Paare pro Schicht zusammenfuehren")
print(f"  • Vollstaendig training-frei — direkt auf jedes vortrainierte ViT anwendbar")

6. Hands-on Lab: Speculative Decoding (Sprachmodelle)

Als Naechstes kommt die praktisch relevanteste Dynamic-Computation-Technik fuer LLMs – Speculative Decoding. Wir nutzen die native assistant_model-API[17] von HuggingFace, um zu erleben, wie ein kleines Modell „Entwuerfe fuer das grosse" erstellt.

Google Colab oeffnen (T4-GPU waehlen), neues Notebook erstellen und den folgenden Code der Reihe nach einfuegen:

6.1 Step 1 — Zielmodell und Entwurfsmodell laden

!pip install transformers accelerate -q

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import time

# ★ Entscheidend: Ein grosses und ein kleines Modell derselben Familie ★
target_name = "facebook/opt-1.3b"   # Zielmodell: 1,3B Parameter
draft_name  = "facebook/opt-125m"   # Entwurfsmodell: 125M Parameter (10x kleiner)

print("Lade Zielmodell (1.3B)...")
tokenizer = AutoTokenizer.from_pretrained(target_name)
target_model = AutoModelForCausalLM.from_pretrained(
    target_name, torch_dtype=torch.float16, device_map="auto"
)

print("Lade Entwurfsmodell (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✓ Modelle geladen")
print(f"  Zielmodell: {target_name} ({target_mem:.2f} GB)")
print(f"  Entwurfsmodell: {draft_name} ({draft_mem:.2f} GB)")
print(f"  Entwurfsmodell ist nur {draft_mem/target_mem*100:.1f}% des Zielmodells")

6.2 Step 2 — Standardgenerierung 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"  Standardgenerierung vs. Speculative Decoding Vergleich")
print(f"{'='*70}")

total_standard, total_spec = 0, 0

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

    # ---- Standardgenerierung (Token fuer Token) ----
    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,  # ★ Nur diesen einen Parameter hinzufuegen ★
    )
    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: {prompt}")
    print(f"  Standard: {t_standard:.2f}s | Spekulativ: {t_spec:.2f}s | "
          f"Speedup: {t_standard/t_spec:.2f}x | Token: {tokens}")

    # Ueberpruefen, dass die Ausgaben identisch sind (mathematische Garantie von Speculative Decoding)
    match = torch.equal(out_standard, out_spec)
    print(f"  Ausgaben vollstaendig identisch: {'✓' if match else '✗'}")

6.3 Step 3 — Vollstaendige Statistik

print(f"\n{'='*70}")
print(f"  Speculative Decoding Zusammenfassung")
print(f"{'='*70}")
print(f"  Gesamtzeit Standardgenerierung:     {total_standard:.2f}s")
print(f"  Gesamtzeit Speculative Decoding:    {total_spec:.2f}s")
print(f"  Gesamt-Speedup:                     {total_standard/total_spec:.2f}x")
print(f"{'='*70}")
print(f"\n★ Zentrale Beobachtungen:")
print(f"  • Ausgabe ist mathematisch vollstaendig aequivalent zur Standardgenerierung (null Genauigkeitsverlust)")
print(f"  • Der Beschleunigungseffekt haengt von der Trefferquote des Entwurfsmodells ab")
print(f"  • Je naeher das Entwurfsmodell der Verteilung des Zielmodells → desto groesser die Beschleunigung")
print(f"  • Modelle derselben Familie (z. B. OPT-125M → OPT-1.3B) funktionieren am besten")
print(f"  • Native Unterstuetzung ab HuggingFace Transformers v4.29+")
print(f"  • Kombinierbar mit Quantisierung: 4-Bit-Zielmodell + kleines Entwurfsmodell")

7. Hands-on Lab: DeepCache + ToMe (Diffusionsmodell-Beschleunigung)

Zum Abschluss kombinieren wir zwei Dynamic-Computation-Techniken – DeepCache (Feature-Caching) und ToMe (Token-Zusammenfuehrung) – auf Stable Diffusion, um die Leistung der „training-freien" Beschleunigung zu erleben.

Google Colab oeffnen (T4-GPU waehlen), neues Notebook erstellen und den folgenden Code der Reihe nach einfuegen:

7.1 Step 1 — Umgebungseinrichtung

!pip install diffusers transformers accelerate DeepCache tomesd -q

import torch
import time
from diffusers import StableDiffusionPipeline

# Stable Diffusion 1.5 laden
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 geladen")
print(f"  VRAM-Verbrauch: {torch.cuda.memory_allocated()/1024**3:.2f} GB")

7.2 Step 2 — Basisgenerierung

# ---- Basis: Standard-50-Schritte-Generierung ----
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"Basis (50 Schritte Standardgenerierung): {base_time:.2f}s")
image_base.save("01_baseline.png")

7.3 Step 3 — DeepCache-Beschleunigung

from DeepCache import DeepCacheSDHelper

# ★ DeepCache: Hochrangige U-Net-Features cachen ★
helper = DeepCacheSDHelper(pipe=pipe)
helper.set_params(
    cache_interval=3,    # Alle 3 Schritte das U-Net vollstaendig berechnen
    cache_branch_id=0,   # Welche Schicht-Features gecacht werden
)
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 (Speedup {base_time/dc_time:.2f}x)")
image_dc.save("02_deepcache.png")

7.4 Step 4 — ToMe-Beschleunigung

import tomesd

# ★ ToMe: Redundante Token zusammenfuehren ★
tomesd.apply_patch(pipe, ratio=0.5)  # 50% der Token zusammenfuehren

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 (Speedup {base_time/tome_time:.2f}x)")
image_tome.save("03_tome.png")

7.5 Step 5 — DeepCache + ToMe kombiniert

# ★ Kombination: 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 (Speedup {base_time/both_time:.2f}x)")
image_both.save("04_deepcache_tome.png")

7.6 Step 6 — Vollstaendiger Vergleich

print(f"\n{'='*60}")
print(f"  Dynamische Beschleunigung von Diffusionsmodellen – Vollstaendiger Vergleich")
print(f"  Stable Diffusion 1.5 / 50 Schritte / T4 GPU")
print(f"{'='*60}")
print(f"{'Methode':<20} {'Zeit(s)':<10} {'Speedup':<8} {'Training noetig?'}")
print(f"{'-'*60}")

results = [
    ("Standard (Basis)", base_time, 1.0, "—"),
    ("DeepCache", dc_time, base_time/dc_time, "Nein"),
    ("ToMe (50%)", tome_time, base_time/tome_time, "Nein"),
    ("DeepCache + ToMe", both_time, base_time/both_time, "Nein"),
]

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★ Zentrale Beobachtungen:")
print(f"  • Beide Techniken sind vollstaendig training-frei — sofort einsatzbereit")
print(f"  • Die Beschleunigungseffekte von DeepCache und ToMe sind kombinierbar")
print(f"  • Mit zusaetzlicher INT8-Quantisierung kann der Gesamt-Speedup 5x ueberschreiten")
print(f"  • Vergleichen Sie die generierten Bilder in den Dateien (Qualitaetsunterschiede meist nicht erkennbar)")
print(f"  • Diese Techniken funktionieren ebenso mit SDXL und Stable Video Diffusion")

8. Das Oekosystem im Ueberblick

Das Tool-Oekosystem fuer Dynamic Computation reift rasch heran – von Forschungsprototypen bis hin zu Produktionsdeployments gibt es passende Loesungen:

Mixture of Experts Frameworks

Speculative Decoding

Token Merging

Beschleunigung von Diffusionsmodellen

9. Von technischen Kennzahlen zur Geschaeftswirkung

Die Auswirkungen von Dynamic Computation auf den KI-Einsatz in Unternehmen sind mehrdimensional:

10. Einfuehrungspfad: Dreistufige Praxisstrategie

  1. Sofortige Wirkung – Bestehende Dynamic-Computation-Modelle und -Tools nutzen: Deployen Sie Mixtral 8x7B oder DeepSeek-V3 als LLM-Inferenz-Backend (ueber vLLM/SGLang); fuegen Sie bei der Bildgenerierung tomesd + DeepCache hinzu (zwei Codezeilen, training-frei). Diese Massnahmen erfordern keinerlei Modellaenderungen und koennen innerhalb eines Tages umgesetzt werden
  2. Schrittweise Validierung – Speculative Decoding fuer bestehende Modelle: Koppeln Sie Ihr bestehendes LLM mit einem kleinen Entwurfsmodell derselben Familie (z. B. Phi-3-mini mit Phi-3-small), aktivieren Sie Speculative Decoding ueber den assistant_model-Parameter von HuggingFace. Messen Sie die Latenzreduzierung und Ausgabekonsistenz und pruefen Sie die Eignung fuer Ihren Anwendungsfall
  3. Tiefenoptimierung – Full-Stack Dynamic Computation Integration: Erwaegen Sie Medusa oder EAGLE als Alternative zum Standard-Speculative-Decoding (hoehere Beschleunigung); evaluieren Sie MoE-Feinabstimmung (z. B. LoRA-Feinabstimmung spezifischer Experten auf Mixtral); kombinieren Sie Dynamic Computation mit Quantisierung und Pruning fuer einen vollstaendigen Inferenz-Effizienz-Stack. In der Bildgenerungs-Pipeline DeepCache + ToMe + INT8-Quantisierung kombinieren, mit dem Ziel einer 5x+ End-to-End-Beschleunigung

Dynamic Computation ist die „vierte Saeule" der Modelleffizienz – sie veraendert weder die Groesse noch die Praezision des Modells, sondern lehrt es, „je nach Situation unterschiedlich viel Aufwand zu betreiben". Im Gegensatz zu Pruning (permanentes Entfernen von Parametern), Distillation (Training eines neuen Modells) und Quantisierung (Reduzierung der Praezision) behaelt Dynamic Computation die vollstaendigen Faehigkeiten des Modells bei und verteilt die Rechenressourcen lediglich intelligenter. Diese vier Techniken sind vollstaendig orthogonal, kombinierbar und bilden gemeinsam den vollstaendigen Werkzeugkasten fuer den Weg der KI vom Labor zum Grosseinsatz.

Wenn Ihr Team evaluiert, wie die Inferenzkosten ohne Qualitaetseinbussen erheblich gesenkt werden koennen, oder wenn Sie die Reaktionszeit grosser Modelle in latenzempfindlichen Szenarien beschleunigen muessen, freuen wir uns auf ein vertieftes technisches Gespraech mit Ihnen. Das Forschungsteam von Meta Intelligence begleitet Sie auf dem gesamten Weg – von der Diagnose von Performance-Engpaessen bis zum vollstaendig optimierten Deployment.