10.3.5 Transformer-Technologie

Ein Transformer kann nur rechnen. Bevor der Transformer also seine Arbeit aufnimmt, muss Sprache in eine mathematische Struktur verwandelt werden. Das macht der Tokenizer:

Ein vollwertiger Transformer wird mit einer Unmenge von Text trainiert, bevor er sinnvolle Antworten liefert. Chat-GPT wird z.B. mit Millionen von Textseiten aus dem Internet trainiert.

Hier betrachten wir einen sehr kurzen Trainings-Text:

    In Spanien ist Paella als Essen beliebt.      
    In Deutschland ist Bier als Getränk beliebt.      
    In Japan ist Sushi als Essen beliebt.      
    In Deutschland ist Apfelstrudel als Essen beliebt.      
    In Spanien ist Sangria als Getränk beliebt.      
    In Italien ist Kaffee als Getränk beliebt.      
    In Italien ist Pizza als Essen beliebt.      
    In Japan ist Sake als Getränk beliebt.      
    In Spanien ist Tortilla als Essen beliebt.      
    In Japan ist Sushi als Essen beliebt.      
    In Deutschland ist Bratwurst als Essen beliebt.      
    In Italien ist Wein als Getränk beliebt.      

Damit mit Sprache gerechnet werden kann, wird eine Wortliste (Vokabular) aus dem Trainingstext entnommen und jedem Wort in der Wortliste wird ein sogenannter One-Hot-Vektor zugeordnet:

Vokabular:

    In           [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Spanien      [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    ist          [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Paella       [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    als          [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Essen        [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    beliebt      [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Deutschland  [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Bier         [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]      
    Getränk      [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]      
    Japan        [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]      
    Sushi        [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]      
    Apfelstrudel [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]      
    Sangria      [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0]      
    Italien      [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]      
    Kaffee       [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0]      
    Pizza        [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]      
    Sake         [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0]      
    Tortilla     [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]      
    Bratwurst    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]      
    Wein         [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]           

Der Prompt wird in Sprache formuliert. Mit den Worten kann der Transformer nichts anfangen. Also werden die Worte des Prompts im Vokabular gesucht und anstelle der Worte werden die One-Hot-Vektoren dem Transformer übergeben:

Prompt: "Essen in Spanien"

One-Hot-Vektoren ohne Beachtung der Groß-/ Kleinschreibung:

    [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
    [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 
    [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 

Die One-Hot-Vektoren werden anstelle der Worte dem Transformer übergeben. Mit diesen Zahl-Listen (Vektoren) kann der Transformer rechnen.

Damit ein Computer mit Sprache rechnen kann, muss Sprache mathematisch kodiert werden. Dabei ordnet man einem Wort eine Zahl-Liste (Vektor) zu.

Sprache besteht aus tausenden von Worten und man kann mit diesen Worten beliebig viele verschiedene Texte bilden. Die Bücher der Menschheit und das aktuelle Internet enthält so viel Text, dass eine mathematische Kodierung per Hand nicht zu leisten wäre.

Selbstlernende neuronale Netze können vollautomatisch Sprache zu mathematischen Zahl-Listen (Wortvektoren) kodieren.

• Öffne folgende App in einem neuen Fenster: Worte zu Vektoren

• Lade den Text "Essen", indem du "Essen" im Auswahlfeld anklickst und dann auf "Daten laden" klickst.

• Klicke dann auf "Nächster Schritt".

Aus dem Trainingstext werden One-Hot-Vektoren erstellt, so dass jedem Wort ein One-Hot-Vektor zugeordnet wird:

    In           [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Spanien      [0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    ist          [0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Paella       [0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    als          [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Essen        [0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    beliebt      [0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Deutschland  [0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0]      
    Bier         [0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0]      
    Getränk      [0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0]      
    Japan        [0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]      
    Sushi        [0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0]      
    Apfelstrudel [0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0]      
    Sangria      [0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0]      
    Italien      [0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0]      
    Kaffee       [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0]      
    Pizza        [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0]      
    Sake         [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0]      
    Tortilla     [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0]      
    Bratwurst    [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0]      
    Wein         [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]  

Aus dem Text werden Trainingspaare erzeugt, mit welchen das neuronale Netz trainiert wird:

    In | Spanien     
    Spanien | In     
    Spanien | ist     
    ist | Spanien     
    ist | Paella     
    Paella | ist     
    Paella | als     
    ...

Im neuronalen Netz:

• wird der One-Hot-Vektor des ersten Worts in die Eingabe-Schicht eingesetzt,
• werden zufällige Gewichte gesetzt,
• das zweite Wort des Trainingspaares wird neben die Ausgabeschicht gesetzt

In der Ausgabeschicht wird die Wahrscheinlichkeit ausgegeben, welches Wort auf "In" folgt. Da die Werte im neuronalen Netz nur Zufallswerte sind, stimmt die ausgegebene Wahrscheinlichkeit nicht: an der zweiten Stelle müsste der größte Wahrscheinlichkeitswert stehen.

Das neuronale Netzt macht einen Fehler. Dieser Fehler wird berechnet und das neuronale Netz korrigiert die eingetragenen Werte (Back-Propagation).

Das wird jetzt für jedes Trainingspaar wiederholt. Einen Durchlauf für den gesamten Text nennt man eine Epoche. Nach einigen Trainings-Epochen werden für jedes Wort die Werte der verborgenen Schicht als "Wort-Vektor" des entsprechenden Wortes ausgegeben:

    In           (0.9079, 0.0560, 0.0246)     
    Spanien      (0.1429, 0.4444, 0.9130)     
    ist          (0.2575, 0.0132, 0.0154)     
    Paella       (0.5235, 0.7616, 0.6587)     
    als          (0.0593, 0.0091, 0.1881)     
    Essen        (0.8465, 0.8465, 0.0536)     
    beliebt      (0.3473, 0.0209, 0.9355)     
    Deutschland  (0.1442, 0.4682, 0.9092)     
    Bier         (0.3882, 0.8046, 0.6064)     
    Getränk      (0.8586, 0.8344, 0.0692)     
    Japan        (0.1539, 0.4580, 0.9104)     
    Sushi        (0.2602, 0.8529, 0.5121)     
    Apfelstrudel (0.5288, 0.8105, 0.6844)     
    Sangria      (0.4635, 0.7780, 0.6356)     
    Italien      (0.1514, 0.4622, 0.9097)     
    Kaffee       (0.5242, 0.8034, 0.6657)     
    Pizza        (0.3855, 0.8124, 0.6098)     
    Sake         (0.4591, 0.7822, 0.6332)     
    Tortilla     (0.4668, 0.8105, 0.6499)     
    Bratwurst    (0.4915, 0.8077, 0.6484)     
    Wein         (0.4684, 0.7892, 0.6369)     

In der dreidimensionalen Darstellung sieht man, dass das neuronale Netz folgende Worte in einer räumlichen Nähe positioniert hat:

• Essen, Getränk
• Deutschland, Spanien, Japan Italien
• Apfelstrudel, Paella, Sangria, Bratwurst,...

Das neuronale Netz gibt Worten einen ähnlichen Wortvektor, die aufgrund ihrer Position im Text eine ähnliche Bedeutung haben.

• Ändere den Wortradius auf 2, setze den Speed aufs Maximum und lasse das neuronale Netz 30 Epochen trainieren.

Durch den größeren Wortradius hat das neuronale Netz gelernt, dass

• Paella, Sushi, Apfelstrudel, Pizza, und Tortilla ähnlich sind,
• Bier, Sake, Kaffee, Wein und Sangria ähnlich sind.

Die Wortvektoren eines Essens sind weiter oben positioniert als die Wortvektoren eines Getränks:

Durch die relative Position der Wortvektoren werden Bedeutungs-Ähnlichkeiten zwischen den Worten mathematisch kodiert.

Beispiel:

In drei Dimensionen gibt es für die Bedeutung von Sprache zu wenig Platz. Deswegen werden in professionell eingesetzten Transformern Wortvektoren in mehr als drei Dimensionen kodiert.

• Öffne folgende App in einem neuen Fenster: Mehrdimensionale Wortvektoren

• Lade den Datensatz "LeagueOfLegends".

• Setze die Wortvektor-Länge auf 25, den Speed aufs Maximum und starte das Training.

Die Wortvektoren für jedes Wort enthalten jetzt jeweils 25 Dezimalzahlen. Das kann man nicht mehr räumlich darstellen, weswegen die Wortvektoren mit Hilfe von Farben anschaulich dargestellt werden können.

Ähnliche Worte wie die Positionen Top, Mid, Jungle, BotSupport und BotAD haben ähnliche Wortvektoren:

Bedeutungsvielfalt

Worte können aufgrund ihrer relativen Position in einem Text völlig unterschiedliche Bedeutungen haben:

Beispiel: "Flügel"

• Die Pianistin entfaltet ihre Virtuosität am Flügel.
• Der Flügel der Taube musste vom Tierarzt geschient werden.

Beispiel: "Erde"

• Die Erde ist unser Heimatplanet.
• Für unser neues Hochbeet müssen wir im Baumarkt noch Erde kaufen.

Beim "Positional Encoding" werden die Werte eines Wort-Vektors abhängig von seiner Position im Prompt auf eine bestimmte Weise verändert.

Der Transformer hat durch eigenes Training auf der Basis einer großen Menge von Trainingstexten selbst gelernt, wie die Wort-Vektoren abhängig von der Position im Prompt sinnvoll verändert werden sollten.

Die Wortvektoren des Eingabe-Prompts werden dem Encoder übergeben. Der Encoder ist ein trainiertes neuronales Netz dessen Gewichte mit Hilfe von Trainingstexten angepasst wurden.

Die Aufgabe des Encoders besteht darin, die Beziehungen der Wort-Vektoren des Prompts zueinander zu analysieren und diese Beziehungen mathematisch zu kodieren.

Wir Menschen lesen diese beiden Sätze und können das Wort "sie" sinnvoll zuordnen:

• im ersten Satz bezieht sich "sie" auf "Boxen", da wir wissen, dass man normalerweise einem Pferd in einer Box Heu zu fressen gibt.

• im zweiten Satz bezieht sich "sie" auf "Pferde", da wir wissen, dass Pferde aufgeregt sein können, aber eine Pferde-Box niemals aufgeregt ist.

In einem Encoder gibt es dafür einen Rechenschritt der "Self-Attention", wo Beziehungen zwischen Worten mit Hilfe eines trainierten neuronalen Netzes mathematisch kodiert werden:

• Zu dem Wort-Vektor "sie" werden vom trainierten neuronalen Netz drei weitere Vektoren automatisch berechnet:

  • Query-Vektor
  • Key-Vektor
  • Value-Vektor

• Mit Hilfe dieser drei Vektoren wird für jedes andere Wort im Satz ein Trefferwert berechnet, wie stark sich das gewählte Wort auf das Wort bezieht.

• Beispiel des Ergebnisses dieser Rechnung für das Wort "sie" im ersten Satz:

• Beispiel des Ergebnisses dieser Rechnung für das Wort "sie" im zweiten Satz:

Mit Hilfe des trainierten Neuronalen Netzes ermittelt der Encoder eine Wahrscheinlichkeit, auf welches andere Wort sich das Wort "sie" wahrscheinlich bezieht. Das funktioniert aber nur, wenn in den Trainigstexten, mit welchen der Encoder trainiert wurde, auch Texte enthalten waren, mit welchen ein solcher Bezug trainiert werden konnte.

Der Encoder wird für jedes Wort im Prompt mehrfach durchlaufen und die dabei berechneten resultierenden Wortvektoren werden dann dem Decoder übergeben.

Der Decoder ist ein Neuronales Netz, das ebenso wie der Encoder mit der gleichen riesigen Menge von Text trainiert wurde.

Die Aufgabe des Decoders ist es, ein einziges Wort auszugeben, das sinnvoll einen Antwortsatz auf den Prompt beginnt.

In diesem Beispiel enthält der Trainingstext 21 Vokabeln. Der Decoder würde als Ergebnis der Berechnung einen Ergebnis-Vektor mit 21 Werten ausgeben:

    [3.13214247,-2.93261276,-2.28851225,-2.91095481,-2.49184605,-2.43332968,-1.3576114,-0.28156537000000004,-2.39388675,-2.22635866,-2.98321713,-2.77063388,-2.68930381,-2.46356088,-0.9479922100000002,-2.91694953,-2.06877692,-1.59522302,-2.73126018,-1.92038736,-0.72816028]

Mit Hilfe einer Softmax-Funktion werden die Zahlen des Ergebnis-Vektors in Werte zwischen 0 und 1 umgerechnet. Dabei gilt, dass die Summe aller dieser Zahlen genau 1 ist.

    [0.26661489, 0.00292988, 0.03093425, 0.00387153, 0.02209365, 0.02463784, 0.0714082,  0.11819281, 0.02635275, 0.03363658, 0.00072969, 0.00997244,  0.01350853, 0.02332344, 0.08921773, 0.00361089, 0.04048796, 0.06107726, 0.01168434, 0.04693968, 0.09877564]

Dieser Ergebnis-Vektor wird in einen One-Hot-Vektor umgeschrieben, indem man den größten Wert auf 1 und alle anderen Werte auf 0 setzt:

    [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]   

Aus dem Vokabular holt man das Wort, welches dem ermittelten One-Hot-Vektor zugeordnet ist und gibt dieses aus:

    In           [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] 

Der vom Decoder ausgegebene Text wird wieder in den Decoder eingepflegt und immer weiter ein Wort nach dem anderen ausgegeben, bis der Decoder die Ausgabe beendet: