Wie Precision Scaling den CO₂-Fußabdruck von Deep Learning reduziert

Mit der zunehmenden Verbreitung künstlicher Intelligenz in unterschiedlichen Branchen werden immer mehr GPUs eingesetzt, mehr Trainingsdurchläufe ausgeführt und mehr Server rund um die Uhr betrieben. Zusammen tragen diese Faktoren erheblich zum weltweiten Stromverbrauch bei. Moderne GPUs können jeweils etwa 300 bis 700 Watt aufnehmen. Werden sie in Clustern mit Hunderten oder Tausenden Einheiten betrieben, steigt der gesamte Energiebedarf sehr schnell an. Gleichzeitig wachsen Modellgrößen exponentiell, von Millionen über Milliarden bis hin zu Billionen Parametern. Die Trainingskosten steigen dabei oft noch schneller als die Modellgröße selbst, wodurch auch der Energiebedarf stark zunimmt. Dadurch wächst der CO₂-Fußabdruck von Training, Inferenz und großflächigem KI-Betrieb deutlich.

Aus diesem Grund ist Energieeffizienz inzwischen ein zentrales Entwicklungsziel für Machine-Learning-Systeme. Unternehmen optimieren Modelle nicht mehr ausschließlich auf Genauigkeit und Geschwindigkeit. Immer wichtiger werden auch Recheneffizienz, Nachhaltigkeit und geringere Betriebskosten. Eine der wirksamsten Methoden, um diese Ziele zu erreichen, ist Precision Scaling. Dabei wird die Anzahl der Bits reduziert, mit denen Modellgewichte und Aktivierungen dargestellt werden.

Vereinfacht gesagt verschiebt Precision Scaling Modelle von hochpräzisen Formaten wie FP32 hin zu kompakteren numerischen Formaten wie FP16, INT8 oder sogar INT4. Weniger Bits bedeuten weniger Rechenaufwand, weniger Datenbewegung im Speicher und einen niedrigeren Energieverbrauch, häufig ohne größere Leistungseinbußen. Dieser Ansatz entwickelt sich zunehmend zu einer wichtigen Methode, um energieeffiziente Deep-Learning-Systeme sowohl für Training als auch für Inferenz aufzubauen.

Wichtige Grundbegriffe im Deep Learning

Bevor es ins Detail geht, helfen einige grundlegende Begriffe dabei, den Artikel besser zu verstehen und moderne Deep-Learning-Systeme einzuordnen.

Zentrale Rechenkonzepte

• FLOPs (Floating Point Operations per Second): Diese Kennzahl beschreibt, wie viele mathematische Operationen, etwa Additionen oder Multiplikationen, ein Prozessor pro Sekunde ausführen kann. Mehr FLOPs bedeuten in der Regel eine höhere Rechenleistung.
• Matrixmultiplikationen (MatMuls): Eine grundlegende Operation in neuronalen Netzen, bei der zwei Matrizen miteinander multipliziert werden. MatMuls kommen in Attention-Schichten, MLPs und Convolution-Schichten zum Einsatz und verursachen einen großen Teil des Trainingsaufwands.
• Tensoren: Mehrdimensionale Arrays, etwa Vektoren, Matrizen oder höherdimensionale Datenblöcke, in denen Daten innerhalb von Deep-Learning-Modellen gespeichert werden. Fast alle Operationen in neuronalen Netzen erhalten Tensoren als Eingabe und erzeugen Tensoren als Ausgabe.
• Bits: Ein Bit ist die kleinste Dateneinheit in der Informatik. Die Anzahl der Bits bestimmt, wie genau eine Zahl gespeichert werden kann, zum Beispiel FP32 mit 32 Bits. Weniger Bits führen meist zu schnellerer Berechnung und geringerem Speicherbedarf.

Präzisions- und Zahlenformate

• Mixed Precision Training: Ein Trainingsverfahren, bei dem unterschiedliche Teile eines Modells verschiedene Zahlenformate verwenden, etwa FP16 für Berechnungen und FP32 für numerische Stabilität. Dadurch kann das Training beschleunigt werden, während die Genauigkeit stabil bleibt.
• Low-Precision-Formate: FP32 gilt als hohe Präzision, FP16 und BF16 als mittlere Präzision, während FP8, INT8 und INT4 sehr niedrige Präzision darstellen. Niedrigere Präzision senkt Rechenaufwand, Speicherbedarf und Energieverbrauch.
• Quantisierung: Der Prozess, bei dem Werte mit weniger Bits gespeichert und berechnet werden. Quantisierung wird häufig bei der Inferenz eingesetzt, um den Speicherbedarf zu reduzieren und die Ausführung zu beschleunigen.

Performance- und Effizienzkonzepte

• Durchsatz: Die Anzahl an Samples, Tokens oder Anfragen, die ein System pro Sekunde verarbeiten kann. Ein höherer Durchsatz steht für eine schnellere Modellleistung.
• Latenz: Die Zeit, die benötigt wird, bis eine einzelne Eingabe eine Antwort erhält. Eine geringere Latenz ermöglicht schnellere Interaktionen.
• GPU-Stunden: Eine Kennzahl für Kosten und Effizienz, die beschreibt, wie lange GPUs genutzt werden. Wenn beispielsweise 8 GPUs 10 Stunden lang laufen, entspricht das 80 GPU-Stunden.
• Speicherbandbreite: Die Geschwindigkeit, mit der Daten zwischen GPU-Speicher und Recheneinheiten übertragen werden. Das ist wichtig, weil viele neuronale Workloads stärker durch Speicherbewegung als durch reine Rechenleistung begrenzt sind.

Trainingsdynamik und Modellkonzepte

• Aktivierungen: Zwischenergebnisse, die jede Schicht während des Forward Pass erzeugt. Beim Training werden Aktivierungen gespeichert, damit später Gradienten berechnet werden können.
• Gradienten: Werte, die während der Backpropagation berechnet werden und dem Modell zeigen, wie seine Gewichte angepasst werden sollen.
• Optimizer States: Zusätzliche Tensoren, etwa Momentum oder Varianz, die Optimierer wie Adam oder SGD verwalten, um das Training stabiler zu machen.
• Gewichte (Parameter): Die lernbaren Werte innerhalb eines Modells. Sie werden während des Trainings aktualisiert, um den Loss zu verringern.
• KV Cache (Key-Value Cache): Eine Speicherstruktur in Transformer-Modellen, die während der Inferenz frühere Attention-Zustände speichert, um die Dekodierung zu beschleunigen.

Weitere nützliche Begriffe

• Compute-Bound vs. Memory-Bound Workloads: Compute-bound bedeutet, dass ein Workload durch mathematische Operationen begrenzt ist. Memory-bound bedeutet, dass die Begrenzung vor allem durch Datenbewegung entsteht.
• Unterschiedliche Aufgaben können unterschiedliche Engpässe haben.
• Epoche: Ein vollständiger Durchlauf durch den gesamten Trainingsdatensatz.
• Batch Size: Die Anzahl der Samples, die in einem einzelnen Forward- und Backward-Pass verarbeitet werden.
• Modellgröße: Die Anzahl der Parameter in einem Modell. Größere Modelle können leistungsfähiger sein, sind aber auch teurer zu trainieren.

Die folgenden ausführlichen Python-Beispiele zeigen diese Kernkonzepte, darunter FLOPs, Tensoren, Matrixmultiplikationen, Durchsatz, GPU-Stunden, Mixed Precision und Quantisierung in einer praxisnahen und ausführbaren Form.

PyTorch-Lightning-Version

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
import pytorch_lightning as pl
from pytorch_lightning.callbacks import LearningRateMonitor
from pytorch_lightning.strategies import DDPStrategy
from torch.cuda.amp import GradScaler
import time

# -------------------------------------------
# Mixed Precision + Basic Lightning Model
# -------------------------------------------

class LightningMLP(pl.LightningModule):
    def __init__(self):
        super().__init__()
        self.model = nn.Sequential(
            nn.Linear(1024, 2048),
            nn.ReLU(),
            nn.Linear(2048, 1024)
        )
        self.loss_fn = nn.MSELoss()

    def forward(self, x):
        return self.model(x)

    def training_step(self, batch, batch_idx):
        x, y = batch
        with torch.cuda.amp.autocast():     # Mixed precision forward pass
            preds = self.model(x)
            loss = self.loss_fn(preds, y)
        self.log("train_loss", loss)
        return loss

    def configure_optimizers(self):
        return torch.optim.Adam(self.parameters(), lr=1e-3)

# -------------------------------------------
# Dataset
# -------------------------------------------

X = torch.randn(10_000, 1024)
Y = torch.randn(10_000, 1024)
dataset = TensorDataset(X, Y)
loader = DataLoader(dataset, batch_size=32, shuffle=True)

# -------------------------------------------
# Throughput Measurement
# -------------------------------------------

dummy_batch = next(iter(loader))[0]

start = time.time()
for _ in range(200):
    _ = dummy_batch @ dummy_batch.T
end = time.time()

throughput = (200 * dummy_batch.shape[0]) / (end - start)
print(f"Matrix Throughput: {throughput:.2f} samples/sec")

# -------------------------------------------
# Trainer with Mixed Precision
# -------------------------------------------

trainer = pl.Trainer(
    max_epochs=2,
    accelerator="gpu",
    devices=1,
    precision=16,              # Mixed Precision
    callbacks=[LearningRateMonitor(logging_interval="epoch")],
)

model = LightningMLP()
trainer.fit(model, loader)

# -------------------------------------------
# GPU Hours Example
# -------------------------------------------

num_gpus = 4
training_time_hours = 6

gpu_hours = num_gpus * training_time_hours
print(f"Total GPU Hours: {gpu_hours} GPU-hours")

# -------------------------------------------
# INT8 Quantization (Post-Training)
# -------------------------------------------

model_cpu = model.to("cpu")
quantized = torch.ao.quantization.quantize_dynamic(
    model_cpu, {nn.Linear}, dtype=torch.qint8
)

test_input = torch.randn(1, 1024)
out = quantized(test_input)
print("Quantized Output Shape:", out.shape)

# -------------------------------------------
# KV Cache Example
# -------------------------------------------

num_heads = 8
seq_len = 16
head_dim = 64

kv_cache = {
    "key": torch.randn(num_heads, seq_len, head_dim),
    "value": torch.randn(num_heads, seq_len, head_dim),
}

print("KV Cache Shapes:", {k: v.shape for k, v in kv_cache.items()})

Das PyTorch-Lightning-Beispiel zeigt, wie ein kleines neuronales Netz mit Mixed Precision und FP16 trainiert wird. Lightning übernimmt einen großen Teil des Trainingsablaufs, sodass im Wesentlichen das Modell definiert und die gewünschte Präzision ausgewählt werden muss.

Dieses Beispiel zeigt:

• Wie Mixed Precision das Training beschleunigen kann
• Wie Lightning Trainingsschleifen vereinfacht
• Wie GPUs automatisch Tensor Cores für schnellere Matrixmultiplikationen nutzen können

TensorFlow/Keras-Version

import tensorflow as tf
from tensorflow import keras
import time

# Enable mixed precision globally
mixed_precision = tf.keras.mixed_precision.set_global_policy("mixed_float16")

# ------------------------------------------------------
# Simple MLP with Mixed Precision
# ------------------------------------------------------

inputs = keras.Input(shape=(1024,))
x = keras.layers.Dense(2048, activation="relu")(inputs)
outputs = keras.layers.Dense(1024)(x)

model = keras.Model(inputs, outputs)

model.compile(
    optimizer=keras.optimizers.Adam(),
    loss="mse"
)

# ------------------------------------------------------
# Dataset
# ------------------------------------------------------

X = tf.random.normal((10000, 1024))
Y = tf.random.normal((10000, 1024))

dataset = tf.data.Dataset.from_tensor_slices((X, Y)).batch(32)

# ------------------------------------------------------
# FLOPs Calculation Example
# ------------------------------------------------------

def compute_flops(M, N, K):
    return 2 * M * N * K

flops = compute_flops(2048, 2048, 2048)
print(f"FLOPs for matmul: {flops/1e9:.2f} GFLOPs")

# ------------------------------------------------------
# Measure Throughput
# ------------------------------------------------------

batch = next(iter(dataset))

start = time.time()
for _ in range(200):
    _ = tf.matmul(batch[0], batch[0], transpose_b=True)
end = time.time()

throughput = (200 * batch[0].shape[0]) / (end - start)
print(f"TF Throughput: {throughput:.2f} samples/sec")

# ------------------------------------------------------
# Train
# ------------------------------------------------------

model.fit(dataset, epochs=2)

# ------------------------------------------------------
# GPU Hours Example
# ------------------------------------------------------

num_gpus = len(tf.config.list_physical_devices("GPU"))
training_time_hours = 4
gpu_hours = num_gpus * training_time_hours

print("GPU Hours:", gpu_hours)

# ------------------------------------------------------
# Post-Training Quantization (INT8)
# ------------------------------------------------------

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]  # Enables INT8
tflite_model = converter.convert()

print("TFLite INT8 model size:", len(tflite_model) / 1024, "KB")

# ------------------------------------------------------
# KV Cache Example
# ------------------------------------------------------

num_heads = 8
seq_len = 16
head_dim = 64

kv_cache = {
    "k": tf.random.normal((num_heads, seq_len, head_dim)),
    "v": tf.random.normal((num_heads, seq_len, head_dim)),
}

print("KV Cache Shapes:", {k: v.shape for k, v in kv_cache.items()})

Das TensorFlow/Keras-Beispiel verdeutlicht dasselbe Prinzip, indem ein Modell mit Mixed Precision trainiert wird, um Trainingsgeschwindigkeit und Effizienz zu verbessern. TensorFlow aktiviert Mixed Precision global und setzt FP16 automatisch dort ein, wo es sicher möglich ist.

Dieses Beispiel zeigt:

• Wie Mixed Precision in TensorFlow genutzt wird
• Wie Modelle schneller trainieren und dabei weniger GPU-Speicher benötigen können
• Wie TensorFlow Loss Scaling und FP32-Stabilität automatisch verwaltet

Den CO₂-Fußabdruck von Deep Learning verstehen

Deep-Learning-Modelle sind leistungsfähig, benötigen jedoch auch viel Energie. Dieser Energieverbrauch ist einer der Hauptgründe dafür, dass ihr CO₂-Fußabdruck weiter steigt. Da ein großer Teil des weltweiten Stroms weiterhin aus fossilen Energieträgern stammt, kann jedes zusätzliche Watt, das GPUs verbrauchen, letztlich zu zusätzlichen CO₂-Emissionen beitragen.

Das Training großer Modelle gehört zu den wichtigsten Treibern dieses Energiebedarfs. Modelle wie Transformers und Vision Transformers (ViTs) führen für jedes Token oder jeden Bildausschnitt enorme Mengen an Matrixmultiplikationen aus. Außerdem verarbeiten sie den gesamten Datensatz mehrfach, oft über viele parallel laufende GPUs hinweg und über Tage oder sogar Wochen. Diese dauerhaft arbeitenden GPUs verbrauchen erhebliche Mengen Strom.

Mehrere technische Faktoren machen Deep Learning zusätzlich energieintensiv. Die Modellgröße spielt eine zentrale Rolle, da größere Modelle mehr Berechnungen benötigen. Die Sequenzlänge, insbesondere bei Transformern, kann den Rechenaufwand quadratisch erhöhen. Wird die Sequenzlänge verdoppelt, kann sich der Rechenbedarf vervierfachen. Auch die Batch Size beeinflusst den Energieverbrauch. Größere Batches können das Training beschleunigen, benötigen aber pro Schritt mehr Leistung. Zusätzlich können ineffiziente Hardware, ältere GPUs, ungünstige Kühlung oder langsamer Speicherzugriff den Energieverbrauch weiter erhöhen.

Dieser gesamte Strombedarf führt direkt zu CO₂-Emissionen. Da weltweit weiterhin Kohle, Erdgas und andere fossile Brennstoffe zur Stromerzeugung genutzt werden, kann eine hohe GPU-Auslastung dazu führen, dass mehr fossile Energie bereitgestellt werden muss.

Deshalb wird eine bessere Energieeffizienz im Deep Learning für Unternehmen und Forschung zunehmend wichtiger.

Eine der effektivsten Möglichkeiten, diesen CO₂-Einfluss zu verringern, ist Precision Scaling. Präzision beschreibt, wie viele Bits zur Darstellung von Zahlen während einer Berechnung genutzt werden. FP32 verwendet beispielsweise 32 Bits, während FP16 nur 16 Bits nutzt und damit halb so groß ist. FP32 benötigt mehr Speicherbandbreite und aufwendigere Berechnungen, was zu höherem Energieverbrauch führt. FP16 ist dagegen schlanker und ermöglicht es GPUs, Daten schneller und effizienter zu verarbeiten.

Man kann es mit dem Heben von Gewichten vergleichen: FP32 ist wie eine 10-kg-Hantel, FP16 wie eine 5-kg-Hantel.

Die Bewegung bleibt gleich, aber FP16 erfordert bei jeder Ausführung weniger Aufwand. Über Millionen oder Milliarden Operationen hinweg kann dies den Stromverbrauch deutlich reduzieren.

Moderne GPUs enthalten spezialisierte Hardware, sogenannte Tensor Cores, die darauf ausgelegt sind, FP16 und noch niedrigere Präzisionen wie INT8 oder INT4 besonders effizient auszuführen. Wenn niedrigere Präzisionsformate überall dort eingesetzt werden, wo es möglich ist, lässt sich der Energiebedarf für Training und Inferenz stark senken, ohne die Modellleistung aufzugeben.

Was ist Precision Scaling?

Precision Scaling ist eine Technik, bei der die numerische Präzision, also die Anzahl der Bits, angepasst wird, mit denen Zahlen in Deep-Learning-Modellen während Training, Inferenz oder in beiden Phasen dargestellt werden. In Deep Learning werden jedes Gewicht, jede Aktivierung, jeder Gradient und weitere Werte in einem numerischen Format gespeichert. Diese Werte können in unterschiedlichen Präzisionen dargestellt werden, zum Beispiel:

• FP32 (32-Bit-Float)
• FP16 / BF16 (16-Bit-Float)
• FP8 (8-Bit-Float)
• INT8 (8-Bit-Integer)
• INT4 (4-Bit-Integer) bis hinunter zu binär (1 Bit).

Precision Scaling bedeutet also, überall dort weniger Bits zu verwenden, wo es möglich ist.

Das Ziel von Precision Scaling ist es, Rechenkosten zu senken. Weniger Bits bedeuten kleinere Zahlen, wodurch Matrixmultiplikationen schneller ausgeführt werden können.

Precision Scaling reduziert außerdem den Speicherbedarf, da niedrigere Präzision kleinere Tensoren erzeugt. Dadurch sinken sowohl der GPU-Speicherbedarf als auch die Anforderungen an die Speicherbandbreite.

Wie Deep Learning numerische Formate nutzt

Neuronale Netze bestehen aus:

• Gewichten
• Aktivierungen
• Gradienten
• Optimizer States
• KV Cache für Transformer

Diese Werte werden als Floating-Point-Zahlen oder Integer gespeichert. Traditionell war FP32 der Standard, doch heute zeigt die Entwicklung eher in folgende Richtung:

• Training → BF16 / FP16 / FP8
• Inferenz → INT8 / INT4 / sogar INT3

Verschiedene Teile eines Modells können unterschiedliche Präzisionen verwenden, abhängig von:

• Stabilität
• Hardware-Unterstützung
• Engpässen, etwa compute-bound oder memory-bound Workloads

Wie Precision Scaling die Energieeffizienz verbessert

Wie bereits erläutert, bedeutet Precision Scaling, die numerische Bitbreite während Training oder Inferenz zu reduzieren. Dadurch wird die Recheneffizienz moderner Deep-Learning-Workloads direkt verbessert und der Energieverbrauch gesenkt. Da große Modelle weiter wachsen, gehört die Reduzierung der Präzision zu den wirkungsvollsten Strategien, um sowohl CO₂-Fußabdruck als auch Betriebskosten zu verringern.

Reduzierter Rechenaufwand

Niedrigere Präzisionsformate wie FP16, BF16, FP8 oder INT8 verwenden weniger Bits pro Multiply-Accumulate-Operation (MAC). Dadurch sinkt der Arbeitsaufwand für die GPU-Recheneinheiten erheblich.

• Weniger Bits bedeuten weniger benötigte FLOPs pro Operation.
• Matrixmultiplikationen laufen schneller und verkürzen die Trainingszeit.
• Eine geringere arithmetische Komplexität kann außerdem die GPU-Auslastung verbessern.

Dadurch kann ein Trainingsschritt mit FP8 oder BF16 häufig deutlich schneller abgeschlossen werden als derselbe Schritt mit FP32, was den gesamten Trainingsdurchsatz verbessert.

Geringere Anforderungen an die Speicherbandbreite

Speicherzugriffe gehören zu den größten Energieverbrauchern moderner Beschleuniger. Tensoren mit niedrigerer Präzision reduzieren die Anzahl der Bytes, die zwischen GPU-Speicher und Rechenkernen bewegt werden müssen.

Beispiel:

• INT8-Tensoren benötigen 4× weniger Speicher als FP32-Tensoren.
• Niedrigere Präzision verringert Speichertransaktionen und Latenz.
• Bandwidth-bound Workloads wie Inferenz oder Long-Sequence-Decoding werden effizienter.

Diese reduzierte Datenbewegung senkt den Energieverbrauch direkt, insbesondere bei Systemen im großen Maßstab.

Höherer Durchsatz

Moderne Beschleuniger wie NVIDIA H100 und NVIDIA A100 können deutlich höhere Spitzenleistung erzielen, wenn Berechnungen mit niedriger Präzision ausgeführt werden.

• Tensor Cores liefern für FP16, FP8 und INT8 deutlich höhere TFLOPs als für FP32.
• Ein höherer Durchsatz bedeutet, dass jeder Trainingsschritt oder Inferenzlauf in weniger realer Zeit abgeschlossen wird und dadurch insgesamt weniger Energie benötigt.

Für Inferenz-Workloads bedeutet das:

• Schnellere Antworten
• Geringerer Energieverbrauch pro Anfrage
• Mehr Anfragen pro Watt

Reale Verringerung von CO₂-Emissionen

Da Rechenzeit eng mit Stromverbrauch verbunden ist, kann eine geringere Präzision einen spürbaren ökologischen Vorteil bringen.

• Kürzere Trainingszeiten bedeuten weniger GPU-Stunden und einen geringeren Gesamtenergieverbrauch.
• Große KI-Labore nutzen bereits Mixed-Precision- und Low-Precision-Training, um Betriebskosten und CO₂-Emissionen zu senken.

Unternehmen wie Meta, Google und OpenAI setzen in Produktionsumgebungen umfassend auf niedrigere Präzisionsformate wie BF16, FP8 und INT8, während neue Hardware den Wechsel zu noch geringeren Bitbreiten weiter beschleunigt.

Mixed Precision Training

Mixed Precision Training wurde eingeführt, um Deep Learning schneller und effizienter zu machen, ohne die Genauigkeit zu verringern. Als Modelle und Datensätze größer wurden, wurde vollständiges FP32-Training langsamer und speicherintensiver. Mixed Precision löst dieses Problem, indem für die meisten Operationen niedrigere Präzisionsformate wie FP16 genutzt werden. Dadurch sinkt der Speicherverbrauch und der mathematische Durchsatz steigt, während kritische Werte wie Gewichte und Akkumulationen in FP32 bleiben, um numerische Stabilität sicherzustellen.

Mit Verfahren wie Loss Scaling kann Mixed Precision dieselbe Genauigkeit wie FP32-Training erreichen und gleichzeitig deutlich höhere Geschwindigkeit sowie geringere Ressourcenanforderungen bieten. Damit eignet sich dieser Ansatz besonders für moderne KI-Workloads im großen Maßstab.

Mixed Precision Training ist ein Verfahren, bei dem Deep-Learning-Modelle FP16, also halbe Präzision, mit FP32, also einfacher Präzision, kombinieren. Ziel ist es, das Training schneller und speichereffizienter zu machen und gleichzeitig die numerische Stabilität des Modells zu erhalten. Die meisten rechenintensiven Operationen, etwa Forward und Backward Pass, laufen in FP16, da dieses Format schneller ist und weniger Speicher benötigt. Wichtige Werte wie Master Weights und Akkumulationen bleiben jedoch in FP32, um Präzisionsverluste zu vermeiden und ein korrektes Training sicherzustellen. Diese Kombination bietet die Geschwindigkeitsvorteile von FP16, ohne die Modellqualität zu beeinträchtigen.

Moderne Frameworks machen diesen Prozess einfacher. PyTorch AMP, also Automatic Mixed Precision, und die Mixed-Precision-API von TensorFlow bieten integrierte Unterstützung. Sie wählen automatisch aus, welche Operationen in FP16 laufen und welche in FP32 bleiben sollten. Dadurch wird schnelleres Training mit sehr wenig zusätzlichem Aufwand möglich.

Was ist Loss Scaling beim Mixed-Precision-Training?

Loss Scaling ist eine Technik im Mixed-Precision-Training, die verhindert, dass Gradienten zu klein werden, um in FP16 dargestellt zu werden. Da FP16 nur einen begrenzten dynamischen Wertebereich besitzt, können viele Gradientenwerte, insbesondere sehr kleine negative Werte, auf null gerundet werden. Das beeinträchtigt den Lernprozess. Um dies zu vermeiden, wird der Loss vor der Backpropagation mit einem konstanten Faktor multipliziert, also skaliert. Da die Backpropagation der Kettenregel folgt, werden alle Gradienten im gleichen Verhältnis vergrößert. Dadurch gelangen kleine Gradienten in einen Bereich, den FP16 darstellen kann, und verschwinden nicht. Nach der Backpropagation werden die Gradienten wieder entskaliert, bevor die FP32-Master-Gewichte aktualisiert werden. So bleibt die Größe des Updates korrekt.

Kurz gesagt:

• Loss skalieren → Gradienten werden größer → FP16 kann sie darstellen.
• Gradienten entskalieren → Update-Größe bleibt korrekt → Training bleibt stabil.

Der Skalierungsfaktor kann manuell oder automatisch durch Dynamic Scaling gewählt werden. Ist der Faktor zu groß, können Gradienten in NaN- oder Inf-Werte überlaufen. Frameworks erkennen dies und überspringen das Update für diese Iteration. Wenn Loss Scaling korrekt eingesetzt wird, verhindert es das Verschwinden kleiner Gradienten und ermöglicht FP16-Training mit einer Genauigkeit auf FP32-Niveau.

Quantisierung

Quantisierung ist eine Technik zur Modellkomprimierung, bei der die Präzision der Zahlen reduziert wird, mit denen Gewichte und Aktivierungen in einem neuronalen Netz gespeichert werden. Statt 32-Bit-Floating-Point-Werten nutzt das Modell Low-Bit-Integer-Formate wie INT8 oder INT4, bei denen jede Zahl deutlich weniger Bits benötigt.

Die Idee ist einfach: Neuronale Netze benötigen normalerweise nicht die volle 32-Bit-Präzision, um genaue Vorhersagen zu treffen. Daher können Zahlen komprimiert werden, indem sie auf einen kleineren Integer-Bereich zusammen mit einem Skalierungsfaktor abgebildet werden. Dadurch sinken Modellgröße, Speicherbedarf und Rechenkosten deutlich, ohne die Genauigkeit stark zu beeinträchtigen.

Quantisierung ist heute eine Standardtechnik, um große Modelle effizient auf Servern, Edge-Geräten und GPUs bereitzustellen.

Post-Training Quantization (PTQ) ist die einfachste Variante. Ein vollständig trainiertes Modell wird ohne erneutes Training in niedrigere Präzision konvertiert. PTQ ist schnell und einfach anzuwenden und benötigt meist nur einen kleinen Kalibrierungsdatensatz, um Aktivierungsbereiche abzuschätzen. Obwohl PTQ eine geringe Genauigkeitseinbuße verursachen kann, reduziert es den Speicherbedarf stark und beschleunigt die Inferenz. Deshalb wird es häufig als Standardansatz für Deployments genutzt.

Quantization-Aware Training (QAT) geht einen Schritt weiter, indem Quantisierungseffekte bereits während des Trainings simuliert werden. Das Modell lernt, unter Low-Precision-Bedingungen zu arbeiten, und passt seine Gewichte an, um Rundungsfehler auszugleichen. Da sich das Modell während des Trainings an INT8- oder INT4-Arithmetik anpasst, erreicht QAT in der Regel eine bessere Genauigkeit als PTQ, insbesondere bei sensiblen Aufgaben wie Objekterkennung oder generativer Modellierung. QAT benötigt anfangs mehr Rechenleistung, erzeugt dafür jedoch besonders optimierte quantisierte Modelle.

Einer der größten Vorteile der Quantisierung ist die starke Senkung des Energieverbrauchs. Integer-Operationen wie INT8 oder INT4 benötigen weniger Transistoren, weniger Speicherzugriffe und weniger Leistung als Floating-Point-Mathematik. Dadurch können quantisierte Modelle deutlich schneller laufen und wesentlich weniger Energie verbrauchen. Das ist besonders wichtig für mobile Geräte, IoT-Systeme und großskalige Inferenz-Workloads.

Moderne Werkzeuge erleichtern Quantisierung deutlich. Die Hugging Face Optimum Library bietet optimierte INT8- und INT4-Pipelines für Transformer und ermöglicht eine schnelle Konvertierung mit ONNX Runtime oder Intel Neural Compressor Backends. Quanto, ein leichtgewichtiges Quantisierungs-Backend für PyTorch, unterstützt schnelle Quantisierungsabläufe mit nativer PyTorch-Kompatibilität sowie dynamische, statische und integer-only Quantisierungsmodi. Zusammen vereinfachen diese Tools die Bereitstellung kleinerer, ressourcenschonenderer und schnellerer KI-Modelle.

Weitere Informationen zu Quantisierungstechniken sind in einem ausführlichen Blog im Ressourcenbereich verlinkt.

Vergleich der Energieeinsparungen nach Präzision

Praxisleitfaden: Precision Scaling implementieren

Kurze Checkliste für das Training

• AMP, also Automatic Mixed Precision, aktivieren, um sofort Geschwindigkeit und Speicherverbrauch zu verbessern.
• Framework-basiertes Mixed Precision wie FP16 oder BF16 nutzen, sofern unterstützt.
• Wenn verfügbar, FP8 oder Bibliotheken wie NVIDIA Transformer Engine testen, um zusätzliche Einsparungen zu erzielen.
• Die Modellstabilität mit Loss Scaling und Gradient Checks prüfen, wenn die Präzision gesenkt wird.

PyTorch: AMP mit FP16 oder BF16 aktivieren

# PyTorch: simple mixed-precision training loop with AMP
import torch
from torch import nn, optim
from torch.cuda.amp import autocast, GradScaler

model = nn.Sequential(nn.Linear(1024, 2048), nn.ReLU(), nn.Linear(2048, 1024)).cuda()
opt = optim.Adam(model.parameters(), lr=1e-3)
scaler = GradScaler()  # for stable FP16 training

for epoch in range(num_epochs):
    for x, y in dataloader:
        x, y = x.cuda(), y.cuda()
        opt.zero_grad()
        with autocast():              # forward in mixed precision
            pred = model(x)
            loss = ((pred - y) ** 2).mean()
        scaler.scale(loss).backward() # scale gradients
        scaler.step(opt)
        scaler.update()

Hinweise:

• autocast() für FP16 verwenden. Auf Plattformen, die BF16 unterstützen, sollte der entsprechende dtype gesetzt werden.
• Bei sehr großen Modellen sind Gradient Accumulation und sorgfältiges Loss Scaling sinnvoll.

PyTorch: Einstieg in FP8 und Low Precision

FP8 ist von der Hardware abhängig, zum Beispiel H100/Hopper. Wenn verfügbar, sollten Anbieterbibliotheken wie NVIDIA Transformer Engine oder eigene optimierte Kernel genutzt werden.

Typische Schritte sind die Installation des Anbieter-SDKs, das Ersetzen zentraler Operationen wie GEMM, MatMul oder LayerNorm durch FP8-beschleunigte Varianten des Anbieters sowie anschließende Plausibilitätsprüfungen.

Beispielhafter Ablauf:

# pseudocode
from transformer_engine import fp8_layer, cast_to_fp8
x_fp8 = cast_to_fp8(x)
out = fp8_layer(x_fp8, weight_fp8)

TensorFlow / Keras: Mixed Precision

import tensorflow as tf
from tensorflow import keras

# Enable policy globally (auto chooses BF16 on TPUs / supported GPUs)
tf.keras.mixed_precision.set_global_policy('mixed_float16')

model = keras.Sequential([
    keras.layers.Dense(2048, activation='relu', input_shape=(1024,)),
    keras.layers.Dense(1024)
])
model.compile(optimizer='adam', loss='mse')
model.fit(dataset, epochs=2)

Hinweise

• Keras übernimmt Loss Scaling automatisch, wenn mixed_float16 verwendet wird.
• Für BF16 auf unterstützten GPUs oder geeigneten Beschleunigern kann mixed_bfloat16 eine Option sein.

Kurze Checkliste für die Inferenz

• Mit Post-Training Quantization, etwa INT8 oder INT4, beginnen, da dies der schnellste Weg zu geringerem Speicherbedarf ist.
• Wenn PTQ die Genauigkeit zu stark reduziert, Quantization-Aware Training verwenden, um die Gewichte anzupassen.
• Nach ONNX exportieren und anschließend mit TensorRT oder ONNX Runtime für maximalen Durchsatz optimieren.
• Vor einer breiten Bereitstellung die Abwägung zwischen Genauigkeit, Energieverbrauch und Latenz messen.

PyTorch zu ONNX zu TensorRT exportieren

import torch

# assume `model` on CPU / eval mode
model.eval()
dummy = torch.randn(1, 1024)
torch.onnx.export(model.cpu(), dummy, "model.onnx",
                  input_names=["input"], output_names=["output"],
                  opset_version=17, do_constant_folding=True)

ONNX Runtime: Ein ONNX-Modell dynamisch oder statisch quantisieren

from onnxruntime.quantization import quantize_dynamic, QuantType

quantize_dynamic("model.onnx", "model_int8.onnx", weight_type=QuantType.QInt8)

Laden und ausführen:

import onnxruntime as ort
sess = ort.InferenceSession("model_int8.onnx", providers=['CUDAExecutionProvider'])
out = sess.run(None, {'input': dummy_np})

TensorFlow Lite für Mobile- und Edge-INT8

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
# (optionally supply representative dataset for full-int8)
tflite_model = converter.convert()
open("model.tflite","wb").write(tflite_model)

FAQs

Was ist FP32 und warum wird es im Deep Learning verwendet?

FP32, also 32-Bit-Floating-Point-Präzision, ist ein Standardformat, das in vielen Deep-Learning-Modellen genutzt wird. Aufgrund seiner hohen numerischen Stabilität eignet es sich gut für das Training komplexer Netzwerke wie Transformer und CNNs. FP32 kann sehr kleine Dezimalunterschiede darstellen, unterstützt dadurch stabile Gradientenupdates und hilft, ein Auseinanderlaufen des Trainings zu vermeiden. Allerdings benötigt FP32 viel Speicher und Rechenleistung, was es energieintensiv macht. Deshalb gewinnen Formate mit geringerer Präzision zunehmend an Bedeutung.

Was bedeutet „CO₂-Fußabdruck“ bei KI-Workloads?

Der CO₂-Fußabdruck beschreibt die gesamten Treibhausgasemissionen, die durch den Stromverbrauch beim Training und Betrieb von Machine-Learning-Modellen entstehen. Große Modelle können sehr viel Energie verbrauchen, insbesondere wenn GPUs über lange Trainingszyklen hinweg hochpräzise Berechnungen ausführen. Diese Energie stammt häufig aus nicht erneuerbaren Quellen und trägt dadurch zu globalen Emissionen bei. Eine geringere Präzision, optimierte Rechenprozesse und effizientere Hardware können den CO₂-Fußabdruck von KI-Systemen deutlich senken.

Was ist Mixed Precision Training?

Mixed Precision Training kombiniert mehrere numerische Formate – typischerweise FP16 und FP32 –, um sowohl die Trainingsleistung als auch die numerische Stabilität zu verbessern. Die meisten Berechnungen werden in FP16 ausgeführt, wodurch der Speicherverbrauch sinkt und die Ausführung auf modernen GPUs beschleunigt wird. FP32 wird hingegen für Operationen verwendet, die eine höhere Präzision erfordern, etwa Gradientenakkumulation, Loss Scaling und Optimizer-Updates.

Frameworks wie PyTorch Automatic Mixed Precision (AMP) und die Mixed-Precision-API von TensorFlow automatisieren diesen Prozess. Dadurch können Entwickler mit minimalen Codeänderungen von schnellerem Training profitieren und gleichzeitig die Modellgenauigkeit beibehalten. Mixed Precision Training hat sich daher zu einer Standardoptimierung entwickelt, um die Effizienz zu steigern, ohne die Modellleistung zu beeinträchtigen.

Welche Arten von Precision-Scaling-Techniken gibt es?

Precision Scaling bedeutet, numerische Formate anzupassen, um Berechnungen effizienter zu machen. Zu den gängigen Methoden gehören Mixed Precision, etwa FP16 zusammen mit FP32 zur Trainingsbeschleunigung, reduzierte Präzision bei der Inferenz mit Formaten wie FP8, INT8 oder INT4 sowie Quantisierung, bei der Modelle durch geringere Präzision von Gewichten und Aktivierungen komprimiert werden. Jede Methode bietet eigene Kompromisse zwischen Geschwindigkeit, Genauigkeit und Energieverbrauch. Zusammen bilden sie ein zentrales Werkzeugset für energieeffizientes Deep Learning.

Wie reduziert geringere Präzision den Energieverbrauch?

Formate mit geringerer Präzision verwenden weniger Bits zum Speichern von Zahlen. Dadurch muss während der Berechnung weniger Speicher übertragen werden, und Datenbewegung gehört zu den größten Energieverbrauchern. Integer-Operationen wie INT8 oder INT4 benötigen außerdem weniger Leistung als Floating-Point-Mathematik, weil sie einfachere Schaltungen und weniger Rechenschritte verwenden. Das führt zu schnellerer Inferenz, kleineren Modellen und deutlich geringerem Energiebedarf der Hardware. In großem Maßstab kann reduzierte Präzision die Umweltwirkung von KI-Workloads erheblich verringern.

Was ist Quantisierung und wie unterscheidet sie sich von Mixed Precision?

Quantisierung wandelt Modellgewichte und Aktivierungen von Gleitkommaformaten in niedrigpräzise Integer-Formate wie INT8 oder INT4 um. Anders als Mixed Precision, das weiterhin auf Gleitkommaberechnungen basiert, verlagert Quantisierung viele Operationen auf Integer-Arithmetik und erreicht dadurch eine deutlich höhere Effizienz.

Sie kann nach dem Training durch Post-Training Quantization (PTQ) angewendet oder während des Trainings über Quantization-Aware Training (QAT) integriert werden, um die Genauigkeit besser zu erhalten. Da quantisierte Modelle weniger Speicher benötigen und weniger Energie verbrauchen, ist Quantisierung besonders wertvoll für Edge-Deployments, großskalige Inferenz und energieeffiziente KI-Systeme.

Beeinflusst Precision Scaling die Modellgenauigkeit?

Precision Scaling kann Rundungsfehler verursachen und numerische Details reduzieren. Dadurch kann die Genauigkeit leicht sinken, insbesondere bei kleineren Modellen oder sensiblen Aufgaben. Moderne Methoden wie Loss Scaling, Quantization-Aware Training und FP8-Training verringern diese Probleme jedoch deutlich. In vielen Fällen bleibt die Genauigkeit nahezu gleich, während nur ein Bruchteil der Rechenleistung benötigt wird. Der kleine Genauigkeitskompromiss wird häufig durch große Vorteile bei Geschwindigkeit, Kosten und Umweltwirkung aufgewogen.

Kann Precision Scaling mit jeder Modellarchitektur verwendet werden?

Die meisten modernen Deep-Learning-Architekturen – darunter Transformer, CNNs, RNNs und Diffusionsmodelle – unterstützen sowohl Mixed Precision als auch Quantisierung. Gängige Deep-Learning-Frameworks und moderne Hardwarebeschleuniger bieten integrierte Unterstützung für diese Optimierungstechniken, sodass sie sich relativ einfach in Produktions- und Forschungsworkflows einsetzen lassen.

Bestimmte ältere Architekturen, benutzerdefinierte Layer oder spezialisierte Operationen können jedoch zusätzliche Feinabstimmung erfordern, um numerische Stabilität und Modellgenauigkeit zu erhalten. Mit den passenden Tools und sorgfältiger Validierung können die meisten weit verbreiteten Deep-Learning-Modelle von Precision Scaling profitieren – durch schnellere Ausführung, geringeren Speicherverbrauch und insgesamt höhere Effizienz.

Fazit

Precision Scaling wird zu einer der wirkungsvollsten Strategien, um Modellkomplexität, Energieverbrauch und Rechenkosten im Deep Learning zu reduzieren. Durch den Wechsel von voller FP32-Präzision zu leichteren Formaten wie FP16, FP8, INT8 oder INT4 können Entwickler sowohl Training als auch Inferenz effizienter gestalten und gleichzeitig die Umweltbelastung moderner KI-Workloads senken. Die Grundidee ist einfach, aber wirkungsvoll: schnellere Modelle, geringere Kosten und ein nachhaltigerer Ansatz zur Skalierung von KI.

Allerdings bringt Precision Scaling auch Kompromisse mit sich. Sehr niedrigpräzise Formate können die Modellgenauigkeit beeinflussen, die Unterstützung durch Frameworks kann variieren, und manche Hardwareplattformen sind bei fortgeschrittenen Quantisierungstechniken weiterhin eingeschränkt. In präzisionssensiblen Bereichen wie dem wissenschaftlichen Rechnen kann daher weiterhin eine höhere numerische Stabilität erforderlich sein. Trotz dieser Einschränkungen bleibt Precision Scaling eine äußerst wertvolle Methode, um KI-Systeme effizient, skalierbar und stärker auf langfristige Nachhaltigkeitsziele auszurichten.