date-created: 2024-07-02 02:14:59 date-modified: 2024-07-09 07:53:32

Sequenzmodellierung | Self-Supervised learning

anchored to 116.00_anchor_machine_learning tags: #machinelearning #Study

Sequenzlernen

Wir kommen somit den aktuellen Strukturen in der Idee und Struktur näher!

Motivation

[!Tip] Motivation

Bis dato haben wir nur einzelne und unabhängige Inputs beetrachtet.

Das heißt also, wir haben einem Modell $x$ als Eingabe gegeben und wollten anschließend $\hat{y}$ erhalten ( als Prediction!)

Wir wissen, dass es viele Aufgaben gibt, die Modellierung und Vorhersagen von Sequenzen erfordert.

Beispiele wäre hierbei etwa:

• Sentimentanalyse: Klassifizierung der Stimmung von Produktrezensionen
• Spracherkennung : Erkennen von gesprochenen Worten

Für Sequenzvorhersagen / Generierung wären folgende Instanzen:

• Zeitreihenprognose: -> Vorhersage von Energieverbrauch oder Wetterbedingungen
• Texterzeugung: Generierung von Text -> Zeichen für Zeichen oder Wort für Wort ( LLM)
• Sprachübersetzung: Übersetzung von Sätzen einer Sprache in eine andere
• Sprachtranskription: Umwandlung gesprochener Sprache in Text

Different Sequence Tasks

Es lassen sich verschiedene Strukturen für “Probleme” mit Sequenzen formulieren.

Sie variieren hierbei etwa bei der Quantität der Eingabe und der Dimension / Struktur der Ausgabe

[!Req] Different sequence Tasks

Wir betrachten ferner den Input, die Sequenz, immer als eine Sequenz von Vektoren ( $x$), also $x^1,\dots ,x^T$

Wir können jetzt 5 verschiedene Aufgaben beschreiben, von welchen dann auch der Output abhängt.

Die Grafik gibt folgend die einzelnen Sequenzen und die Aus- und Eingaben für diese an.

Welche beschreiben diese Grafiken? Wo ordnen wir die Sequenzerkennung und die Sequenzvorhersage ein? #card

• Sequenzerkennung (many to one): gibt uns folgende Ausgabe: Label $y$ für die gesamte Sequenz (Eingabe) -> Stimmung einer Rezension, wo $x^1,\dots$ die Wörter darstellt
• Seuqenzvorhersage (many to many): eine Sequenz von Labels $y^1,\dots ,y^{T+1}$ -> Wettervorhesage
  • Hier hängt die jetzige Vorhersage immer auch von den vorherigen Ausgaben ab!

Die Zeindizes für $y$ hängen von der Aufgabe ab

-> Es kann hier also ein Delay auftreten etc.

Netzwerkarchitekturen | Umsetzung von Sequenzlernen

Historisch betrachtet gab es schon viele Ansätze, die versucht haben solche Netze zu modellieren, die Daten über lange Zeit sammeln und dann abhängig von mehreren Sequenzen Ausgaben oder auch neue Sequenzen ausgeben können.

Dass diese nicht so optimal waren, betrachten wir folgend.

Beispiele sind etwa:

• Recurrent Networks - Rumelhart et al. 1986
• Long short-term Memory Unit (LSTM) - Hochreiter and Schmidhuber, 1997
• Gated recurrent unit - Cho et al, 2014
• Transformer-Modelle - Vaswani et al. 2017

Sequenz als EINS Behandeln ( Time-delay neural networks)

Als einfachste Idee betrachten wir Time-delay neural networks.

[!Definition] Time-Delay neural networks

Betrachten wir einen Input $x^1,\dots ,x^T$

Wie behandeln wir dieses Datum in diesem Modell, wie führen wir aus, wo liegen Probleme? #card

Wir behandeln zeitliche Sequenzen, indem wir sie in einen einzigen Vektorinput umwandeln

–> Also wir packen alles in eine einzige Sequenz!

Der Ablauf ist dabei:

• Verzögere frühere Eingaben in der Zeit und füttere alle Eingaben

Problem:

• Wir fordern hier, dass alle Sequenzen die gleiche Länge haben / aufweisen (müssen)

Weiterentwicklung dazu sind dann Rekurrente Netze:

Rekurrente Netze

Sie sind ähnlich zu Sequenz als EINS Behandeln ( Time-delay neural networks), aber noch etwas angepasst:

[!Tip] Beschreibung Rekurrente Netze

Betrachten wir die beschreibende Grafik eines solchen Netzes:

Welche Änderungen zum Time-Delay neural network haben wir? Wie trainieren wir so ein Netz dann und was für ein Problem kommt auf?! #card

Das Netz hat folgende Eigenschaften:

• es enthält Selbstverbindungen oder Verbindungen zu Einheiten in früheren Schichten
• Diese Rekurrenz wirkt als Kurzzeitgedächtnis
• Normalerweise sind nur Teile der Neuronen mit rekurrenten Verbindungen

Trainieren eines Rekurrenten Netzes wird dann folgend umgesetzt:

• Meist mit Backpropagation

Dabei ist relevant bzw. einsehbar, dass sie sich über Zeit entfalten werden!

Das heißt diese Entfaltung in der Zeit wird durch das Erstellen einer Kopie jeder Einheit für jeden Zeitschriftt.

-> Damit ist das resultierende Netzwerk wieder ein Feed-Forward-Netzwerk! Beschrieben wird es dann also mit: $$\begin{array}{rl}>z_h^t& =f\left(\sum _{j=0}^d(w_{hj}{x}_j^t+)+\sum _{t=0}^H(r_{hl}\cdot z_l^{t-1})\right)\\ >y^t& =g\left(\sum _{h=0}^H(v_h\cdot z_h^t)\right)>\end{array}$$

Hierbei werden solche Netzwerke meist sehr tief sein und damit haben wir das Problem von Exploding | Vanishing Gradients , die immer kleiner werden und verschwinden!

Long Short-Term Memory (LSTM)

LSTMs sind teils wieder relevant und werden betrachtet und umgesetzt!

[!Definition]

(Hochreiter und Schmidhuber, 1997)

Grundlegend beschreiben LSTMs eine komplexere Variante einer rekurrenten Uni rekurrente Netze

Unter Betrachtung der Grafik, nach welchem Prinzip funktioniert diese Struktur? Die roten Boxen beschreiben Gates. Jeder Pfad hat weiterhin eine Wichtung, die wir einbeziehen und die somit die Verarbeitung der Daten / Werte einbezieht! #card

• Die Eingabe in ein LSTM ist immer die Verkettung von aktuellen $x^t$ und vergangenen Daten $z^{t-1}$
• Dabei werden jetzt Gates verwendet, um den Einfluss vergangener Eingaben steuern zu können –> diese können also alte Eingaben einbringen / oder nicht. Wir listen dabei drei Typen von Gates:
  • Eingangs-Gates $i_h$
  • Vergessens-Gates $f_h$
  • Ausgangs-Gates $0_h$

Eine LSTM-Einheit besteht dann jetzt aus folgenden Zuständen:

• Effekt der aktuellen Eingabe $c_h$
• kumulativer interner Zustand $s_h$
• und der Gesamtwert $z_h$

Dabei ist noch wichtig, dass Gates multiplikativ sind:

• Meist verwenden wir hierfür dann sigmoids, sodass also $$i_h=sigmoid(W(x,z))$$
• und auch $s_h=c_h\odot i_h$ –> Elementweise Multiplikation!

Damit können wir dann also Informationsflüsse einfach Aus/Anschalten!

Beispiel-Anwendungen

Angenommen wir möchten unter Betrachtung von Sensoren jetzt feststellen, was eine Person macht - laufen, stehen, sitzen, liegen

Dafür müssen wir offensichtlich mehrere Verläufe betrachten und u.U. dann Veränderungen erkennen und auswerten.

Genau das können wir mit solchen LSTMs eben umsetzen, weil sie genau diese verschiedenen Zeit-Parameter einbeziehen und betrachten könnnen!.

[!bsp] Menschliche Aktivitätserkennung

Nehmen wir also an, wir möchten die Aktivität einer Person anhand der Sensoren an deren Smartphone erkennen.

Wie könnten wir dann hieraus etwa verschiedene Bewegungsabläufe erkennen? #card

Wir müssen hierfür erstmal eine Prämisse setzen, dass das Handy an einer bestimmten Stelle ist –> Damit wir den Kontext einschätzen können.

Jetzt können wir etwa Beschleunigungsdaten sammeln und dann daran die Aktivitäten erkennen:

• Gehen
• Treppensteigen
• Sitzen
• Stehen
• Liegen

Beispiel:

In folgendem Beispiel wurden Zeitreihen eines Beschleunigungsmesser ausgewertete

• Es brauchte Vorverarbeitungen, um die Gravitationsinformationen zu extrahieren –> relativ zur Erde!
• Es wurde eine many-to-one Konfiguration angenommen um aus vielen Verläufen eine Aussage treffen zu können
• Weiter gab es dann Klassenlabel mit 128 Datenpunkten
• (LSTM)
• Testgenauigkeit war hier bei 91.6%

Autoregressive Modelle

Wir wollen jetzt noch eine Struktur betrachten, die anhand von früheren Informationen eine neue vorhersagen kann:

Es ist also eine Many-To-Many Konfiguration!

[!Definition]

Wir möchten also eine Sequenzvorhersage beschreiben / bestimmen.

(etwa für Wettervorhersage, Sprachgenerierung)

Dabei werden uns jetzt Beispiele der Form $\{x_1^i,\dots x_T^i{\}}_{i=1}^N$ wobei hier $T$ unter Umständen verschieden Lang ist! (Also die Eingabe kann je nach Sequenz variierren!)

Nach der Idee möchten wir während des Trainings dann immer das nächste Elemente der Sequenz voraussagen.

Wie würden wir dann das Netzwerk beschreiben? Was passen wir für die Vorhersage an? #card

Beim training erhalten wir also eine Many-To-Many Konfiguration, die wir dann immer mit der Eingabe der nächsten Sequenz vergleichen –> Wir wollen diese ja später vorhersagen und nehmen sie deswewgen als korrekten Wert für den Loss!

Vorhersage:

In der Verwendung der Vorhersage möchten wir dann die Ausgaben der vorherigen Sequenz bzw. Verarbeitung als Eingabe in die neue Sequenz eingeben –> Wir füttern also unseren Output anschließend als neue Eingabe ein!

[!Attention] Autoregressive Modelle

Hierbei ist jetzt ersichtlich, dass bestimmte Probleme auftreten können.

was bahnt sich mit fortlaufender Vorhersage an? #card

Wenn wir Fehler haben, dann werden diese sich nach und nach immer erweitern / verschlimmern, weil jede weitere Eingabe einen alten Fehler erhält und verschlimmert.

Self Supervised Learning

Motivation

[!Korollar] Gründe für Self-Supervised-Learning

Was sind grundlegende Motivationen, um self supervised learning zu konstruieren. Was wäre die Alternative? #card

Grundlegend gibt es viel mehr unlabled Informationen - etwa im Internet etc - als gelableded Informationen!

Diese Infos können und wollen wir auch anwenden, um Aufagben mit wenig gelabelten Daten besser lösen zu können.

• Dafür müssen wir die Repräsentationen lernen, die für viele Aufgaben nützlich ist!

Labeln von Daten ist grundsätzlich aufwendig und teuer!

Etwa das Labeln von 1m Bildern würde etwa $83.333\€$ kosten. (Was noch nicht genug wäre)

Wir wollen jetzt also eine Repräsentation finden, die man bei möglichst vielen Beispielen / Konstrukten anwenden kann –> damit man also ein generelles Modell für viele Aufgaben gestalten / beschreiben kann!

AutoEncoder

Ist so mit das beliebtestes Framework, weil es sehr grundlegende Eigenschaften und herangehensweisen anwendet, um eine Lösung bzw ein Netz zu trainieren.

[!Definition] Auto-Encoder

Grundlegend: wir wollen ein Modell trainieren, indem die Labels für eine Eingabe direkt die Eingabe ist / sein wird.

–> Das ist erstmal sehr einfach und könnte trivial mit $h(x)=x$ gelöst werden.

(Jedoch würde wir damit nichts lernen, weswegen wir einen Auto-Encoder etwas anders konstruieren müssen).

Wie bauen wir einen Auto-Encoder auf, um jetzt ein Netz trainieren zu können? #card

Da die Identität uns keine Information teilen / geben kann, möchten wir das Modell in einen Encoder und Decoder aufteilen.

Hierbei:

1. Die Eingabe $x$ wird in den Encoder gepackt und es folgt $$z=encoder(x)$$
2. Die Ausgabe $z$ wird jetzt wieder versucht in $x$ umzuwandeln –> Also den Ausgangszustand wiederherstellen. Wir berechnen also: $$\hat{x}=decoder(z)$$

Visuell sieht das etwa so aus:

Trainieren eines Autoencoder

Es stellt sich die Frage: Wie trainiert man den Autoencoder jetzt?

[!Def] Training eines Autoencoder

Wir wollen hier auch wieder einen regression Loss verwenden, um das Netz aus Encoder / Decoder auf der Eingabe $x$ zu trainieren.

Was ist hierbei wichtig, was führt der Autoencoder grundsätzlich durch und womit kann man es vergleichen? #card

Diese Transformation ist grundsätzlich erstmal eine Dimensionsreduktion –> Wir wandeln von einer Hochdimensionalen Eingabe - vielleicht ein Bild mit Pixeln - in Gewichte des Netzes um, sodass wir das Bild anschließend theoretisch rekonstruieren können!

• Der Autoencoder führt also eine nicht-lineare Dimensionreduktion durch!
• Er kann dabei einen neuen Datenpunkt codieren –> als Ausgabe $z$
• Ferner könnte er jetzt auch einen neuen Datenpunkt erzeugen, wenn ihm eine Eingabe $z$ gegeben wäre

–> Damit wird die Struktur also auch generativ (auch wenn nicht so advanced wie aktuelle “generative ai” )

Grundlegend geben wir also $x$ ein, es wird encoded und danach wieder decoded und wir erhalten $\hat{x}$. Es wird dann gegen $x$ verglichen und damit der Loss berechnet!

Also $\hat{x}-z=Loss$

Mögliches Problem?

[!Hinweis]

Angenommen wir können also komplizierte, nichtlineare Transformationen der Daten durchführen.

Können wir sie dann in niedrigere Dimensionen komprimieren? #card

Als Beispiel wollen wir das an der Peano-Kurven betrachten.

Wir sehen hier, dass das nicht passieren kann

Denn:

1. Netzwerke bevorzugen, keine star nichtlinearen Lösungen, können sie aber erreichen, wenn man sie lang genug trainiert!
2. Regularisierung auf der Repräsentationsschicht kann helfen!

Regularisierung | Autoencoder

[!Definition] Regularisierung bei Autoencodern

Wir wollen jetzt die $L^2$ Regularisierung zur Repräsentation, also dem Zwischenschritt $z$ hinzufügen.

Wie sieht dann unser Loss aus? Was kann mit z passieren? #card

Unser Loss wird beschrieben mit: $$L(\theta )=\sum _{t=1}^N(\parallel x^t-decode{r}_{\theta }(encode{r}_{\theta }(x^t)){\parallel }^2+\lambda \parallel z^t{\parallel }^2)$$

Es folgt hier also, dass $z$ sehr klein wird!

• Jedoch könnte der decoder $z$ auch wieder vergrößern! (Also der Teil, der $z\to \hat{x}$ umwandelt)
• Jede Skalierung $\ne 0$ kann man rückgängig machen!
• Wenn wir dem Decoder jetzt “nicht erlauben, sehr genau hinzusehen” dann würde man das Problem lösen können.

Autoencoder mit Rauschen

Eine Alternative, um besser abbilden / übersetzen zu können, bildet sich mit Rauschen ab:

[!Definition] Wir fügen dem latenten Zustand also ein Rauschen hinzu, bevor wir es dann wieder Dekodieren.

Wie beschreiben wir dann also $\hat{x}$ und welchen Vorteil gewinnen wir? #card

$$\begin{array}{rl}>z& =encoder(x)\\ >\hat{x}& =decoder(z+\xi ),\xi \sim \mathcal{N}(0,{\sigma }^2)>\end{array}$$

Dabei ist jetzt $\sigma$ eine beliebige Konstante, die wir setzen können!

• Bei der Regularisierung verwenden wir das zuvor definierte $z$!
• Sofern wir jetzt $L^2$ Regularisieren: folgt für $\parallel z{\parallel }^2$
• oder wenn wir eine $L^1$ Regularisierung durchführen: $\mid z|$

Unser Netz sieht also folgend aus:

Variational Autoencoder

Gleiche Idee, aber mächtiger!: Wir haben eine Encoder und Decoder für eine Eingabe $x$.

[!Feedback] Definition | Idee

Mit einem Variational Autoencoder (VAE) möchten wir prinzipiell wieder die gleiche Idee, wie zuvor betrachten und umsetzen –> also wieder Encoder/Decoder zusammenschließen.

Was macht diese Variante aus? Was passiert mit dem Zwischenwert z? Wie agiert der Decoder dann? #card

Prinzipiell handelt es sich hier auch um ein stochastisches Modell –> welches eine variationale Inferenz implementieren möchten / wird.

Dabei wir also wieder die Wahrscheinlichkeit $p(x)$ für die Eingabe modellieren, sodass daraus dann die Samples gezogen / erzeugt werden können.

• Also wir wollen neue Datenpunkte generieren, Samples aus der Verteilung ziehen

Der Decoder wird hier als generatives Modell agieren und folgende WSK modellieren:

$$p(x)=p_{\theta }(x\mid z)\cdot p(z),p(z):=\mathcal{N}(0,1)$$

–> Also wir setzen eine Normalverteilung über den Zwischenwert $z$ Wir möchten diesen Zwischenwert mit einer Gaußverteilung normalisieren –> Das heißt, wenn wir dann Punkte encoden, werden sie nach dieser Normalisierung “in der Mitte” liegen und dabei dann helfen, ein gutes $z$ zu bestimmen, was wir anschließend wieder decoded und ein nahes $\hat{z}$ erhalten können.

Dabei ist die Lernabbildungsfunktion (der Encoder) dann Amortisiert $q_{\theta }(z\mid x)$

Unser Ziel: Halte $q_{\theta }$ nahe bei $\mathcal{N}(0,1)$ –> etwa durch die Kullback-Leibler Divergenz link

Convolution Autoencoder

[!Tip]

Wenn wir jetzt mit Bildern arbeiten möchten, wie müssen wir vorgehen, um den Autoencoder nutzen zu können? #card

Wir wollen hier also die Idee des CNN anwenden -> mehrere Schichten, die Informationen filtern und somit erkennen können.

1. Encoder ist hierbei dann das Standard CNN mit voll verbundenem Readout
2. Decoder ist hierbei eine transponierte CNN –> also einfach das gleiche Prinzip, aber andersherum.

Grafisch wäre das etwa:

Anpassungen am Decoder

[!Definition] Decoder Modifikation

Da wir beim Decoder eine transponierte Convolution verwenden, wenden wir prinzipiell also ein CNN aber “rückwärts” an.

Wie müssen wir dann Padding und Stride anpassen? #card

Padding und Stride haben hier eine andere Implementierung -> weil sie sonst nicht funktionieren würden.

Padding:

• Kein Padding für normale Convolution bedeutet etwa, dass man ein volles Padding für eine transponierte Convolution anwenden wird.

Grafisch also:

(Wir müssen ja die verlorenen Daten wiederherstellen und somit durch das Padding neu erzeugen!)

Stride:

• Je nach Wert wird man hier also Zeilen und Spalten mit Nullen einfügen, um diese Lücken zu füllen.

Grafisch wäre das etwa:

Beispiel | Disentangling Erzeugender Faktoren

[!Example] Es ist ein Datensatz mit Portraits von Prominenten gegeben (weil man sonst in Copyright Probleme kommen könnte und es von diesen Menschen viele Fotos gibt!)

ein VAE (mit CNN) trainiert auf diesen Bildern mit einem $32-dim$ latenten Raum.

–> Man hat dann hier nur eine Koordinate von diesem Raum $z$ verändert, um mögliche Veränderungen des Ausgangsbildes - was konstruiert wird - zu finden / zu erkennen.

So konnte man etwa diverse Charakteristika von Menschen verändern:

(Das Paper wurde auch von unserem Prof mitgeschrieben: https://arxiv.org/abs/1812.06775)

Zusammenfassung | Auto-Encoder

[!Bsp] Zusammenfassung

was beschreiben wir mit autoencoder, was fügen variational autoencoders hinzu, was wird damit ermöglicht? #card

Autoencoder sind eine allgemeine Struktur um eine Dimensionsreduktion und ein Repräsentationslernen umsetzen zu können.

• dabei sind sie in der Idee einfach: Kodieren und Dekodieren einer Eingabe, während man die Menge von Daten zum rekonstruieren verringert –>> Dimensionsbottleneck
• der latente Raum ($z$) ist somit immer von kleinerer Dimension, als die Eingangsdaten!

Eine Erweiterung ist der Variational Autoencoder:

• damit wird der latente Raum besser / mehr strukturiert –> durch eine Normalverteilung
• damit können Samples / Daten generiert werden!
• sie können gute getrennte Repräsentationen erstellen –> sie führen quasi ein “nicht-lineares PCA” durch

Beispiele

Autoencoder mit MNIST-Ziffern

Wir wollen uns die Erkennung von handgeschriebenen Ziffern, wie bei 116.04_regression nochmal anschauen!

Wir nutzen hier einen Variational Autoencoder, welcher durch Eingaben des MNIST gelernt hat, Ziffern darstellen und erzeugen zu können.

Wir wissen ja, dass unser Modell hier also eine Art von Dimensionsreduktion umsetzt, um die Ziffern zu generieren / codieren zu können. Ferner kann man damit auch neue erzeugen, was wir folgend einsehen können:

Wir beschreiben hier eine Darstellung / Erzeugung von Nummern mit dem Modell.

Wenn wir usn das mit Labels anschauen, (achtung die Punkte unten rechts (blau) sind die Nullen, also alles ist gedreht) können wir genau diese Cluster gut erkennen, die uns auch visuell geboten werden

[!Attention] Dimension ist wichtig

Mit diesem Modell können wir jetzt auch eine Eingabe aufnehmen und dann rekonstruieren lassen.

Ein Beispiel mit $$z\in {\mathbb{R}}^2$$

Ein Beispiel mit $$z\in {\mathbb{R}}^{10}$$

Wir erkennen hier, dass unsere Accuracy mit steigender Dimension innerhalb des Autoencoders (also beim Schnittpunkt zwischen Decoder / Encoder ( genauer die Ausgabe $z$)) wachsen kann!

Denoising

Ferner, was logisch ist, kann man jetzt auch vorhandene Daten - Ziffern hier - mit Rauschen einsehen und anschließend herausfiltern –> Wir haben ja die Eigenschaft rekonstruieren zu können!

[!Attention] mit höheren Dimensionen $z\in {\mathbb{R}}^d$ funktioniert es besser!

Contrastive Learning

[!Definition] Contrastive learning

Eine weitere Idee für unüberwachtes / selfsupervised learning.

Unser Ziel: Wir wollen nicht annotiert (labled) Daten nutzen, um ein System zu trainieren!

_Was beschreiben wir mit der Idee von Contrastive Learning? Wie können wir positiv- und Negativbeispiele finden? #card

Idee:

• Lerne eine Repräsentation bei der ähnliche Dinge ( Bilder oder so) nah und unähnliche Dinge nicht nah sind!

Etwa visualisiert:

Problem: Wir müssen positive und negative Beispiele finden –> diese aber nicht explizit selbst erstellen –> dann wäre es wieder supervised!

Eine Möglichkeit dafür wäre:

• positive Beispiele werden direkt aus dem Datenpunkt selbst erstellt und ein andere Zufallspunkt als negativ verwendet.
  • Bei Bildern könnten das etwa verschiedene Zuschnitte derer sein!
  • 

Weiterhin könnten wir auch Filter anwenden –> etwa bei der Daten-augmentation <–

Man könnte durch multimodale Signale Klassifizieren:

• etwa das Bild betrachten
• und die Bildunterschrift

–> Daraus zieht man dann, ob es passt oder nicht.

Wir setzen also meist einen Anchor –> was etwa das Originalbild sein kann.

Dieses Bild und die andern beiden - ein positives und ein negatives Beispiel ( etwa ein ganz anderes Bild) - können wir dann in das CNN werfen, was diese bilder verarbeitet.

Dabei erhalten wir dann drei verschiedene Repräsentation dieser Bilder als Features des CNN, wobei wir anschließend versuchen die beiden Vektoren des Anchors und dem positive Beispiel - also beide, die etwa eine Katze abbilden! - möglichst nach zu setzen –> also ihre Distanz verringern. Zu dem “falschen Bild” und dem Anchor möchten wir logischerweise die Distanz vergrößern –> damit sie nicht untereinander assoziert werden können!.

Loss-Funktion beschreiben:

Jetzt brauch es bei diesen drei Datenpunkten eine Loss-Funktion, die uns hilft das Modell gemäß dieses Zieles: zwei möglichst nah zu legen und einen mit hoher Distanz zu entfernen; diese Reduktion modellieren zu können.

[!Tip] Loss-Funktion | Triplet Loss

Grundsätzlich gibt es viele verschieden Loss-Funktionen, die man hier nutzen kann.

Betrachten wir folgendes Szenario:

Gegeben ist ein Datenpunkt $x^a$ - entweder eine Abfrage oder ein Anker! - und weiter haben wir - zum Vergleichen - ein positives Beispiel $x^{+}$ ( was etwa ein modifizierter Anker sein könnte oder etwas anderes ähnliches) und ein negatives Beispiel $x^{-}$ (was etwa ein zufälliger Punkt sein könnte, oder etwas, wo wir wissen, dass es ein Negativbeispiel ist).

Wie definieren wir jetzt das Triplet-Loss? #card

Wir wollen Triplet-Loss mit Margin $m>0$ betrachten: $$L(x^a,x^{+},x^{-})=\max (0,D(x^a,x^{+}{)}^2-D(x^a,x^{-}{)}^2-m)$$

• Triplet Loss ist 0, wenn der Abstand zwischen den positiven Punkten kleiner ist als der Abstand zwischen dem Anker und dem negativen Punkt $-m$ also dem Margin.
• Der Loss ist positiv, wenn der Margin kleiner ist als $m$ –> oder sogar der Abstand zum negativen Punkt näher ist, als zum positiven Punkt
• Der Raum in dem der Abstand gemessen wird, ist ein Repräsentationsraum -> etwa $f=Ne{t}_{\theta }(x)$
• Somit folgt also : $$D(x^a,x^{+}{)}^2=\parallel Ne{t}_{\theta }(x^a)-Ne{t}_{\theta }(x^{+}){\parallel }^2$$
  • Das heißt wir wollen eigentlich schauen, wohin unser Punkt eher tendiert bzw näher ist –> zum Fehler oder Positiven Beispiel!

Alternativ nutzt man auch noch den Kosinusabstand als möglichen Abstand. Definiert ist er folgend, wobei man mit einen normierten Vektor $f$ arbeitet: $$D_{\cos ()(x^a,x^{+}{)}^2=1-⟨f^a,f^{+}⟩}$$

[!Bemerkung]

Mit diesem Triplet-Loss möchten wir also versuchen die Distanz von Vektoren - aus dem CNN - die zwei “positive / gleiche” Bilder abbilden, möglichst nah beieinander zu haben, während falsche Bilder dann weiter weg sein sollten.

Um das zu bestimmen, wann etwas dazugehört / wann nicht, können wir einen Threshold um den originalen Datenpunkt - wo wir wissen, dass er eine Klasse ist / haben soll / wirdw - welcher etwa als Radius für einen Kreis umgesetzt werden kann.

Anmerkungen:

[!Bemerkung]

Was sagt uns der Wert des Loss über die Abstände aus? Was wäre etwa bei Loss = 0 oder >0? Wovon ist die Distanzberechnung abhängig? #card

Der Triplet loss ist 0, wenn der Abstand zwischen den positiven Punkten kleiner ist, als der Abstand zwischen dem Anker und dem negativen Punkt $-m$ - dem Margin

• Weiterhin ist der Loss positiv wenn der Margin kleiner als $m$ ist – oder sogar der Abstand zum negativen Punkt näher als zum positiven

Wir messen diesen Abstand etwa im Repräsentationsraum, in welchem wir unsere Daten angeben., also etwa $f=Ne{t}_{\theta }(x)$

Somit folgt dann für die Distanz: $$D(x^a,x^{+}{)}^2=\parallel Ne{t}_{\theta }(x^a)-Ne{t}_{\theta }(x^{+}){\parallel }^2$$

Symmetric cross entropy | Info NCE loss

Ein weiteres, populäres Loss für Repräsentationslernen beschreiben wir mit Symmetric cross entropy Loss:

[!Definition]

Betrachten wir jetzt $n$ positive Paare – etwa die Ankerpunkte + ein positives Beispiel ( oder auch ein negaties)

Wir wollen uns dann jetzt die Ähnlichkeit Anschauen, beschrieben mit: $S_{\cos }(f^1,f^2)=⟨f^1,f^2⟩=f^{1^T}{f}^2$ wobei sie alle normierte Vektoren $f$ sind.

Was möchten wir jetzt für $f^a,f^{+}$ erreichen und was mit $f^{-}$, also im Bezug auf die Vektoren und die Ähnlichkeit dieser?_ #card

Grundsätzlich möchten wir, dass die Vektoren, die das Gleiche beschreiben - also $f^a,f^{+}$ - in die gleiche Richtung zeigen (sodass sie also sehr ähnlich sind) und die negativen Beispiele $f^{-}$ sollen möglichst orthogonal zu diesen sein !

Wir wollen genau diese Abhängigkeiten in einer Matrix festhalten: Jeder Eintrag wird folgend $⟨f^i,f^j⟩$ sein, wobei das jeweils ein bestimmter Vektor ist.

Die Diagonale sollte im Optimalfall immer $1$ sein - weil die Vektoren mit sich selsbt halt 100% ähnlich sind.

Man wendet dann ferner ein Softmax und die Cross-Entropy über alle Reihen und Spalten

Diese Matrix sieht dann etwa so aus:

Wir wollen also normierte Vektoren - der Datenpunkte - betrachten und hierbei dann die orthogonale Vektoren dazu erzeugen. -> Durch das Produkt.

Info NCE loss ist für large scale System wichtig / funktional, weil hier die random samples eher nicht zwingend falsche Beispiele sind.

Wenn wir etwa nur zwei Klassifkationen - Hunde / Katzen - hätten, dann würde unser Modell nicht so gut funktionieren.

CLIP model - Contrastive Learning for Multimodel Data

Als Anwendung der Symmetric cross entropy | Info NCE loss können wir jetzt etwa das CLIP-Modell betrachten

[!Idea]

Wir wollen jetzt multimodale Daten verwenden, also Bilder und Text und damit eine Vielzahl von Aufgaben bewältigen können.

Im folgenden Betrachten wir hier die Bildklassifikation, als eine spezifische Anwendung der Idee und Struktur!

Netterweise haben wir viele Bild-Text-Paare zur Verfügung stehen –> sodass wir diese Paare nutzen können, um etwaige Modelle zu trainieren, sie zu assistieren!

Wie macht das Clip ungefähr? Es setzt auf 3 Schritt. Was kann dieses Modell u.U. gut umsetzen? #card

Grundsätzlich ist es sehr bekannt und war womöglich das erste große Modell was auf open-world data aufgebaut - hat.

Interaktiv kann man es hier ausprobieren

• Mit der CLIP-Repräsentation kann man manche Aufgaben direkt in zero-shot (also sofort ) lösen.
  • Etwa Bildklassifikation durch Überprüfen der Nähe der Einbettung des Satzes: “A photo of a …” für viele verschiedene Objekte mit der Repräsentation des Bildes –> es wird also ein Kontext zwischen den Werten geschaffen und genutzt!
• Der latente Raum $z$ ist $512$ groß!

Wie er also funktionieren kann (er kann ja viele Dinge darstellen, das ist eine spezifische Anwendung des Modells, wo wir eine Klassifikation umsetzen!).

Wir geben einen Text: “ A photo of a {object}“ und dieser wird durch einen Text-Encoder in einen Vektor umgestellt / übersetzt. Jetzt können wir diesen Vektor nehmen und anschließend diese passende Bildunterschrift für ein Bild entscheiden. Also wir encoden das Bild in einen Vektor - haben wir ja zuvor trainiert - und dann können wir diesen Vektor mit dem anderen des Textes vergleichen –> Wir erhalten mit dem Wert, der den besten Match - niedrigster Wert - hat, dann eine passende Bildunterschrift, die das Bild etwa beschreibt.

Also haben wir mit diesem “generellen Modell” eine spezifische Aufgabe bearbeiten können –> die Bildklassifikation!

[!Bemerkung]

CLIP beschreibt mit das erste Foundation-Modell –> also ein solches, welches für viele Aufgaben genutzt werden kann und nicht spezifisch für eine konstruiert / modelliert wurde.

• Es hat einen sehr großen latenten Raum von $512$ Dimensionen
• Man kann es für viele spezielle Aufgaben verwenden -> Im Beispiel etwa Bildklassifikation, indem Encodings von Vektoren genommen und verglichen werden können.

Transformers

Transformers sind in ihrer Struktur ebenfalls 116.16_self_supervised_learning, welche also ohne immenses Supervising selbst Strukturen und Übersetzungen in Erfahrung bringen können. Ferner funktionieren sie auf Sequenz-Eingaben und können durch diese neue Sequenzen erzeugen - und wenn man diesen Output wieder in das System einbringt, wieder verarbeitet, erhält meine eine weitere Ausgabe mit dem Kontext –> Somit kann etwa ein Satz mit einem LLM erzeugt werden ( auch wenn hier noch weitere Strukturen mit eingebunden werden).

Motivation | Idee

[!Tip] Transformer - 2017 Vaswani et al.

Mit Transformern beschreiben wir auch wieder ein self supervised modell, dass Mengen als Eingaben verarbeitet ->> Dabei besteht keine bestimmte Reihenfolge, und auch keine Größenbeschränkung der Menge

• Mittlerweile fester Bestandteil von diversen LLM Systemen bzw. generell dem Feld der Sprachverarbeitung.
• DIese Struktur hat RNNs übertroffen, auch weil wir beim Erfassen etwa eine Langzeitabhängigkeit haben, die dabei mit einbezogen werden kann.
• Transformer sind hervorragend in maschineller Übersetzung, Textzusammenfassung und Aufgaben zur Beantwortung von Fragen –> Da hier versucht wird von dem System eine Abhängigkeit / Ähnlichkeit zu diversen Wörtern zu finden
• Wird auch in Computer Vision und Audioverarbeitung angewandt

Eigenschaften

[!Tip] Haupteigenschaften eines Transformer Modells:

Welchen Mechanismus nutzt ein Transformer? Wie werden die durch den Mechanismus gelernten Werte dann weiterverarbeitet? WAS kann das Modell damit bei einem Input umsetzen / bewirken? Was meint Selbst-Attention? #card

• Transformer verwenden den Selbst-Attention-Mechanismus, um Beziehungen zwischen Elementen einer Sequenz erfassen zu können.
• Attention multipliziert jedes Eingabeelement mit einem gelernten Relevanz-Wert –> welcher im gegeben Kontext Abhängigkeiten zu anderen Worten darstellen kann etwa.
• Damit ist das Modell in der Lage, sich auf verschiedene Teile des Inputs konzentrieren zu können
• Selbst-Attention meint hierbei, dass dies für jedes Element im Input durchgeführt wird und Kontext und Abhängigkeiten über die gesamte Sequenz erfasst

Wir durchlaufen also eine Menge von Worten und erzeugen die Wichtung dieser Worte im Kontext und können so Abhängigkeiten zwischen diesen erhalten etc. –> Visuell etwa:

Attention Mechanismus |

Ein wichtiger Punkt bei Transformern ist die Nutzung von Attention-Mechanisms ( daher ist der Titel des Papers auch “Attention is all you need” ).

[!Definition]

Ein Attention-Mechanismus ist eine Art eines Netzwerk-Layers (also er wird ebenso in eine Schicht von Layern eines Netzes eingebracht und verwendet) (später bei LLMs chained man diese etwa).

Hierbei wird, ähnlich zu Long Short-Term Memory (LSTM) die Multiplikation genutzt, um ein “Gating” zu erzeugen / zu verwenden.

Welche drei Komponenten erhalten wir hier, für ein Eingabeelement? –> Wie werden diese Werte (grob) berechnet? Welche Eingaben haben wir bei dieser Schicht? Was erhalten wir anschließend? #card

–> Der Attention Mechanismus berechnet hierbei eine gewichtete Summe von Values –> Wobei diese Gewichte aus der “Ähnlichkeit” zwischen dem Wert der Query und dem Wert des Keys für jedes Eingabeelement abgeleitet wird.

Insgesamt: Wir übersetzen eine Menge von Eingaben $x$ zu einer Menge von Layer Ergebnissen $y$ –> dabei geben wir das ganze in Vektornotation aus! <–

Die drei Komponenten beschreiben wir mit:

1. Query $(Q)$ : Dieser Wert repräsentiert das aktuelle Element in der Ausgabesequenz des Layers –> Also unter Betrachtung dessen können wir bestimmte Eingaben herausfiltern ( wenn ihre Relevanz nicht hoch genug ist etwa)
2. Key $(K)$ : Repräsentiert jedes Element in der Eingabesequenz –> Keys sind dann die vorhandenen Informationen, die wir (aus dem Kontext etwa ein Satz) betrachten und dann für eine Query schauen, wie ähnlich sie sind. –> im Kontext von Suchmaschine, wären es die Daten in der Datenbank gegen die wir unsere Query matchen und so eventuell einen Match finden (was dann die Value ist)
3. Values $(V)$: Repräsentiert die Information die aus der Eingabesequenz aggregiert werden soll.

–> Es gibt also etwa eine semantische Informationen, die für weitere Wörter, die folgend können, darstellt / beschreibt. Values sind also die Semantik / der Inhalt, den wir am Ende erhalten, der unseren Satz beispielsweise eine gewisse Idee gibt / darstellt.

In der Analogie der Datenbank wäre die Value dann die Ausgabe der Suchmaschine nach der Anfrage –> Sie gibt uns also eine gewisse Semantik aus, die wir weiterverwenden können.

weitere Erklärung etwa hier und nun auch 116.19_attention_mechanism

[!Tip] Darstellen der Werte als lineare Abbildung

Wir können diese Werte $Q,K,V$ als lineare Abbildung darstellen:

Wie machen wir das in Abhängigkeit der Gewichte? #card

Wir können folgend beschreiben: $$\begin{array}{rl}>Q_j& =W^Q\cdot x_j\\ >K_j& =W^K\cdot x_j\\ >V_j& =W^V\cdot x_j>\end{array}$$ Für $n$ Eingaben und der Key-Dimension von $k$ wodurch also folgt, dass die Matrizen folgende Größen haben:

$Q,K,V\in {\mathbb{R}}^{n,k}$

[!Feedback] Selbst-Attention

Was wird mit self attention gemeint, was ermöglicht sie? #card

Selbst-Attention ermöglicht es jedem Wort sich auf alle Wörter in der Sequenz zu beziehen (eingeschlossen sich selbst) –> es wird also der ganze Kontext betrachtet und bearbeitet.

Ferner möchten wir die Berechnung dieser Struktur jetzt genauer Betrachten:

Computation | Attention Mechanism

[!Definition] Dot-Product Attention

Wir wollen jetzt exemplarisch den Attention mechanism berechnen und somit die Werte unter Eingabe von $Q,K,V$ berechnen und verstehen.

Gegeben sind hierbei folgende Matrizen:

• $Q$ -> Queries
• $K$ -> Keys
• $V$ -> Values
• und die Dimension der Keys $k$ (also die Menge dieser)

Wie können wir jetzt die Attention unter Eingabe dieser Werte berechnen? Was symbolisieren die Skalarprodukte jeweils? wofür benötigen wir den Softmax? Was bedeutet das Skalarprodukt in dem Kontext #card

Wir berechnen die Attention für eine Eingabe $Q,K,V$ folgend: $$Attention(Q,K,V)=softmax\left(\frac{Q\cdot K^T}{\sqrt{k}}\right)\cdot V$$

• Dabei normalisieren wir also die Ergebnisse der Matrizen aufgrund der Dimension der Keys.
• dann werden wir Schritt für Schritt diese Matrizen berechnen, wobei das immer die Skalarprodukte von $Q,K$ sein werden
• diese Skalarprodukte geben hierbei die Ähnlichkeit der jeweiligen Keys und Queries an –> also Ähnlichkeit aus Betrachtung von Worten

Visuell ergibt die Berechnung schon mehr Sinn:

und somit dann für jeden Eintrag erhalten wir die Skalarprodukte dafür:

Anschließend wird man jetzt die Ergebnisse der Reihe (row) nehmen und daraus einen softmax bilden. Dieser wird dann mit den Values konkateniert und somit die Attention berechnet.

Multi-Head Attention

Jetzt haben wir die Verarbeitung eines Segments aus einem Raum betrachtet und umgesetzt. Wir wiederholen diesen Prozess aber mehrfach und - das machen wir, damit wir für eine mögliche Sequenz relativ gute Nuancen und Relationships finden können! –> Also wir crunchen die selbe Eingabe auf mehrere Attention-Heads- und möchten diese anschließend zusammenfassen, damit die Attention für alle Werte vorliegt. Das wollen wir durch Multi-Attention-Heads lösen / bearbeiten:

[!Bsp] Multi-Head Attention

Was wird uns mit der Multi-Head Attention ermöglicht? Was meinen wir mit einem Head und wie wird dieser berechnet? Warum führen wir multiple male aus? #card

Mit dem Konzept der Multi-Head Attention ermöglichen wir unserem Modell, gleichzeitig auf Informationen aus verschiedenen Repräsentationsunterräumen zu achten. Da wir die Attention-Heads multiple Male gleichzeitig laufen lassen, können wir diese Daten somit akkumulieren und gemeinsam betrachten.

(Wir lassen sie multiple male laufen, weil so für eine Eingabe / Sequenz verschiedene Reltionships / Ähnlichkeiten gefunden werden können und wir somit eine bessere Analyse erhalten können)

Wir beschreiben diese Operation mit: $$MultiHead(Q,K,V)=W^{O}Concat(hea{d}_1,\dots ,hea{d}_h)$$

Wobei hier jeder Head folgend berechnet wird: $$hea{d}_j=Attention(W_j^{Q^{\prime }}\cdot Q,W_j^{K^{\prime }}\cdot K,W_j^{V^{\prime }}\cdot V)$$

Visuell also:

Ferner gibt es jetzt noch weitere Aspekte die hier mit eingebracht werden:

[!Feedback] Residualverbindungn | Layer Normalization

Welche weitere Strukturen haben wir in unserem Transformer enthalten (siehe ResNet), wann wird die Normalisierung angewandt? #card

• Wie bei ResNet verwenden wir auch hier wieder skip connections
• Weiterhin wird Layer Normalization angewandt, welche - wie der Name suggeriert - nach jeder Unterschicht - also nach Self-attention und feed-forward - angewandt wird.
  • Sie wird eingesetzt, weil damit eine stabilisierung und Beschleunigung des Trainings ermöglicht wird

[!Tip] Elementweise Feed Forward Network

Weiterhin wird jedes Element der Sequenz - die Menge von Wörtern, die die Eingabe bildet - vom selbsen 2-layer MLP verarbeitet

Zwischenergebnis | Transformer

Als Zwischenfazit können wir jetzt folgende Punkte betrachten / einsehen:

[!Proposition] Transformer | Zwischenergebnis

Bis Dato haben wir also den Attention mechanism, sowie die Verarbeitung auf multiplen Layern kennengelernt, damit haben wir eine gute Grundlage geschaffen und können manche Eigenschaften / Ergebnisse beschreiben:

Welche Aussagen können wir über die Transformer im Bezug auf die bekannten Struktur treffen? #card

Transformer verwenden also einen Attention Mechanism, um die ganze Eingabesequenz / Menge gleichzeitig zu verarbeiten und aus dieser eine Semantik - Abhängigkeit zwischen Worten - erhalten zu können.

Es wird ermöglicht die Relevanz von Eingabeobjekten für die aktuelle Ausgabe zu erlenen –> also wie stark ein solches Wort etwa gewichtet in der Ausgabe ist. Das bezeichnen wir mit einem Retrievalmechanismus.

• Eingaben, die wir tätigen werden auf Keys - repräsentiert den Inhalt der Eingabe - und Values - beschreibt was wir weiterverarbeiten - abgebildet.
• Queries werden dann verwendet, um Eingaben zu filtern
• Die Self-Attention beschreibt also, dass jede Eingabe auch eine Query erzeugt
• Ähnlichkeiten werden mit Skalarprodukten (zwischen Query und Keys) und einem anschließenden Softmax gemessen

Daraus können wir auch einige Vorteile / Nachteile Ziehen

Vor / Nachteile | (von Attention)

[!Feedback]

beschreibe Vor und Nachteile vom Attention-Mechanismus #card

Vorteile:

• Funktioniert bei langen Sequenzen - Eingabe
• Kann das Nadel im Heuhaufen-Problem lösen
• Konzeptuell sehr einfach zu implementieren

Nachteile:

• Erfordert $\mathcal{O}(N^2)$ Rechenleistung und auch Speicher -> Skaliert also uncool schnell
• Die Reihenfolge der Inputs ist egal ( was auch ein Vorteil sein könnte).

Text Encoding

Wir haben jetzt bereits von Wörtern in Form von Vektoren gesprochen, aber nicht explizit benannt, wie diese Translation von Text zu Vektor passiert / umgesetzt werden kann.

Als Idee könnte man ja etwa einfach $n$-Gramme nutzen, also $n$ Zeichen, die zusammen liegen, betrachten und dann entsprechend übersetzen.

Alternativ könnte man ganze Wörter nehmen und sie als One-Hot darstellen.

–> Man könnte auch Tokens aus Wörtern ziehen und dise dann durch ein Embedding in einen hoch-dimensionalen Raum übertragen / übersetzen.

Überlegen Sie sich die Vor- und Nachteile der einzelnen Eingabecodierungen

• Verwendung eines Zeichens als atomare Eingabe
• Vorteil: kann den gesamten Text ohne Probleme verarbeiten
• Nachteil: viele Eingabeitems f¨ur einen kurzen Text
• Nachteil: sehr wenig Information pro Zeichen → denken Sie an die ¨Ahnlichkeitsmessung bei Attention: macht auf der Zeichenebene weniger Sinn

Verwendung von n-Grammen: n-Zeichen zusammen Etwas mehr Info pro Eingabe-Item

• Nachteil: willk¨urliche Trennung von W¨ortern
• Nachteil: f¨ur h¨ohere n: viele verschiedene Inputs

Verwendung ganzer Wörter

• Vorteil: Viel Information pro Eingabeitem
• Nachteil: beschr¨anktes Vokabular

Verwendung von häufigen Wörtern und Teilwörtern (Tokens)

• Vorteil: Viel Information pro Eingabeitem
• Vorteil: Ungeschränktes Vokabular
• Vorteil: Repräsentation im Vektorraum: Semantische Informationen k¨onnen gelernt werden
• Nachteil: benötigt einen geeigneten Tokenizer

Input Embedding und Tokenisierung

[!Idea]

Wir möchten unsere Eingaben so transformieren, dass sie als Vektor dargestellt und genutzt werden können.

High-Level haben wir dafür folgende Struktur:

1. Input Embedding
2. Tokenisierung
3. Embedding Matrix –> die diese Translation umsetzen kann

Wie funktioniert das input embedding, was machen wir bei der Tokenisierung? Wie ist die embedding Matrix aufgebaut? #card

Bei der Tokenisierung möchten wir prinzipiell Text in Tokens umwandeln.

Eine Häufige Tokenisierung funktioniert folgend:

• Häufige Wörter erhalten ihren eigenen Token –> weil sie relevant sind
• Weniger häufige Wörter werden in Teilwörter aufgeteilt und somit kann man sie dann kombinieren und somit manche Wortbedeutungen zusammenfassen, weil sie die selben Tokens aufweisen.
• Sonderzeichen erhalten ebenfalls einen eigenen Token.

Die Embedding Matrix wird genutzt, um jeden Token einen $d-$dimensionalen Vektor zuzuordnen.

Dabei betrachten wir mit $v$ die Vokubalurgröße und mit $d_{model}$ die Embedding-Dimension –> also wie hoch unser Feature Space ist quasi

Jetzt ist jeder Token $t_i$ eine One-Hot-Codierung, wobei $i\in 1,\dots ,v$ - also Abhängig des Vokabulars

Die Embedding-Matrix beschreiben wir folglich mit $E\in {\mathbb{R}}^{v\times d_{model}}$ und sie kann genau diese Translation umsetzen.

Anwendung: $$Embedding=\text{ Eingabe Token }i:x_i-E\cdot t_i$$

Wir geben einem Wort also einen One-Hot Eintrag, welcher aus dem Wort erzeugt wird. –> Anschließend wird diese Repräsentation des Vektors dann ( Was etwa eine Nummer in einer Struktur ist und diesem Wort eine Nummer gibt) durch eine Embedding-Matrix $G$ multipliiziert –> Damit erhalten wir einen Vektor im hoch-dimensionalen Raum, den wir später durch lernen verschieben und somit eventuel lzu manchen Bereichen zuordnen und angeben können –>

Diese Nummerierung des Dictionaries ist am Anfange egal, weil wir eh wieder verändern werden –> es geht darum, dass wir jedem Wort / Token eine einmalige Nummer zuweisen, die wir später verwenden können, um jedes Wort in den höheren Raum “transzendieren zu lassen”

–> Es ist also ein Startpunkt, der eine Eindeutigkeit der Worte dartellt und später werden diese translatierten Worte - im hohen Dim-Raum - dann angepasst und Strukturen für diese gelernt ( und somit Zuordnungen / Nähen etc erzeugt!)

Positional Encoding

Wir haben zuvor gesagt, dass die Eingabe egal ist, weil wir einfach eine Menge betrachten und somit die Eingaben unabhängig ihrer Reihenfolge verarbeitet werden. Wir wollen das nun folgend mit einer forcierten Position umgehen / lösen.

[!Definition] Positional Encoding

Wir wissen, dass ein Transformer kein Konzept von Eingabenreihenfolge aufweist, sondern einfach auf einer Menge operiert, wo diese egal ist.

Wir wollen unter Anwendung des Positional Encodings jetzt aber eine Methode anschauen, die diese Reihenfolge dennoch umsetzen kann.

Nach welchem Prinzip funktioniert sie? Wie werden die Formeln dafür beschrieben und angewandt? #card

Wir erzeugen jetzt positional encoding Vektoren die zum Anfangs erzeugten Embedding der Eingabe addiert werden –> Damit fügen wir quasi eine neue Sortierung ein.

Wir setzen das folgend um, wobei für die Position $p$, $i$ die Dimension steht:

$$\begin{array}{rl}>P{E}_{(p,2i)}& =\sin \left(\frac{p}{10000\cdot \frac{2i}{d}}\right)\\ >P{E}_{p,2i+1}& =\cos \left(\frac{p}{10000\cdot \frac{2i}{d}}\right)>\end{array}$$

Hierbei ist $d$ die Dimension der Eingabe!

Bzw. sehen wir auch den Einfluss in folgender Grafik:

Warum Positional Encoding Addieren

[!Korollar] Beobachtung

Es scheint grundlegend etwas ungewöhnlich / unpassend, dass der Position Encoding Vektor nicht angehangen wird, sondern als Addition mit eingebracht.

Warum ist das kein Problem, was kann man in den Eingabe-Embedding nach der Addition erkennen? Warum verwendet man es? #card

Wenn wir jedoch die vorherigen Grafiken anschauen, dann sehen wir da, dass sich nur ein Teil der Dimensionen wirklich verändert und die restlichen beinahe Unverändert bleiben.

Diese Struktur ist auch bei langen Sequenzen zu erkennen: nur ein Bruchteil des Position Encodings oszilliert hier - stark.

Dieses Eingabeencoding wird ebenfalls gelernt und damit kann man quasi “ einige Dimensionen nur für das position encoding reservieren“–> Also ein Teil gibt als Feature die Position des Wortes an!

Gründe:

• hautpsächlich nutzt an das aufrund der Einfachheit und Effizienz der Implementierung dieser.
  • Die Dimensionen bleiben Layer für Layer gleich!
  • Addieren ist schneller umgesetzt, als ein Anhängen
  • das Position Encoding hat eine kleinere Skala - wir skalieren $x$ hoch - und somit $x^{\prime }=\sqrt{d_{model}x}+PE$
  • es ist empirisch funktional

Transformer Architektur

Wir wissen, dass ein Transformer grundlegend ähnlich einem RNN ist -> in der Hinsicht, dass es Eingaben erhält und daraus dann Ergebnisse generieren kann.

[!Definition] Transformer Architektur:

Bettrachten wir nochmal im Vergleich die Struktur eines RNN Wie sind Transformer in ihrere Struktur aufgebaut, in welche Blöcke? Was macht der Encoder, was der Decoder? –> Wie wird eine Eingabe, im Unterschied zu einem RNN, umgesetzt? Was macht man mit weiteren Ausgaben? #card

Das RNN hat die Eingaben Schritt für Schritt aufgenommen und dann sequentiell bearbeitet. Also Vorteil dazu nimmt der Transformer die ganze Eingabe als Sequenz - Menge ! - und bearbeitet sie. Anschließend werden die Ergebnisse des Encoders in den Decorder gegeben - aber gleichzeitig auch der Kontext des vorherigen, um quasi in Abhängigkeit der Eingabe und der vorherigen Ausgabe ($\hat{y}$) eine neue Ausgabe zu tätigen - und dieser erzeugt eine neue Ausgabe, welche jetzt gemeinsam mit der Grundeingabe und diesem Feedback in den nächsten Decoder gegeben wird und somit nach und nach etwas generieren kann.

-> Der Transformer verwendet also eine gestapelte Menge von Self-Attention Blöcken in Form einer Encoder-Decoder-Architektur

1. Encoder erfasst hierbei die Eingaberepräsentation ( konvertiert also in den passenden Bereich und gibt die Ähnlichkeiten etc aus)
2. Decoder generiert dann die Ausgabesequenz - unter Vorbetrachtung der erhaltenen Eingabe(n)

High-Level sieht es folgend aus:

Ferner verwendet der Decoder dann noch eine masked attention –> Also nur die Vergangenheit der Ausgabesequenz.

Im Beispiel ist der Satz der produzierte Text vom Transformer:

Training Loss

[!Feedback]

Der Output unseres Transformers soll - im Kontext von Text-Generation - Text generieren können. Das heißt jetzt wir generieren Token für Token eine Ausgabe, die durch eine Vorhersage entsteht.

Welchen Loss können wir beim transformer anwenden, welche Art von Problem (lösung) setzt das voraus? #card

Wir benötigen hier einen Cross-Entropy-Loss, weil es sich um ein Klassifizierungsproblem handelt, welches wir lösen möchten.

(Im original-paper von Transformer) waren es etwa 30k Klassen / Token, auf die man dann die Vorhersage ausbauen wollte.

GPT-2 hatte dann schon 50k

Problem:

Wenn man jetzt immer die höchste Likelihood für eine Klassen nimmt, dann wäre der Text ja meist schon eher ähnlich und wir würden somit kaum Varianz in der Ausgabe haben.

In der Umsetzung wird man hier demnach auch ein Sample aus den höchsten WSK sehen, sodass hier verschiedene Einträge aus einer Menge von wahrscheinlichen Wörtern genommen werden kann.

–> Damit kann man dann verschiedene Texte generieren, trotz gleicher Eingabe

Zusammenfassung Transformer

[!Hinweis] Zusammenfassung von Transformern:

Prinzipiell haben wir eine einfache Idee:

Welche und wie wird das dann angewandt? #card

• Wir wollen das Prinzip der Attention anwenden und in vielen identischen Layers anwenden.
• diese Struktur kann erstaunlich gut mit Texten arbeiten
  • Text-Tokenisierung und Einbettung helfen sie in Vektoren darstellen zu können
  • Position Encoding gibt eine Metrik an, um die Wörter in einen Kontext zu schieben
  • Ausgabe-Klassifizierung über alle Tokens –> Wir erhalten eine WSK für diverse Tokens und können dann die erst-besten davon auswählen

–> Diese Struktur skaliert echt gut auf Texten, wie wir bei all den großen LLMs erkennen können.

LLMs | GPT etc

Ähnlich, wie unser zuvor betrachtetes CLIP-Modell suchen wir nach einem System, das mit einer riesigen Menge an Daten vortrainiert werden und dann für viele Aufgaben angewandt werden kann.

Das ist, was man mit LLM / Large Language Models umgesetzt hat oder aufbaut:

• Es sint große Modelle, die auf die Generierung von Text trainiert wurden. Damit ist die Aufgabe in vielen Bereichen möglich

GPPT –> Beschreibt die allgemeinere Idee:

• Unter Verwendung eines Transformers möchten wir diverse Dinge erzeugen –> nicht nur Text, sondern auch Bilder / Audios etc

[!Attention] Bei all diesen Modellen hat man immense Mengen von Daten – etwa das gesamte Internet, quasi – angewandt, um sie so gut zu trainieren.

Gutes Video über die Entwicklung dieser Ideen: link | youtube

GPT - Skalierbare Architekturen

[!Bsp] Der Große Durchbruch von all diesen Modellen kam eigentlih daher, dass diese Architekturen mit einer Menge von Daten immer besser skalieren können

Instruction Finetuning und Alignment

[!Question]

• Warum erstellen LLMs “gute Texte” –> Das Internet hat doch richtig viel Müll enthalten?
• Wie kann man eine Anweisung - etwa Code schreiben - stellen und eine sinnige / passende Antwort erhalten?

Umgesetzt wird das mit folgender Idee:

was meinen wir mit RLHF, was bewirkt es? #card

Reinforcement Learning from Human Feedback:

• wir generieren etwa 2 - oder mehr - Antworten zu einem Prompt und lassen dann von der Person entscheiden, welcher gut / besser war –> Mit dieser Informatione kann dann ein Ranking eingebracht werden
• Dieses Finetuning des LLM erhöht dann die WSK von bevorzugten Ausgaben und senkt gleichzeitig die WSK für unerwünshte Ausgaben

–> Hier sieht man dann auch, dass Menschen - und die ausgebeuteten Arbeiter*innen in afrikanischen / Entwicklungsländern wunderbar ausgebeutet werden, um diese Moderation und das Training umzusetzen.