Im Jahr 2017 veröffentlichte ein Team bei Google ein Paper mit einem gewagten Titel: „Attention Is All You Need.“ Das war nicht nur akademische Prahlerei. Die vorgestellte Transformer-Architektur veränderte grundlegend, wie wir KI-Systeme bauen. Heute basiert jedes große Sprachmodell von GPT über Claude bis Gemini auf diesem Fundament. Wenn Sie ein modernes KI-Tool nutzen, haben Sie bereits mit einem Transformer interagiert.

Als Software Engineer haben Sie vielleicht gehört, dass Transformers „nur aus Matrixmultiplikationen“ bestehen oder dass sie „Aufmerksamkeitsmechanismen verwenden“. Diese Beschreibungen sind zwar technisch korrekt, verfehlen aber die elegante mathematische Argumentation, die Transformers funktionieren lässt. Dieser Artikel nimmt Sie mit auf eine Reise zu den Problemen, die Transformers motivierten, bis zu den hochmodernen Optimierungen in Produktionssystemen. Am Ende verstehen Sie nicht nur, was die Mathematik hinter Transformers bedeutet, sondern warum sie genau so sein muss. Damit erlangen Sie das Wissen, um einen Transformer von Grund auf zu implementieren.

Wir folgen einem roten Faden: Wie bauen wir ein System, das Beziehungen zwischen Elementen in einer Sequenz verstehen kann, unabhängig davon, wie weit diese Elemente auseinanderliegen, und dies effizient genug, um auf Milliarden von Beispielen zu trainieren? Jede Formel, jede architektonische Entscheidung resultiert aus der Beantwortung dieser Frage.

Das Problem: Warum Recurrent Networks uns im Stich ließen

Vor Transformers dominierte der Ansatz der Recurrent Neural Networks (RNN) die Sequenzverarbeitung. Um zu verstehen, warum Transformers existieren, müssen wir verstehen, warum wir RNNs trotz ihrer Eleganz nicht auf die Probleme skalieren können, die wir lösen wollen.

Stellen Sie sich vor, Sie bauen ein Übersetzungssystem. Sie erhalten den englischen Satz „The cat sat on the mat“ und müssen die französische Übersetzung produzieren. Ein RNN verarbeitet dies sequenziell. Es liest „The“, aktualisiert seinen internen Zustand, liest dann „cat“, aktualisiert seinen Zustand erneut, und so weiter. Die Idee: Wenn das Übersetzungssystem den Satz zu Ende gelesen hat, enthält sein versteckter Zustand eine komprimierte Repräsentation von allem, was es gesehen hat.

So aktualisiert ein RNN seinen versteckten Zustand bei jedem Zeitschritt:

h_t = tanh(W_hh * h_{t-1} + W_xh * x_t + b_h)

In dieser Formel repräsentiert h_t den versteckten Zustand zum Zeitpunkt t, x_t ist die Eingabe zum Zeitpunkt t, W_hh ist eine Gewichtsmatrix, die den vorherigen versteckten Zustand transformiert, W_xh transformiert die aktuelle Eingabe, und b_h ist ein Bias-Term. Die tanh-Funktion beschränkt das Ergebnis, um die Werte begrenzt zu halten.

Das Problem zeigt sich, wenn Sie das Ganze aus der Perspektive vieler Zeitschritte betrachten. Angenommen, Sie übersetzen ein langes Dokument, und eine kritische Information erscheint im ersten Satz, aber Sie benötigen diese Information, um den hundertsten Satz korrekt zu übersetzen. Diese Information muss somit eine hundertfache Multiplikation mit W_HH überleben.

In der Praxis führt dies zu zwei katastrophalen Problemen:

Erstens das Problem verschwindender Gradienten. Beim Training neuronaler Netzwerke berechnen wir Gradienten, die uns sagen, wie wir Gewichte anpassen sollen. Diese Gradienten müssen rückwärts durch die Zeit fließen. Wenn der Gradient bei Schritt 100 die Gewichte beeinflussen muss, die wir im Schritt 1 verarbeitet haben, muss er hundertmal mit der Ableitung der tanh-Funktion multipliziert werden. Da die Ableitung von tanh immer kleiner als eins ist, schrumpft der Gradient exponentiell. Wenn er die frühen Schritte erreicht, bleibt er im Wesentlichen bei null und die Gewichte somit unverändert, ohne dazuzulernen.

Zweitens gibt es, selbst wenn wir verschwindende Gradienten mit Techniken wie LSTMs oder GRUs lösen, ein fundamentaleres Problem: Sequenzielle Verarbeitung ist langsam. Moderne GPUs zeichnen sich durch parallele Berechnung aus. Sie können massive Matrizen unglaublich schnell multiplizieren. Aber RNNs zwingen uns, Sequenzen Schritt für Schritt zu verarbeiten, weil jeder Schritt vom vorherigen abhängt. Sie können h_100 nicht berechnen, bis Sie h_99 berechnet haben, was h_98 erfordert, und so weiter, bis wir schlussendlich h_1 erreichen. Diese sequenzielle Abhängigkeit macht das Training auf den massiven Datensätzen, die wir für moderne KI benötigen, unerträglich langsam.

Die Transformer-Architektur löst beide Probleme mit einer radikalen Idee: Was, wenn wir alle Positionen in der Sequenz gleichzeitig betrachten und das Modell lernen lassen könnten, welche Positionen füreinander relevant sind? Hier kommt Attention ins Spiel.

Die Kernidee: Attention als differenzierbare Lookup-Tabelle

Bevor wir in mathematische Formeln eintauchen, bauen wir Intuition darüber auf, was Attention tatsächlich macht. Stellen Sie sich vor, Sie lesen diesen Satz: „Die Trophäe passte nicht in die Truhe, weil sie zu groß war.“ Worauf bezieht sich „sie“? Ihr Gehirn verarbeitet dies nicht Wort für Wort unter Beibehaltung eines versteckten Zustands. Stattdessen schauen Sie, wenn Sie auf „sie“ stoßen, durch den Satz zurück, finden relevanten Kontext (Trophäe und Truhe) und bestimmen, was angesichts von „zu groß“ sinnvoll ist.

Aufmerksamkeitsmechanismen formalisieren diesen intuitiven Prozess. Im Kern ist Attention ein differenzierbarer Nachschlagemechanismus (Lookup-Mechanismus). In einer traditionellen Lookup-Tabelle oder Hash-Map geben Sie einen Schlüssel an und erhalten einen Wert zurück. Attention macht etwas Ähnliches, aber mit einem entscheidenden Unterschied: Statt exakter Übereinstimmungen berechnet es einen gewichteten Durchschnitt aller Werte, wobei die Gewichte davon abhängen, wie gut jeder Schlüssel zu Ihrer Abfrage passt.

Konkretisieren wir dies mit einem einfachen Beispiel. Angenommen, Sie haben drei Wörter in einem Satz, und jedes Wort repräsentiert sich als Vektor. Sie möchten eine neue Repräsentation für das zweite Wort berechnen, die Informationen von den anderen Wörtern basierend auf ihrer Relevanz einbezieht.

# Einfaches Beispiel mit drei Wortvektoren

wort1 = [1.0, 0.0] # "Die"

wort2 = [0.5, 0.5] # "Katze"

wort3 = [0.0, 1.0] # "saß"

Um nun eine attention-erweiterte Repräsentation für wort2 zu berechnen, müssen wir beantworten: Wie relevant ist jedes andere Wort im Textfragment für wort2? Wir könnten diese Relevanz als Skalarprodukt berechnen, das Ähnlichkeit misst:

relevanz_1_zu_2 = skalarprodukt(wort1, wort2) = 1.0 * 0.5 + 0.0 * 0.5 = 0.5

relevanz_2_zu_2 = skalarprodukt(wort2, wort2) = 0.5 * 0.5 + 0.5 * 0.5 = 0.5

relevanz_3_zu_2 = skalarprodukt(wort3, wort2) = 0.0 * 0.5 + 1.0 * 0.5 = 0.5

Diese rohen Relevanzwerte sind nicht sehr nützlich, weil sie sich nicht zu eins summieren lassen. Wir wollen Gewichte, die wir für einen gewichteten Durchschnitt nutzen können. Hier kommt die Softmax-Funktion ins Spiel. Softmax konvertiert beliebige Werte in eine Wahrscheinlichkeitsverteilung:

def softmax(werte):

exp_werte = [exp(w) for w in werte]

summe_exp = sum(exp_werte)

return [e / summe_exp for e in exp_werte]

Die Softmax-Funktion besitzt eine schöne Eigenschaft: Sie ist differenzierbar, sodass wir sie mit Backpropagation trainieren können, und sie produziert immer Ausgaben, die zu eins summieren und allesamt positive Werte besitzen. Die Exponentialfunktion stellt sicher, dass größere Werte exponentiell mehr Gewicht erhalten, was einen weichen Auswahlmechanismus schafft.

Wenden wir Softmax auf unsere Relevanzwerte an, …

gewichte = softmax([0.5, 0.5, 0.5]) = [0.33, 0.33, 0.33]

…, können wir die Attention-erweiterte Repräsentation als gewichtete Summe berechnen:

erweitertes_wort2 = 0.33 * wort1 + 0.33 * wort2 + 0.33 * wort3

= 0.33 * [1.0, 0.0] + 0.33 * [0.5, 0.5] + 0.33 * [0.0, 1.0]

= [0.495, 0.495]

Dies ist die Essenz von Attention: Wir berechnen, wie relevant jede Position für die aktuelle Position ist, normalisieren diese Relevanzen zu Gewichten und nehmen einen gewichteten Durchschnitt. Das Genie der Transformer liegt darin, diesen Prozess lernbar und effizient zu machen.

Scaled Dot-Product Attention: Das mathematische Fundament

Jetzt sind wir bereit, die tatsächliche Attention-Formel abzuleiten, die Transformers nutzen. Wir bauen sie Schritt für Schritt auf und bekommen Einblick, warum jede Komponente existiert.

Unser Ziel: Einen Mechanismus schaffen, bei dem wir für jede Position in einer Sequenz eine Repräsentation berechnen können, die Informationen von allen anderen Positionen basierend auf gelernter Relevanz einbezieht. Wir benötigen drei Dinge:

1. eine Möglichkeit auszudrücken, „wonach ich suche“ und das an jeder Position. Wir nennen dies die Query (Q). Denken Sie zum Beispiel an eine Suchanfrage in einer Datenbank.
2. eine Möglichkeit auszudrücken, „was ich anzubieten habe“ an jeder Position. Wir nennen dies den Key (K). Denken Sie an den Index in einer Datenbank, gegen den wir abgleichen.
3. die tatsächliche Information, die wir abrufen möchten. Wir nennen dies den Value (V). Denken Sie an die in der Datenbank gespeicherten Daten.

Warum Keys und Values trennen? Weil das, was wir zur Bestimmung der Relevanz verwenden (der Key), sich von dem unterscheiden kann, was wir tatsächlich abrufen möchten (der Value). Zum Beispiel könnte beim Übersetzen von „Die Katze saß“ das Wort „Katze“ relevant sein, weil es ein Substantiv ist (das erfasst der Key), aber was wir tatsächlich abrufen möchten, ist seine volle semantische Bedeutung (das erfasst der Value).

Wir erzeugen Q, K und V, indem wir unsere Eingabe mit gelernten Gewichtsmatrizen multiplizieren:

Q = X * W_Q

K = X * W_K

V = X * W_V

Hier ist X unsere Eingabematrix, wobei jede Zeile ein Wort-Embedding ist, und W_Q, W_K, W_V lernbare Gewichtsmatrizen. Diese Matrizen lernen während des Trainings, die richtige Art von Informationen für Queries, Keys und Values zu extrahieren.

Um nun Attention zu berechnen, müssen wir messen, wie gut jede Query zu jedem Key passt. Die natürliche Wahl ist das Skalarprodukt, weil es Ähnlichkeit misst: Wenn zwei Vektoren in die gleiche Richtung zeigen, ist ihr Skalarprodukt groß; wenn sie orthogonal sind, ist es Null; wenn sie in entgegengesetzte Richtungen zeigen, ist es negativ.

Wir berechnen alle Query-Key-Ähnlichkeiten auf einmal, indem wir Q und K transponiert multiplizieren:

scores = Q * K^T

Dies gibt uns eine Matrix, bei der Eintrag (i,j) beschreibt, wie intensiv Position i (die Query) auf Position j (den Key) achten sollte. Die Dimensionen ergeben sich daraus wie folgt: Wenn wir n Positionen betrachten und jede Query/jeder Key d-dimensional ist, dann erhalten wir eine Matrix Q mit der Größe n mal d, K^T mit der Größe d mal n, und ihr Produkt mit der Größe n mal n.

Hier stoßen wir auf unser erstes Problem. Erhöht sich die Dimension d wachsen die Skalarprodukte ebenfalls. Um zu sehen, warum, bedenken Sie, dass ein Skalarprodukt eine Summe von d Termen ist. Wenn jeder Term die Varianz sigma zum Quadrat hat, hat die Summe die Varianz d mal sigma zum Quadrat aufgrund der Eigenschaften der Varianz. Dies bedeutet, das Skalarprodukt wächst mit der Quadratwurzel von d.

Warum ist dies ein Problem? Weil wir Softmax auf diese Werte anwenden. Softmax mit sehr großen Eingaben führt allerdings zu extrem „spitzen Werten“. Um dies zu sehen, betrachten Sie:

softmax([10, 9, 8]) = [0.665, 0.245, 0.090]

softmax([100, 90, 80]) = [0.9999, 0.0001, 0.0000]

Wenn die Eingaben für Softmax riesengroß sind, ergibt sich im Wesentlichen eine harte Auswahl, die nur den größten Wert auswählt und alles andere ignoriert. Dies löscht Gradienten während des Trainings aus, weil die Ableitung von Softmax fast überall Null erreicht, außer am Maximum.

Die Lösung besteht darin, die Skalarprodukte durch die Quadratwurzel der Dimension zu skalieren:

skalierte_scores = (Q * K^T) / sqrt(d_k)

Diese Skalierung stellt sicher, dass unabhängig von der Dimension die Varianz der Werte ungefähr konstant bleibt. Die Quadratwurzel wirkt speziell dem Quadratwurzelwachstum entgegen, das wir früher identifiziert haben.

Jetzt wenden wir Softmax an, um Attention-Gewichte zu erhalten:

attention_gewichte = softmax(skalierte_scores)

Schließlich verwenden wir diese Gewichte, um einen gewichteten Durchschnitt der Values zu berechnen:

ausgabe = attention_gewichte * V

Alles zusammengesetzt erhalten wir die Scaled Dot-Product Attention-Formel:

Attention(Q, K, V) = softmax((Q * K^T) / sqrt(d_k)) * V

Implementieren wir das in Code, um es zu veranschaulichen:

import numpy as np

def scaled_dot_product_attention(Q, K, V):
    """
    Berechnet Scaled Dot-Product Attention.
    
    Args:
        Q: Query-Matrix der Form (n, d_k), wobei n die Sequenzlänge ist
        K: Key-Matrix der Form (n, d_k)
        V: Value-Matrix der Form (n, d_v)
        
    Returns:
        ausgabe: Attention-Ausgabe der Form (n, d_v)
        attention_gewichte: Attention-Gewichtsmatrix der Form (n, n)
    """
    # Holt die Dimension der Keys für die Skalierung
    d_k = Q.shape[-1]
    
    # Berechnet Attention-Scores durch Skalarprodukt von Queries und Keys
    # Form: (n, d_k) @ (d_k, n) = (n, n)
    scores = np.matmul(Q, K.transpose(-2, -1))
    
    # Skaliert Scores durch Quadratwurzel der Key-Dimension
    # Dies verhindert, dass Softmax zu spitz wird
    skalierte_scores = scores / np.sqrt(d_k)
    
    # Wendet Softmax an, um Attention-Gewichte zu erhalten
    # Jede Zeile summiert zu 1, repräsentiert eine Wahrscheinlichkeitsverteilung
    attention_gewichte = softmax(skalierte_scores)
    
    # Berechnet gewichtete Summe der Values
    # Form: (n, n) @ (n, d_v) = (n, d_v)
    ausgabe = np.matmul(attention_gewichte, V)
    
    return ausgabe, attention_gewichte

def softmax(x):
    """
    Berechnet Softmax-Werte für jede Zeile der Matrix x.
    Numerisch stabile Implementierung, die den Maximalwert subtrahiert.
    """
    # Subtrahiert Maximum für numerische Stabilität
    # Dies verhindert Overflow durch exp von großen Zahlen
    exp_x = np.exp(x - np.max(x, axis=-1, keepdims=True))
    return exp_x / np.sum(exp_x, axis=-1, keepdims=True)

Dies ist der Kern des Transformers. Alles andere baut auf diesem Fundament auf. Beachten Sie, wie die Formel aus ersten Prinzipien entstand: Wir wollten einen differenzierbaren Lookup-Mechanismus, wir wählten Skalarprodukte für Ähnlichkeit, wir skalierten, um Sättigung zu verhindern, und wir verwendeten Softmax, um normalisierte Gewichte zu erhalten.

Deno Deploy ist nun allgemein verfügbar, nachdem im Juni 2021 die erste Beta-Version erschienen war. Die Serverless-Plattform dient dazu, JavaScript- und TypeScript-Anwendungen ins Web zu deployen. Sie kann mit beliebten Webframeworks wie Next.js umgehen und nutzt den Node.js-Konkurrenten Deno als Runtime.

Framework-Support für Next.js, Nuxt & Co.

Wie das Deno-Team in der Ankündigung hervorhebt, soll Deno Deploy das Deployment einer Webanwendung so einfach machen, als würde diese lokal laufen. Es sind weder Adapter oder Build-Konfigurationen noch anbieterspezifische Konfigurationsdateien nötig, denn Deno Deploy lässt sich mit gängigen JavaScript- und TypeScript-Frameworks out-of-the-box nutzen. Diese sind laut der Dokumentation Next.js, Astro, Nuxt, SolidStart, SvelteKit, Fresh, Lume und – noch experimentell – Remix.

Das Deno-Team weist darauf hin, dass auch andere Frameworks mit Deno Deploy funktionieren können, jedoch eine weitergehende Konfiguration erfordern. Entwicklerinnen und Entwickler können Frameworks via Discord-Channel oder per Mail an den Deno-Support vorschlagen.

Continuous Delivery mit Deno Deploy

Das Verbinden eines GitHub-Repos mit Deno Deploy soll Continuous Delivery ohne weitere Konfiguration ermöglichen. Entwicklerinnen und Entwickler erhalten eine Live-Vorschau für jeden Commit, und jeder Pull Request wird als „Timeline“ getrackt. Via User Interface lassen sich Änderungen in Produktion geben oder rückgängig machen.

Als neuer Service von Deno Deploy steht die Deno Sandbox bereit. Mit ihr lassen sich Linux-microVMs – leichtgewichtige virtuelle Maschinen – verwenden, die in der Deno-Deploy-Cloud laufen, um Code sicher auszuführen. Der Hintergrund besteht darin, dass Deno-Deploy-Kunden zunehmend Plattformen entwickeln, auf denen User mithilfe von Large Language Models (LLMs) Code erzeugen, der unverzüglich und ohne menschliche Review ausgeführt wird. Das Deno-Team hat die Sandbox eingeführt, um dies zu verhindern. Aus der Sandbox heraus lässt sich der Code in die Produktion deployen.

Kostenpunkt: Free, Pro oder Enterprise

Deno Deploy lässt sich in einer kostenlosen Free- oder einer kostenpflichtigen Pro-Version für 20 US-Dollar pro Monat nutzen. Die Free-Version ist begrenzt auf eine Million Requests pro Monat (Pro: fünf Millionen), ebenso wie auf eine Egress-Bandbreite von 100 GB (Pro: 200 GB) und eine CPU-Zeit von 15 Stunden (Pro: 40 Stunden). Wer zusätzliche Ansprüche an Sicherheit, Support und Performance stellt, kann ein individuelles Enterprise-Angebot anfragen. Die Deno-Sandbox-Nutzung wird separat berechnet.

(mai)

In dieser Episode von software-architektur.tv sprechen Jonas Clusen und Hansjörg Gude mit Eberhard Wolff über soziotechnische Architektur-Reviews (STAR). Der Ansatz erweitert klassische Reviews um die organisatorische Perspektive. Das Ergebnis des Reviews zeigt, wie Teams, Kommunikation und Strukturen die Architektur beeinflussen.

Im Unterschied zum klassischen Ansatz liegt STAR ein kollaborativer Prozess zugrunde, der dazu beitragen soll, die Architektur so zu gestalten, dass sie mit der Organisation mitwachsen kann. So sollen beispielsweise Ursachen für Reibungsverluste in der Zusammenarbeit von Teams möglichst frühzeitig erkannt werden, um diesen entgegensteuern zu können.

Gemeinsam diskutieren Clusen, Gude und Wolff, wie STAR hilft, technische und soziale Spannungsfelder zu erkennen und daraus konkrete, wirksame Verbesserungen für Systeme und Organisationen abzuleiten – und wie durch den Ansatz Organisationen auch schon nachweisbar verbessert worden sind.

Jonas Clusen und Hansjörg Gude sind Gründer und Geschäftsführer von SWAGLab. Beide bringen jahrelange Erfahrung aus fachlich-technischen und leitenden Rollen in verschiedenen Bereichen der IT und Digitalisierung mit.

Livestream am 6. Februar

Die Ausstrahlung findet am Freitag, 6. Februar 2026, live ab 13 Uhr statt. Die Folge steht im Anschluss als Aufzeichnung bereit. Während des Livestreams können Interessierte Fragen via Twitch-Chat, YouTube-Chat oder anonym über das Formular auf der Videocast-Seite einbringen.

software-architektur.tv ist ein Videocast von Eberhard Wolff, Blogger sowie Podcaster auf iX und bekannter Softwarearchitekt, der als Head of Architecture bei SWAGLab arbeitet. Zum Team gehören außerdem Lisa Maria Schäfer (Socreatory) und Ralf D. Müller (DB Systel). Seit Juni 2020 sind über 250 Folgen entstanden, die unterschiedliche Bereiche der Softwarearchitektur beleuchten – mal mit Gästen, mal Wolff, Schäfer oder Müller solo. Seit mittlerweile mehr als zwei Jahren bindet iX (heise Developer) die über YouTube gestreamten Episoden im Online-Channel ein, sodass Zuschauer dem Videocast aus den Heise Medien heraus folgen können.

Weitere Informationen zu den Folgen finden sich auf der Videocast-Seite.

(map)