Transformer (Maschinelles Lernen)

Ein Transformer ist eine Methode, mit der ein Computer eine Folge von Zeichen in eine andere Folge von Zeichen übersetzen kann. Dies kann z. B. benutzt werden, um Text von einer Sprache in eine andere zu übersetzen. Dazu wird ein Transformer mittels maschinellem Lernen auf einer (großen) Menge von Beispiel-Daten trainiert, bevor das trainierte Modell dann zur Übersetzung verwendet werden kann. Transformer gehören zu den Deep-Learning-Architekturen. Transformer wurden 2017 im Rahmen der Neural-Information-Processing-Systems-Konferenz veröffentlicht. 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 sind die Grundarchitektur vieler vortrainierter Machine-Learning-Modelle wie

Hintergrund

Vor der Einführung des Transformers wurden in der Verarbeitung natürlicher Sprache (NLP) rekurrente Modelle wie LSTM, GRU und Seq2Seq eingesetzt, welche eine Eingangssequenz sequenziell abarbeiten. Diese Methoden wurden später durch einen Aufmerksamkeitsmechanismus (engl. attention) erweitert. Transformer bauen auf dem Aufmerksamkeitsmechanismus auf und verzichten auf die rekurrente Struktur. 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)^[1] und Generative Pretrained Transformer (GPT). Auch in AlphaFold2 sind Transformer als Evoformer in der Architektur enthalten.

Architektur

Ein Transformer besteht im Wesentlichen aus in Serie geschalteten Kodierern (Encoder) und in Serie geschalteten Dekodierern (Decoder).^[2][3][4] 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.^[3]

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^[4] und wird durch die Dekodierer in eine Ausgabesequenz übersetzt.^[4] Die Eingabesequenz wird hierbei in Batches verarbeitet, wobei die Länge der Kodierer-Dekodierer-Pipeline die maximale Länge der Eingabesequenz beschränkt.^[3] 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 Länge der Kodierer-Dekodierer-Pipeline, wird Padding genutzt, um die Eingabesequenz aufzufüllen.^[3]

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.^[4]

Transformer versuchen, das Problem der Parallelisierung durch die Verwendung von Kodierern und Dekodierer zusammen mit Attention-Modul 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 einen 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.^[5]

Außerdem sind in der Architektur mehrere Residualverbindungen und Layer-Normalisierungen^[6] enthalten.

Kodierer

Der Kodierer besteht aus einem Stapel von 6 identischen Schichten, wobei jede Schicht aus zwei Teilschichten besteht.

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, um jeweils die gleiche Anzahl Ausgaben parallel zu 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 dazwischen liegender Aktivierung der Rectified linear unit (ReLU) besteht.

Alle 6 Schichten des Koderieres 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 der 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.^[7]

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). Während des Trainings des Dekodierers wird dieser Prozess durch Teacher Forcing und Maskierung im Dekodierer ersetzt, womit das Training stark beschleunigt wird.

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 Token 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 berechnet ${\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 angewendet:

${\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 während dem Training notwendig ist, um nur vergangene Tokens zu beachten) 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 den Wert 0 bei unmaskierten Werten annimmt und den wert ${\displaystyle -\infty }$ bei maskierten Werten. Stark negative Werte in der Maskierungsmatrix resultieren durch die softmax-Funktion in einer maskierten Attention von Null.

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 der gesamten 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 werden. 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:^[8]

${\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}}}$

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