Transformer (Maschinelles Lernen)

Ein Transformer ist eine von Google entwickelte Deep-Learning-Architektur, die einen sogenannten Aufmerksamkeitsmechanismus integriert, der erstmals in einem Artikel aus dem Jahr 2017 „Attention Is All You Need“ vorgestellt wurde. Dabei wird Text in numerische Darstellungen, die als Token bezeichnet werden, und anschließend durch Worteinbettung in Vektoren umgewandelt. Dies kann z. B. dazu benutzt werden, Text von einer Sprache in eine andere zu übersetzen. Dazu wird ein Transformer mittels maschinellem Lernen anhand einer (großen) Menge von Beispielstexten trainiert, bevor das trainierte Modell dann zur Übersetzung verwendet werden kann. Weitere Beispielanwendungen von Transformern sind die Textgenerierung oder die Zusammenfassung längerer Texte. Transformer weisen hierbei eine bessere Effizienz gegenüber Long-short-term-memory-Architekturen (LSTM) auf und bilden die Grundarchitektur des generativen vortrainierten Transformers (GPT) und anderer vortrainierter Machine-Learning-Modelle. Lineare Transformer sind eine Form von „fast weight programmers“, welche 1991 vorgeschlagen wurden.^[1]

Hintergrund

Transformer wurden im Dezember 2017 im Rahmen der Neural-Information-Processing-Systems-Konferenz von einem Team von 8 Google-Mitarbeitern vorgestellt und mit dem Artikel „Attention Is All You Need“ veröffentlicht.^[2][3]
Bei der Verarbeitung natürlicher Sprache (NLP) wurden vor der Einführung des Transformers rekurrente Modelle wie LSTM, GRU und Seq2Seq eingesetzt, welche eine Eingangssequenz sequenziell abarbeiten. Diese Methoden wurden später um einen Aufmerksamkeitsmechanismus (engl. attention) erweitert. Transformer bauen auf dem Aufmerksamkeitsmechanismus auf und verzichten auf die rekurrente Struktur; dieser soll menschliche kognitive Aufmerksamkeit nachahmen und die wesentlichen Sinnzusammenhänge in einem gegebenen Kontext erkennen. Er berechnet eine „weiche“ Gewichtung für jedes Wort, genauer gesagt für die Einbettung in seinem aktuellen Kontextfenster. Diese Gewichte können entweder parallel (z. B. in Transformer) oder sequentiell (z. B. in rekurrenten neuronalen Netzen) berechnet werden. „Weiche“ Gewichte können sich im Gegensatz zu (vor)trainierten „harten“ Gewichten, die fix sind und keine Anpassung an wechselnden Kontext erlauben, bei jedem Durchlauf ändern. Sie erzielen bei geringerem Rechenaufwand ähnliche oder bessere Ergebnisse bei der Transformation von Sequenzen als rekurrente Modelle. Beispiele für Transformermodelle sind Bidirectional Encoder Representations from Transformers (BERT)^[4] und Generative Pretrained Transformer (GPT). Auch in AlphaFold2 sind Transformer als Evoformer in der Architektur enthalten.

Architektur

Transformer-Modellarchitektur mit originaler Position der Layer-Normalisierung. 2020 wurde eine verbesserte Positionierung der Layer-Normalisierung vor der Multi-Head Attention gefunden.

Ein Transformer besteht in seiner ursprünglich vorgestellten Form im Wesentlichen aus in Serie geschalteten Kodierern (Encoder) und in Serie geschalteten Dekodierern (Decoder).^[2][5][6] Die Eingabesequenz wird durch eine sogenannte Embedding-Schicht in eine Vektorrepräsentation überführt. Die Gewichte der Embedding-Schicht werden während des Trainings angepasst. Im Falle des Transformers kommt zusätzlich eine Positionskodierung zum Einsatz, wodurch die sequentielle Abfolge der Wörter berücksichtigt werden kann. Ein Wort erhält somit zu Beginn eines Satzes eine andere Repräsentation als am Ende.^[5]

Die Eingabesequenz wird in der Vektorrepräsentation einer Serie von Kodierern übergeben und in eine interne Repräsentation überführt. Diese interne Repräsentation bildet die Bedeutung der Eingabesequenz abstrakt ab^[6] und wird durch die Dekodierer in eine Ausgabesequenz übersetzt.^[6] Die Eingabesequenz wird hierbei in Batches verarbeitet, wobei die Länge der Kodierer-Dekodierer-Pipeline die maximale Länge der Eingabesequenz beschränkt.^[5] Je nach Größe des Netzwerks können beispielsweise einzelne Sätze oder auch ganze Absätze verarbeitet werden. Bei Eingabesequenzen, welche kürzer sind als die Kodierer-Dekodierer-Pipeline, wird Padding zum Auffüllen der Eingabesequenz genutzt.^[5] Ein Kodierer besteht aus einem Self-Attention-Modul und einem Feedforward-Modul, während der Dekodierer aus einem Self-Attention-Modul, einem Kodierer-Dekodierer-Attention-Modul und einem Feedforward-Modul besteht.^[6]

Transformer versuchen, das Problem der Parallelisierung durch die Verwendung von Kodierern und Dekodierer zusammen mit Attention-Modulen zu lösen. Attention-Module steigern die Geschwindigkeit, mit der das Modell von einer Sequenz in eine andere übersetzen kann. Alle Kodierer haben die gleiche Architektur. Dekodierer sind einander auch sehr ähnlich. Jeder Kodierer besteht aus zwei Schichten: Self-Attention und einem Feedforward Neural Network. Die Eingaben des Kodierers durchlaufen zunächst ein Self-Attention Layer. Der Dekodierer verfügt über beide Ebenen, aber zwischen ihnen befindet sich ein Attention Layer, das dem Dekodierer hilft, sich auf relevante Teile der Eingabemenge zu konzentrieren.^[7] Außerdem sind in der Architektur mehrere Residualverbindungen und Layer-Normalisierungen^[8] enthalten.

Attention-Mechanismen wurden erstmals 2015 im Kontext der maschinellen Übersetzung von Bahdanau, Cho und Bengio verwendet. Während sie immer noch auf einem rekurrenten neuronalen Netz basierten, schlugen Vaswani et al. 2017 ein Modell vor, das nur auf Attention beruht. Sie stellten fest, dass es rekurrente neuronale Netze bei maschineller Übersetzung übertrifft. In ihrem Artikel stellten sie eine neue neuronale Netzwerkarchitektur vor: das Transformer-Modell.

Der essentielle Baustein des Transformer-Modells, der Transformator Encoder Block, ist eine Funktion ${\displaystyle f\colon \mathbb {R} ^{t_{max}\times d}\to \mathbb {R} ^{t_{max}\times d}}$ mit ${\displaystyle f_{\theta }(X)=Z}$, die definiert ist durch

${\displaystyle {\begin{aligned}A&={\sqrt {\frac {1}{d}}}XW^{(q)}(XW^{(k)})^{T}\\M&=\mathrm {SoftMax} (A)XW^{(v)}\\O&=\mathrm {LayerNorm_{1}} (M+X)\\F&=\mathrm {ReLU} (OW^{(f_{1})}+b^{(f_{1})})W^{(f_{2})}+b^{(f_{2})}\\Z&=\mathrm {LayerNorm_{2}} (O+F)\\\end{aligned}}}$

Dabei wird die Softmax-Funktion und ein Rectifier (ReLU) verwendet.^[9]

Jede Encoderschicht enthält 2 Unterschichten: die Selbstaufmerksamkeit und das Feedforward-Netzwerk.

Kodierer

Die erste Teilschicht implementiert einen Mechanismus mit Multi-Head Self-Attention. Dieser Mechanismus implementiert Heads, die eine linear projizierte Version der Abfragen, Schlüssel und Werte empfangen und parallel jeweils die gleiche Anzahl Ausgaben erzeugen, die dann zum Generieren eines Endergebnisses verwendet werden. Die zweite Teilschicht ist ein vollständig verbundenes Feedforward Neural Network, das aus zwei linearen Transformationen mit dazwischenliegender Aktivierung der Rectified Linear Unit (ReLU) besteht. Alle sechs Schichten des Kodierers wenden die gleichen linearen Transformationen auf alle Wörter in der Eingabesequenz an, aber jede Schicht verwendet dazu unterschiedliche Parameter. Auf jede Teilschicht folgt eine Normalisierungsschicht, die die berechnete Summe zwischen der Eingabe in die Teilschicht und der von der Teilschicht generierten Ausgabe normalisiert.

Die Transformer-Architektur kann grundsätzlich keine Informationen über die relativen Positionen der Wörter in der Sequenz erfassen, weil sie keine Wiederholung nutzt. Diese Informationen müssen durch die Kodierung der Positionen in die Eingabeeinbettungen eingefügt werden. Die Vektoren für die Kodierung der Positionen haben die gleiche Dimension wie die Eingabeeinbettungen und werden mithilfe von Sinus und Kosinus unterschiedlicher Frequenz generiert. Anschließend werden sie zu den Eingabeeinbettungen summiert, um die Positionsinformationen einzufügen.^[10]

Dekodierer

Während der Inferenz kann ein Dekodierer zur autoregressiven Erzeugung von Sequenzen verwendet werden: Der Dekodierer wird mit einer Startsequenz abgefragt und sagt dann das nächste wahrscheinlichste Token vorher, welches im nächsten Schritt Teil der Eingabe wird (und so weiter). Beim Training des Dekodierers wird dieser Prozess durch Teacher Forcing und Maskierung im Dekodierer ersetzt, womit das Training stark beschleunigt wird.

Jede Schicht Dekodierer enthält drei Teilschichten: die kausal maskierte Selbstaufmerksamkeit (engl. causally masked self-attention), die Kreuzaufmerksamkeit (engl. cross-attention) und das Feedforward-Netzwerk. Weitere Details sind die residual connections eines residual neural network und die Schichtnormalisierung (Funktion LayerNorm), die zwar konzeptionell unnötig, aber für numerische Stabilität und Konvergenz erforderlich sind. Ähnlich wie die Feedforward-Netzwerkmodule einzeln auf jeden Vektor angewendet werden, wird auch LayerNorm einzeln auf jeden Vektor angewendet. Es werden zwei gängige Konventionen verwendet: die Post-LN- und die Pre-LN-Konvention. In der Post-LN-Konvention ist die Ausgabe jeder Teilschicht

${\displaystyle \mathrm {LayerNorm} (x+\mathrm {Sublayer} (x))}$

wobei ${\displaystyle \mathrm {Sublayer} (x)}$ die von der Teilschicht selbst implementierte Funktion ist.

In der Pre-LN-Konvention ist die Ausgabe jeder Unterschicht

${\displaystyle x+\mathrm {Sublayer} (\mathrm {LayerNorm} (x))}$

Der ursprüngliche Transformer von 2017 verwendete die Post-LN-Konvention. Es war schwierig zu trainieren und erforderte eine sorgfältige Abstimmung der Hyperparameter und ein „Aufwärmen“ der Lernrate, bei dem sie klein beginnt und allmählich zunimmt. Die im Jahr 2018 vorgeschlagene Pre-LN-Konvention erwies sich als einfacher zu trainieren, da kein „Aufwärmen“ erforderlich ist und die Konvergenz somit schneller erfolgt.

Diagramme

• 
  Links: Eine Schicht von Kodierer und Dekodierer. Rechts: Zwei Schichten von Kodierer und Dekodierer.
• 
  Links: Kodierer mit norm-first. Rechts: Kodierer mit norm-last.
• 
  Links: Dekodierer mit norm-first. Rechts: Dekodierer mit norm-last.

Pseudocode

Der folgende Pseudocode zeigt die Grundstruktur für den Algorithmus eines Transformers mit Kodierer, Dekodierer und Pre-LN-Konvention:^[11]

   input: Encoder input t_e
          Decoder input t_d
   output: Array of probability distributions, with shape (decoder vocabulary size x length(decoder output sequence))
   
   /* Kodierer */
   z_e = encoder.tokenizer(t_e)
   
   foreach (t in 1:length(z_e))
   {
       z_e[t] = encoder.embedding(z_e[t]) + encoder.positional_embedding(t)
   }
   
   foreach (l in 1:length(encoder.layers))
   {
       layer = encoder.layers[l]
   
       /* Erste Teilschicht */
       z_e_copy = copy(z_e)
       foreach (t in 1:length(z_e))
       {
           z_e[t] = layer.layer_norm(z_e[t])
       }
       z_e = layer.multiheaded_attention(z_e, z_e, z_e)
       foreach (t in 1:length(z_e))
       {
           z_e[t] = z_e[t] + z_e_copy[t]
       }
   
       /* Zweite Teilschicht */
       z_e_copy = copy(z_e)
       foreach (t in 1:length(z_e))
       {
           z_e[t] = layer.layer_norm(z_e[t])
       }
       z_e = layer.feedforward(z_e)
       foreach (t in 1:length(z_e))
       {
           z_e[t] = z_e[t] + z_e_copy[t]
       }
   }
   
   foreach (t in 1:length(z_e))
   {
       z_e[t] = encoder.final_layer_norm(z_e[t])
   }
   
   /* Dekodierer */
   z_d = decoder.tokenizer(t_d)
   
   foreach (t in 1:length(z_d))
   {
       z_d[t] = decoder.embedding(z_d[t]) + decoder.positional_embedding(t)
   }
   
   foreach (l in 1:length(decoder.layers))
   {
       layer = decoder.layers[l]
   
       /* Erste Teilschicht */
       z_d_copy = copy(z_d)
       foreach (t in 1:length(z_d))
       {
           z_d[t] = layer.layer_norm(z_d[t])
       }
       z_d = layer.masked_multiheaded_attention(z_d, z_d, z_d)
       foreach (t in 1:length(z_d))
       {
           z_d[t] = z_d[t] + z_d_copy[t]
       }
   
       /* Zweite Teilschicht */
       z_d_copy = copy(z_d)
       foreach (t in 1:length(z_d))
       {
           z_d[t] = layer.layer_norm(z_d[t])
       }
       z_d = layer.multiheaded_attention(z_d, z_e, z_e) 
       foreach (i in 1:length(z_d))
       {
           z_d[t] = z_d[t] + z_d_copy[t]
       }
   
       /* Dritte Teilschicht */
       z_d_copy = copy(z_d)
       foreach (t in 1:length(z_d))
       {
           z_d[t] = layer.layer_norm(z_d[t])
       }
       z_d = layer.feedforward(z_d)
       foreach (t in 1:length(z_d))
       {
           z_d[t] = z_d[t] + z_d_copy[t]
       }
   }
   
   z_d = decoder.final_layer_norm(z_d)
   
   output_distributions = []
   foreach (t in 1:length(z_d))
   {
       output_distributions.append(decoder.unembed(z_d[t]))
   }
   
   return output_distributions

Attention-Modul

Die Aufgabe des Attention-Moduls besteht darin, die Korrelation eines Eingabesymbols (Token) zu den anderen Eingabesymbolen zu berechnen. Gegeben sei die Worteinbettung (engl. embedding) ${\displaystyle {\vec {x}}_{i}}$ des i-ten Tokens einer Sequenz. Diese Einbettung ist ein als Vektor kodiertes Eingabesymbol. Aus jeder Einbettung werden unabhängig voneinander drei Vektoren berechnet, indem die Einbettung mit einer jeweils erlernten Matrix ${\displaystyle Q}$, ${\displaystyle K}$ oder ${\displaystyle V}$ multipliziert wird:

${\displaystyle {\vec {q}}_{i}={\vec {x}}_{i}\cdot Q}$, der Abfragevektor (engl. query)

${\displaystyle {\vec {k}}_{i}={\vec {x}}_{i}\cdot K}$, der Schlüsselvektor (engl. key)

${\displaystyle {\vec {v}}_{i}={\vec {x}}_{i}\cdot V}$, der Wertevektor (engl. value)

Hieraus wird das Aufmerksamkeitsgewicht (attention score) zwischen Token i und Token j der Sequenz durch das Skalarprodukt ${\displaystyle s_{i,j}}$ berechnet

${\displaystyle s_{i,j}={\vec {q}}_{i}\cdot {\vec {k}}_{j}}$

und schließlich durch die Quadratwurzel der Länge der Schlüsselvektoren ${\displaystyle \dim(k)}$ geteilt, um stabilere Gradienten zu erhalten (da die Softmax-Funktion bei großen absoluten Funktionsargumenten stark abflacht und der Gradient somit sehr klein wird):

${\displaystyle {\frac {s_{i,j}}{\sqrt {\dim(k)}}}}$

Hierauf wird die Softmax-Funktion ${\displaystyle \sigma }$ entlang der letzten Dimension angewandt:

${\displaystyle {\tilde {s}}_{i}=\sigma \left({\frac {s_{i,j}}{\sqrt {\dim(k)}}}\right)}$

Dieser skalare Wert wird nun mit dem Wertevektor multipliziert, was dazu führt, dass der Wertevektor mit einem Aufmerksamkeitsfaktor ${\displaystyle {\tilde {s}}_{i}}$ vergrößert oder verkleinert wird:

${\displaystyle {\vec {z}}_{i}={\tilde {s}}_{i}\cdot {\vec {v}}_{i}=\sigma \left({\frac {s_{i,j}}{\sqrt {\dim(k)}}}\right)\cdot {\vec {v}}_{i},}$

wobei der Vektor ${\displaystyle {\vec {z}}_{i}}$ die berechnete Ausgabe des Attention-Moduls für Token i darstellt.

Unterschiede zwischen Attention im Encoder und Decoder

Der Unterschied zwischen dem Self-Attention-Modul (im Encoder) und dem Kodierer-Dekodierer-Attention-Modul (im Decoder mit Encoder) besteht darin, dass das Self-Attention-Modul ausschließlich die Werte des vorhergehenden Kodierers bzw. Dekodierers verwendet und die Vektoren ${\displaystyle {\vec {q}}_{i}}$, ${\displaystyle {\vec {k}}_{i}}$ und ${\displaystyle {\vec {v}}_{i}}$ berechnet. Das Kodierer-Dekodierer-Attention-Modul hingegen berechnet nur den Abfragevektor ${\displaystyle {\vec {q}}_{i}}$ aus dem vorgelagerten Attention-Modul, während die Vektoren ${\displaystyle {\vec {k}}_{i}}$ und ${\displaystyle {\vec {v}}_{i}}$ aus dem Kodierer (Encoder) bezogen werden.

Masked Attention

Die Maskierung der Attention (welche insbesondere im Decoder beim Training notwendig ist, damit nur vergangene Tokens beachtet werden) ist durch folgende Modifikation gegeben:

${\displaystyle {\begin{aligned}{\text{MaskedAttention}}(Q,K,V)={\text{softmax}}\left(M+{\frac {QK^{\mathrm {T} }}{\sqrt {d_{k}}}}\right)V,\end{aligned}}}$

wobei M die Maskierungsmatrix ist, welche bei unmaskierten Werten den Wert 0 und bei maskierten Werten den Wert ${\displaystyle -\infty }$ annimmt. Stark negative Werte in der Maskierungsmatrix resultieren durch die Softmax-Funktion in einer maskierten Attention von Null. Die Maske wird häufig so gewählt, dass nur auf vorhergehende Werte Wert gelegt wird, d. h., dass eine kausale Maskierung erfolgt.

Multi-Head-Attention

In der Praxis wird die sogenannte Multi-Head-Attention eingesetzt. Jeder Head besteht hierbei aus einer eigenen Version der Matrizen ${\displaystyle Q}$, ${\displaystyle K}$ und ${\displaystyle V}$. Jedes Attention-Modul besitzt mehrere Heads. Wenn ein Head für eine bestimmte Eingabe ${\displaystyle x}$ nicht relevant ist, wird ein niedriger Wert berechnet, während ein für eine Eingabe relevanter Head einen hohen Ausgabewert berechnet.

Scaled Dot-Product Attention

Der Transformer implementiert ein Scaled Dot-Product Attention, das dem Verfahren des allgemeinen Aufmerksamkeitsmechanismus folgt. Scaled Dot-Product Attention berechnet zunächst ein Skalarprodukt für jede Abfrage ${\displaystyle q}$ mit allen Schlüsseln ${\displaystyle k}$. Anschließend dividiert es jedes Ergebnis durch den Skalierungsfaktor ${\displaystyle {\tfrac {1}{\sqrt {d_{k}}}}}$ und wendet dann die Softmax-Funktion an. Dabei erhält es die Gewichte, mit denen die Werte skaliert werden. In der Praxis können die Berechnungen effizient auf die gesamte Menge von Abfragen gleichzeitig angewendet werden. Zu diesem Zweck werden die Matrizen ${\displaystyle Q}$, ${\displaystyle K}$ und ${\displaystyle V}$ als Eingaben für die Aufmerksamkeitsfunktion attention bereitgestellt. Diese kann so dargestellt werden:

${\displaystyle \mathrm {attention} (Q,K,V)=\mathrm {softmax} \left({\frac {QK^{T}}{\sqrt {d_{k}}}}\right)\cdot V}$

Dieser Skalierungsfaktor wurde eingeführt, um dem Effekt entgegenzuwirken, dass die Skalarprodukte bei großen Werten stark ansteigen, wobei die Anwendung der Softmax-Funktion dann extrem kleine Gradienten zurückgeben würde, was zum Problem verschwindender Gradienten führen würde. Der Skalierungsfaktor dient dazu, die durch das Skalarprodukt berechneten Ergebnisse nach unten zu ziehen und dieses Problem zu vermeiden.

Das Verfahren zur Berechnung von ${\displaystyle \mathrm {attention} (Q,K,V)}$ ist wie folgt:

• Die Ausrichtungswerte werden berechnet, indem die in der Matrix ${\displaystyle Q}$ gespeicherte Menge von Abfragen mit den Schlüsseln in der Matrix ${\displaystyle K}$ multipliziert wird. Wenn ${\displaystyle Q}$ eine ${\displaystyle m\times d_{k}}$-Matrix und ${\displaystyle K}$ eine ${\displaystyle n\times d_{k}}$-Matrix ist, dann ist die resultierende Matrix ${\displaystyle QK^{T}}$ eine ${\displaystyle m\times n}$-Matrix:

${\displaystyle QK^{T}={\begin{pmatrix}e_{11}&e_{12}&\cdots &e_{1n}\\e_{21}&e_{22}&\cdots &e_{2n}\\\vdots &\vdots &&\vdots \\e_{m1}&e_{m2}&\cdots &e_{mn}\\\end{pmatrix}}}$

• Jeder der Ausrichtungswert wird mit ${\displaystyle {\tfrac {1}{\sqrt {d_{k}}}}}$ skaliert:

${\displaystyle {\frac {QK^{T}}{\sqrt {d_{k}}}}={\begin{pmatrix}{\tfrac {e_{11}}{\sqrt {d_{k}}}}&{\tfrac {e_{12}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{1n}}{\sqrt {d_{k}}}}\\{\tfrac {e_{21}}{\sqrt {d_{k}}}}&{\tfrac {e_{22}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{2n}}{\sqrt {d_{k}}}}\\\vdots &\vdots &&\vdots \\{\tfrac {e_{m1}}{\sqrt {d_{k}}}}&{\tfrac {e_{m2}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{mn}}{\sqrt {d_{k}}}}\\\end{pmatrix}}}$

• Es wird die Softmax-Funktion angewendet, um eine Menge von Gewichten zu erhalten.
• Die resultierenden Gewichte werden mithilfe der Matrixmultiplikation auf die Elemente der ${\displaystyle n\times d_{v}}$-Matrix ${\displaystyle V}$ angewendet:^[10]

${\displaystyle \mathrm {softmax} \left({\frac {QK^{T}}{\sqrt {d_{k}}}}\right)\cdot V={\begin{pmatrix}\mathrm {softmax} ({\tfrac {e_{11}}{\sqrt {d_{k}}}}&{\tfrac {e_{12}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{1n}}{\sqrt {d_{k}}}})\\\mathrm {softmax} ({\tfrac {e_{21}}{\sqrt {d_{k}}}}&{\tfrac {e_{22}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{2n}}{\sqrt {d_{k}}}})\\\vdots &\vdots &&\vdots \\\mathrm {softmax} ({\tfrac {e_{m1}}{\sqrt {d_{k}}}}&{\tfrac {e_{m2}}{\sqrt {d_{k}}}}&\cdots &{\tfrac {e_{mn}}{\sqrt {d_{k}}}})\\\end{pmatrix}}\cdot {\begin{pmatrix}v_{11}&v_{12}&\cdots &v_{1d_{v}}\\v_{21}&v_{22}&\cdots &v_{2d_{v}}\\\vdots &\vdots &&\vdots \\v_{n1}&v_{n2}&\cdots &v_{nd_{v}}\\\end{pmatrix}}}$

Adding Position Embeddings

Ein gängiger Ansatz besteht darin, der Eingabe Positionseinbettungen hinzuzufügen, bevor sie dem tatsächlichen Transformer-Modell zugeführt wird: Wenn ${\displaystyle U\in \mathbb {R} ^{t_{max}\times d}}$ die Matrix der Einheitseinbettungen ist, wird eine Matrix ${\displaystyle P\in \mathbb {R} ^{t_{max}\times d}}$ hinzugefügt, die die Positionsinformationen darstellt, und ihre Summe wird dem Transformer-Modell zugeführt: ${\displaystyle T(U+P)}$ . Für die erste Transformer-Ebene hat das folgenden Effekt:

${\displaystyle {\begin{aligned}{\tilde {A}}&={\sqrt {\frac {1}{d}}}(U+P)W^{(q)}{W^{(k)}}^{T}(U+P)^{T}\\{\tilde {M}}&=\mathrm {SoftMax} ({\tilde {A}})(U+P)W^{(v)}\\{\tilde {O}}&=\mathrm {LayerNorm_{1}} ({\tilde {M}}+U+P)\\{\tilde {F}}&=\mathrm {ReLU} ({\tilde {O}}W^{(f_{1})}+b^{(f_{1})})W^{(f_{2})}+b^{(f_{2})}\\{\tilde {Z}}&=\mathrm {LayerNorm_{2}} ({\tilde {O}}+{\tilde {F}})\\\end{aligned}}}$

Dabei wird die Softmax-Funktion und ein Rectifier (ReLU) verwendet.^[9]

Positional Encoding

Die Transformer-Architektur ist eine Architektur, die aus gestapelten Encoder-Schichten und Decoder-Schichten besteht. Zum Erzeugen von Sequenzdarstellungen nutzt der Transformer Self-Attention. Eine Encoder-Schicht besteht aus einer Self-Attention-Teilschicht, gefolgt von einer Feedforward-Teilschicht. Auf ähnliche Weise besteht eine Decoder-Schicht aus einer Self-Attention-Teilschicht, gefolgt von einer Encoder-Decodierer-Attention-Teilschicht, auf die eine Feedforward-Teilschicht folgt. Der Aufmerksamkeitsmechanismus ignoriert die Sequenzreihenfolge, weshalb in der Transformer-Architektur Positionskodierungen verwendet werden.

Absolute Positional Encoding

In der ursprünglichen Transformer-Architektur wird zu jedem eingebetteten Quell- und Zielwort ein absoluter Positionskodierungsvektor ${\displaystyle PE_{j}}$ hinzugefügt, um dessen Position ${\displaystyle j}$ anzugeben. Die Idee besteht darin, Sinuskurven unterschiedlicher Wellenlängen zum Kodieren unterschiedlicher Positionen zu verwenden. Für die Position ${\displaystyle j\in \{1,\ldots ,J\}}$ in einer Sequenz der Länge ${\displaystyle J}$ wird der absolute Positionskodierungsvektor ${\displaystyle PE_{j}\in \mathbb {R} ^{d_{\mathrm {model} }}}$ definiert durch

${\displaystyle {\begin{aligned}PE_{j,2\beta }&=\sin(j/10000^{2\beta /d_{\mathrm {model} }})\\PE_{j,2\beta +1}&=\cos(j/10000^{2\beta /d_{\mathrm {model} }})\\\end{aligned}}}$

wobei ${\displaystyle \beta \in \{1,\ldots ,\lfloor {\tfrac {d_{\mathrm {model} }}{2}}\rfloor \}}$. Vaswani et al. schlagen vor, dass sinusförmige Positionseinbettungen genauso gut funktionieren wie erlernte Positionskodierungen, und sie stellen die Hypothese auf, dass erstere auf längere Sequenzen verallgemeinert werden können.^[12]

Weblinks

• Tianyang Lin, Yuxin Wang, Xiangyang Liu, Xipeng Qiu: A Survey of Transformers. (PDF) 8. Juni 2021, abgerufen am 15. Juni 2021 (englisch, Übersicht über Transformer-Architekturen).
• Michael Phi: Illustrated Guide to Transformers - Step by Step Explanation. 1. Mai 2020, abgerufen am 15. Juni 2021 (englisch).

Einzelnachweise

1. Schmidhuber, Jürgen, and A. I. Blog. "Before 1991, no network learned by gradient descent to quickly compute the changes of the fast weight storage of another network or of itself. Such Fast Weight Programmers (FWPs) were published in 1991-93 [FWP0-2](Sec. 1, 2, 3, 4). They embody the principles found in certain types of what is now called attention [ATT](Sec. 4) and Transformers [TR1-6](Sec. 2, 3, 4, 5)." https://people.idsia.ch/~juergen/fast-weight-programmer-1991-transformer.html
2. Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, Illia Polosukhin: Attention is All you Need. (PDF) In: Advances in Neural Information Processing Systems. Curran Associates, Inc., 2017, abgerufen am 29. April 2024 (englisch).
3. Steven Levy: 8 Google Employees Invented Modern AI. Here’s the Inside Story. Wired, 20. März 2024, abgerufen am 2. Mai 2024 (englisch).
4. Rainald Menge-Sonnentag: Wer, wie, was: Textanalyse über Natural Language Processing mit BERT. In: Heise Online. 12. August 2019, abgerufen am 13. August 2020.
5. Alexander Rush: The Annotated Transformer. Harvard NLP, abgerufen am 19. Juni 2020 (englisch).
6. Jay Alammar: The Illustrated Transformer. Abgerufen am 19. Juni 2020 (englisch).
7. Giuliano Giacaglia, Towards Data Science: How Transformers Work
8. Xiong, Ruibin, et al. "On layer normalization in the transformer architecture." International Conference on Machine Learning. PMLR, 2020. https://proceedings.mlr.press/v119/xiong20b
9. Philipp Dufter, Martin Schmitt, Hinrich Schütze: Position Information in Transformers: An Overview
10. Stefania Cristina, Machine Learning Mastery: The Transformer Model
11. Mary Phuong, Marcus Hutter: Formal Algorithms for Transformers
12. Jan Rosendahl, Viet Anh Khoa Tran, Weiyue Wang, Hermann Ney, RWTH Aachen: Analysis of Positional Encodings for Neural Machine Translation