ReLU (Rectified Linear Unit)

Die gleichgerichtete lineare Einheit (ReLU) ist die Aktivierungsfunktion f(x) = max(0, x): Positive Eingaben gibt sie unverändert weiter, für alles andere gibt sie null aus. Dieser einzelne Vergleich verleiht einem neuronalen Netz (NN) die nichtlineare Funktionalität, die es zum Lernen gekrümmter Muster braucht – bei minimalem Rechenaufwand. ReLU wurde zur Standardaktivierung verborgener Schichten im Deep Learning, nachdem Vinod Nair und Geoffrey Hinton sie 2010 eingesetzt hatten und AlexNet, ein auf ReLUs basierendes Faltungsneuronales Netz (CNN), die ImageNet-Herausforderung 2012 gewann. Sie bleibt die Vergleichsbasis für neuere Aktivierungsfunktionen wie SiLU und GELU.

So funktioniert ReLU#

Die Ableitung von ReLU beträgt bei positiven Eingaben 1 und bei negativen Eingaben 0. Bei genau null ist die Ableitung nicht definiert; Frameworks wie PyTorch verwenden den Wert 0. Diese beiden Werte erklären die wichtigsten Eigenschaften von ReLU:

• Geringer Rechenaufwand: Der Vorwärtsdurchlauf vergleicht mit null, der Rückwärtsdurchlauf verwendet eine Maske. Es sind keine Exponentialfunktionen wie bei Sigmoid oder tanh nötig.
• Keine Sättigung bei positiven Eingaben: Ein Gradient von genau 1 wird durch jede aktive Einheit unverändert weitergegeben. Fehlersignale werden daher nicht kleiner, während sie rückwärts durch viele Schichten laufen. Das wirkt dem Problem des verschwindenden Gradienten entgegen, das durch sättigende Funktionen entsteht.
• Dünn besetzte Aktivierungen: Jede negative Eingabe wird zu genau null, sodass zu jedem Zeitpunkt nur ein Teil einer Schicht aktiv ist. Bei zufällig initialisierten Gewichten geben für eine bestimmte Eingabe etwa die Hälfte der Einheiten einer Schicht null aus.
• Stückweise linear: Ein aus ReLUs aufgebautes Netz berechnet eine stückweise lineare Funktion seiner Eingabe mit vielen linearen Bereichen, die an den Stellen zusammenstoßen, an denen sich Einheiten ein- oder ausschalten.

Das folgende PyTorch-Beispiel wendet nn.ReLU an und verwendet Autograd, um den Gradienten an denselben Punkten zu berechnen:

import torch
from torch import nn

relu = nn.ReLU()

# Inputs on both sides of zero, tracked so PyTorch can compute gradients
x = torch.tensor([-2.0, -0.5, 0.0, 0.5, 2.0], requires_grad=True)
y = relu(x)

# Backpropagate a gradient of 1 from each output to its input
y.sum().backward()

print(f"Output:   {y.tolist()}")
print(f"Gradient: {x.grad.tolist()}")

Es gibt die Ausgaben [0.0, 0.0, 0.0, 0.5, 2.0] und die Gradienten [0.0, 0.0, 0.0, 1.0, 1.0] aus. Positive Eingaben werden mit unverändertem Gradienten weitergegeben. Für negative Eingaben und null wird kein Gradient berechnet – das ist sowohl die Ursache für die dünn besetzten Aktivierungen von ReLU als auch für ihren wichtigsten Nachteil.

Das Problem der sterbenden ReLU#

Eine ReLU-Einheit, deren Eingabe für alle Beispiele in den Trainingsdaten negativ ist, gibt null aus und erhält keinen Gradienten. Ihre Gewichte ändern sich daher nie wieder und die Einheit ist praktisch tot. Einheiten sterben meist, wenn eine große Gewichtsaktualisierung, oft aufgrund einer hohen Lernrate, ihren Bias stark ins Negative verschiebt. Einige tote Einheiten sind kaum problematisch, doch ein schlecht abgestimmter Trainingslauf kann einen großen Teil einer Schicht lahmlegen. Die He-Initialisierung, bei der Anfangsgewichte für ReLU-Schichten skaliert werden, hält zusammen mit moderaten Lernraten und Batch-Normalisierung die meisten Einheiten aktiv. Varianten mit negativer Steigung vermeiden das Problem, indem sie den Gradienten nie auf null sinken lassen.

ReLU-Varianten#

• Leaky ReLU: Multipliziert negative Eingaben mit einer kleinen, festen Steigung, üblicherweise 0,01, damit inaktive Einheiten weiterhin einen Gradienten erhalten.
• PReLU: Lernt die negative Steigung während des Trainings. Kaiming He und seine Kolleginnen und Kollegen führten die Funktion 2015 in derselben Arbeit ein, in der sie auch die He-Initialisierung vorschlugen.
• ReLU6: Begrenzt die Ausgabe auf 6, min(max(0, x), 6), sodass Aktivierungen in einem Bereich bleiben, den Berechnungen mit geringer Genauigkeit gut darstellen können. MobileNetV1 und MobileNetV2 verwenden diese Funktion.
• ELU: Ersetzt den negativen Bereich durch eine glatte Exponentialkurve, die bei −1 sättigt, und verschiebt so die mittleren Aktivierungen näher an null.
• SiLU und GELU: Glatte Kurven, x · σ(x) und x · Φ(x), die sich bei großen Eingaben wie ReLU verhalten, aber kleine negative Werte durchlassen und bei null keinen Knick haben. Sie benötigen pro Element mehr Rechenaufwand. Die GELU-Arbeit berichtete für jede getestete Aufgabe aus Bildverarbeitung, Sprache und Spracherkennung bessere Ergebnisse als mit ReLU.

ReLU im Vergleich zu Sigmoid und tanh#

Vor ReLU wurden in verborgenen Schichten Sigmoid oder tanh verwendet. Beide Funktionen sättigen: Bei großen positiven oder negativen Eingaben flachen ihre Kurven ab und ihre Ableitungen nähern sich null. Die Ableitung von Sigmoid überschreitet selbst am steilsten Punkt nie 0,25. Werden solche Ableitungen über viele Schichten hinweg multipliziert, erhalten frühe Schichten kaum noch Gradienten. Im AlexNet-Paper erreichte ein vier Schichten tiefes CNN mit ReLUs den Trainingsfehler von 25 % auf CIFAR-10 sechsmal schneller als dasselbe Netz mit tanh-Einheiten. Sigmoid und tanh bleiben dort nützlich, wo ihre begrenzten Wertebereiche wichtig sind: Sigmoid in Ausgabeschichten für Wahrscheinlichkeiten und in den Gattern rekurrenter Zellen, tanh in verborgenen rekurrenten Zuständen.

ReLU in modernen Modellen#

ResNet und die meisten CNNs aus seiner Zeit verwenden durchgehend ReLU. Auch der ursprüngliche Transformer von 2017 setzte sie in seinen Feedforward-Schichten ein. Viele neuere Modelle sind zu glatteren Funktionen gewechselt: zu GELU in BERT und Vision Transformern sowie zu SwiGLU in vielen aktuellen großen Sprachmodellen. ReLU ist weiterhin verbreitet, wenn Geschwindigkeit und Hardwareunterstützung besonders wichtig sind. YOLO26 verwendet standardmäßig SiLU in seinen Conv-Blöcken. Eine Zeile mit activation: nn.ReLU() in der Modell-YAML-Datei ersetzt ReLU vor dem Training in jedem Conv-Block durch SiLU. Das eignet sich für Beschleuniger wie die AMD Zynq UltraScale+ DPU, die ReLU nativ, SiLU jedoch nicht ausführen. In PyTorch überschreibt nn.ReLU(inplace=True) den Eingabetensor mit dem Ergebnis und spart so den Speicher für einen separaten Ausgabetensor.