Answer to Question 1-1
Aktivierungsfunktionen in tiefen neuronalen Netzen müssen nichtlinear sein, weil:

1. Hinzufügen von Nichtlinearität: Nichtlineare Aktivierungsfunktionen erlauben es dem neuronalen Netz, komplexe Muster und Beziehungen innerhalb der Daten zu lernen, die nicht durch lineare Modelle dargestellt werden können. Ohne Nichtlinearität wäre das Netzwerk effektiv nur in der Lage, lineare Transformationen durchzuführen, was seine Fähigkeit, komplexe Funktionen abzubilden, stark einschränken würde.

2. Erweiterung der Modellkapazität: Die Nichtlinearität ermöglicht es jedem Layer im Netz, eine komplexere Funktion der Eingangsdaten zu erlernen, was die Modellierungskapazität und -tiefe des gesamten Netzwerks erhöht.

3. Ermöglichung des Deep Learnings: Nichtlineare Aktivierungsfunktionen sind entscheidend für das Konzept des Deep Learnings, wo mehrere Schichten von Neuronen abstrakte Repräsentationen der Daten lernen. Ohne Nichtlinearität würden zusätzliche Schichten keinen Nutzen bringen, da das gesamte Netzwerk immer noch eine einzige lineare Transformation darstellen könnte.

4. Problemlösung für nicht separierbare Daten: In vielen Fällen, insbesondere bei Klassifizierungsaufgaben, sind die Daten nicht linear trennbar. Nichtlineare Aktivierungsfunktionen ermöglichen es dem Netzwerk, nicht linear trennbare Grenzen zu lernen, um solche Daten korrekt zu klassifizieren.

Zusammengefasst machen nichtlineare Aktivierungsfunktionen also neuronale Netze mächtiger und vielseitiger im Lernen von komplexen Datenmustern und Beziehungen.





****************************************************************************************
****************************************************************************************




Answer to Question 1-2
LayerNorm, BatchNorm und InstanceNorm sind alles Techniken der Normalisierung, die helfen können, das Training von neuronalen Netzwerken zu stabilisieren. Sie unterscheiden sich hauptsächlich in der Art und Weise, wie und über welche Daten sie die Normalisierung durchführen:

1. BatchNorm: Bei der Batch-Normalisierung wird die Normalisierung über das gesamte Batch durchgeführt, d.h. für jede einzelne Feature-Dimension wird der Mittelwert und die Standardabweichung über alle Beispiele im Batch berechnet. Dies hilft dabei, die Werte der Eingangsdaten zu stabilisieren und ermöglicht es, höhere Lernraten zu verwenden, indem die interne Kovariatenverschiebung reduziert wird.

2. LayerNorm: Layer-Normalisierung normalisiert die Daten über alle Feature-Dimensionen hinweg für ein einzelnes Datenbeispiel. Das bedeutet, dass für jedes Datenbeispiel separat normalisiert wird, und zwar über alle Eigenschaften dieses Beispiels. Dies ist besonders nützlich bei rekurrenten neuronalen Netzwerken (RNNs), da es die Normalisierung für jede Zeiteinheit unabhängig ermöglicht.

3. InstanceNorm: Die Instanznormalisierung wird hauptsächlich in der Bildverarbeitung verwendet und wendet die Normalisierung auf jede einzelne Instanz in einem Batch separat an, aber jeweils für alle Kanäle separat (z.B. bei einem Bild würden die RGB-Kanäle separat normalisiert). Diese Art von Normalisierung ist besonders nützlich bei Aufgaben, die Stiltransfer und Generative Adversarial Networks (GANs) verwenden.

Diese Arten von Normalisierungsschichten helfen bei der Stabilisierung des Trainings, indem sie die Skala der Aktivierungen regulieren und so dazu beitragen, das Problem des verschwindenden oder explodierenden Gradienten zu mildern. Sie ermöglichen es, das Netzwerk schneller zu trainieren, die Empfindlichkeit gegenüber der Initialisierung der Netzwerkparameter zu verringern und sogar die allgemeine Leistung des Netzwerks durch die Reduzierung der Überanpassung zu verbessern. Indem sie konsistente Verteilungen von Eingängen über verschiedene Schichten des Netzwerks hinweg gewährleisten, machen sie das Optimierungsproblem einfacher zu lösen.





****************************************************************************************
****************************************************************************************




Answer to Question 1-3
Um den Wert des Ausgabeneurons im letzten Zeitschritt eines rekurrenten Netzes zu bestimmen, müssen wir die Signale, die durch das Netz fließen, Schritt für Schritt verfolgen und berechnen. Dabei wenden wir auf das Ausgabeneuron die Sigmoidfunktion an, die wie folgt definiert ist:

\[ \sigma(x) = \frac{1}{1 + e^{-x}} \]

Das rekurrente Netz in der Abbildung hat eine Eingabeeinheit, eine verborgene lineare Einheit und eine Ausgabeeinheit. Die Verbindungen zeigen folgende Gewichte:
- Von der Eingabe zur verborgenen Einheit: 1
- Von der verborgenen Einheit zur Ausgabe: 10
- Von der verborgenen Einheit zurück zu sich selbst (rekurrenter Pfad): -1

Da alle Biases 0 sind, brauchen wir sie in den Berechnungen nicht zu berücksichtigen.

Wir gehen von einer Eingabesequenz der Länge N aus, die restlos durch 2 teilbar ist. Um den Wert des Ausgabeneurons im letzten Zeitschritt zu errechnen, benötigen wir die Werte der Eingabesequenz. Da diese Werte nicht gegeben sind und die Aufgabenstellung keine konkreten Zahlen nennt, kann ich leider keine spezifische Berechnung durchführen.

Stattdessen beschreibe ich den allgemeinen Berechnungsablauf:
1. Der Anfangswert des verborgenen Neurons ist 0, da kein Bias vorhanden ist und anfangs kein Eingangssignal empfangen wird.
2. Für jeden Zeitschritt \( t \) berechnen wir den neuen Wert des verborgenen Neurons \( h_t \) mit der Formel \( h_t = h_{t-1} \cdot (-1) + x_t \cdot 1 \), wobei \( x_t \) der Eingabewert zum Zeitschritt \( t \) ist.
3. Der Wert des Ausgabeneurons zum Zeitschritt \( t \) wird als \( y_t \) berechnet und ergibt sich durch Anwendung der Sigmoidfunktion auf das 10-fache des Wertes des verborgenen Neurons: \( y_t = \sigma(10 \cdot h_t) \).
4. Der Prozess wird wiederholt, bis das Ende der Eingabesequenz erreicht ist.

Aufgrund der rekurrenten Verbindung und der Natur der Sigmoidfunktion würde das Verhalten des Netzes stark von den Eingabewerten abhängen. Da wir keine spezifischen Eingabewerte haben, ist es nicht möglich, eine genaue Zahl für den letzten Zeitschritt anzugeben.





****************************************************************************************
****************************************************************************************




Answer to Question 1-4
a: Zur Trainingszeit sind die Netzwerkeingaben das aktuelle Zeichen oder Wort aus der Sequenz, auf das das rekurrente neuronale Netz (RNN) trainiert wird, sowie der vorherige versteckte Zustand (hidden state) des Netzwerks. Zusätzlich wird beim Teacher Forcing der tatsächliche erwartete Ausgabewert (zum Beispiel das nächste Zeichen oder Wort in der Sequenz) direkt an das Netzwerk zum nächsten Zeitschritt weitergeleitet, anstatt die vorhergesagte Ausgabe vom Netzwerk zu verwenden.

b: Zur Inferenzzeit, also wenn das Modell neue Daten generiert oder Vorhersagen macht, werden die Netzwerkeingaben initial durch das Starterzeichen oder -wort und danach durch die vom Netzwerk selbst generierten Ausgaben bestimmt. Der versteckte Zustand des Netzwerks wird weiterhin von einem Zeitschritt zum nächsten übertragen. Im Gegensatz zum Training mit Teacher Forcing wird die Eingabe für den nächsten Zeitschritt jedoch nicht durch eine externe Quelle bestimmt, sondern durch das, was das Netzwerk im vorherigen Zeitschritt vorhergesagt hat.





****************************************************************************************
****************************************************************************************




Answer to Question 1-5
Input:
- Ausgabe Dimensionen: (32, 32, 3)
- Die Dimension des receptive fields: 1

CONV3-8:
- Ausgabe Dimensionen: (32, 32, 8), denn es gibt kein Padding und der Stride ist 1, daher bleibt die räumliche Auflösung gleich.
- Anzahl der Parameter: $(3*3*3)*8 + 8 = 224$. Es gibt 3*3 (Kernelgröße) * 3 (Eingangskanäle) Gewichte für jeden der 8 Filter und zusätzlich 8 bias Werte (einer pro Filter).
- Die Dimension des receptive fields: 3*3=9

Leaky ReLU:
- Ändert nicht die Ausgabe Dimensionen, Anzahl der Parameter oder die Dimension des receptive fields.

POOL-2:
- Ausgabe Dimensionen: (16, 16, 8), denn wir führen ein 2x2 Max-Pooling mit einem Stride von 2 aus, was die räumliche Auflösung um den Faktor 2 reduziert.
- Anzahl der Parameter: 0.
- Die Dimension des receptive fields: 4×4=16, da jedes Fenster, über das der Pooling-Layer läuft, 4 Pixel in der originalen Eingabe bedeckt.

BATCHNORM:
- Ändert nicht die Ausgabe Dimensionen, aber fügt Parameter hinzu (z.B. für die Skalierung und den Shift). Die genaue Anzahl hängt von der verwendeten Implementation ab, typischerweise gibt es zwei Parameter pro Kanal.
- Die Dimension des receptive fields bleibt unverändert.

CONV3-16:
- Ausgabe Dimensionen: (16, 16, 16), da wieder kein Padding verwendet wird und Stride 1 ist.
- Anzahl der Parameter: (3*3*8)*16 + 16 = 1168.
- Die Dimension des receptive fields wird größer, genau zu bestimmen benötigt man mehr Informationen über die Verbindungsstruktur, aber prinzipiell vergrößert sich das Feld proportional zur Anzahl der Schichten und der Größe der Filter.

Leaky ReLU:
- Keine Änderung in den Dimensionierungen oder Anzahl der Parameter.

POOL-2:
- Ausgabe Dimensionen: (8, 8, 16), weil wieder ein 2x2 Max-Pooling mit einem Stride von 2 durchgeführt wird.
- Anzahl der Parameter: 0.
- Die Dimension des receptive fields wächst wieder.

FLATTEN:
- Ausgabe Dimensionen: $(8*8*16) = 1024$, da die 3D-Ausgabe der letzten Schicht in einen eindimensionalen Vektor umgewandelt wird.
- Anzahl der Parameter: 0.
- Die Dimension des receptive fields bleibt unverändert.

FC-10:
- Ausgabe Dimensionen: (10), weil es ein fully-connected Layer mit 10 Neuronen ist.
- Anzahl der Parameter: $(1024 * 10) + 10 = 10250$, da jedes der 1024 Eingabe-Features mit jedem der 10 Neuronen verbunden ist und jedes Neuron einen bias hat.
- Die Dimension des receptive fields bleibt für die vorherigen Schichten gleich, hat aber theoretisch Zugriff auf die volle Eingabedimension durch die vorige Flattening-Operation.





****************************************************************************************
****************************************************************************************




Answer to Question 2-1
1. Falsch. Die Verwendung von tanh gegenüber sigmoid wird zwar bevorzugt, aber nicht weil tanh das Vanishing Gradient Problem vollständig vermeidet. Es ist eher so, dass tanh im Allgemeinen bessere Eigenschaften hat, weil es zentriert ist (Output zwischen -1 und 1), aber es kann noch immer zu Vanishing Gradients kommen.

2. Wahr. Das Vanishing Gradient Problem sorgt dafür, dass in späteren Ebenen (oder Layern) eines tiefen neuronalen Netzes die Gradienten sehr klein werden können, was zu einem langsameren Lernprozess in diesen Layern führt, im Gegensatz zu früheren Layern, wo die Gradienten größer sein können.

3. Wahr. Leaky ReLU, eine Variante der ReLU-Aktivierungsfunktion, hat eine leichte Steigung für negative Werte, was verhindert, dass die Gradienten komplett verschwinden (sogenannte "tote Neuronen" bei der Anwendung der ReLU-Funktion), und somit hilft es, das Vanishing Gradient Problem zu mildern.

4. Wahr. Xavier Initialisierung ist eine Technik zur Initialisierung der Gewichte in einem neuronalen Netzwerk, die darauf abzielt, die Varianz der Ausgaben jedes Neurons zu normalisieren, um das Vanishing Gradient Problem zu vermeiden.

5. Falsch. Da die Optionen 2, 3 und 4 wahr sind, ist die Aussage, dass keine der obigen Aussagen zutreffend ist, falsch.





****************************************************************************************
****************************************************************************************




Answer to Question 2-2
- Die Größe der convolution Kernels: wahr
- Die Anzahl von Kanälen in den convolution Kernels: falsch
- Die Aktivierungsfunktion in jedem layer: falsch
- Die Größe des pooling layers: wahr





****************************************************************************************
****************************************************************************************




Answer to Question 2-3
Falsch. Wenn der Bias-Term in einer logistischen Regression weggelassen wird und der Gewichtsvektor W durch 2 dividiert wird, ändern sich die Entscheidungsgrenzen des Modells, was zu einer anderen Leistung auf dem Testdatensatz führen kann und daher die Testgenauigkeit Acc beeinflussen könnte.





****************************************************************************************
****************************************************************************************




Answer to Question 2-4
1. f(x) = min(2,x) - falsch
2. f(x) = 3x + 1 - falsch
3. f(x) = min(x, 0.5x) if x < 0; f(x) =  min(x, 0.5x) if x >= 0 - falsch
4. f(x) = min(x, 0.1x) if x < 0; f(x) =  max(x, 0.1x) if x >= 0 - wahr





****************************************************************************************
****************************************************************************************




Answer to Question 2-5
1. Data augmentation: wahr
2. Dropout: wahr
3. Batch normalization: wahr
4. Benutzung von Adam anstelle von SGD: falsch





****************************************************************************************
****************************************************************************************




Answer to Question 2-6
1. im Betrag erhöhen, die Polarität erhalten bleiben - falsch
2. im Betrag erhöhen, die Polarität invertieren - falsch
3. im Betrag verringern, die Polarität erhalten bleiben - wahr
4. im Betrag verringern, die Polarität invertieren - falsch





****************************************************************************************
****************************************************************************************




Answer to Question 3-1
a: Damit der attention layer $l$ head $h$ im Dekodierungsprozess vorwiegend zu der Position $n$ attendiert, muss die Bedingung erfüllt sein, dass der Query-Vektor $x^{l}_{n+1} W^{l, h}_Q$ eine hohe Ähnlichkeit (zum Beispiel gemessen durch ein Skalarprodukt) mit dem Key-Vektor $x^{l}_n W^{l, h}_K$ aufweist. Die Softmax-Funktion im attention-Mechanismus bewirkt, dass hohe Ähnlichkeitswerte zu einer stärkeren Gewichtung der entsprechenden Werte führen. In diesem Fall bedeutet dies, dass der attention head $h$ in Schicht $l$ hauptsächlich den Wert an der Position $n$ berücksichtigt.

b: Um diese Aufgabe für beliebige Eingabesequenzen erfüllen zu können, wird die sogenannte "Maskierung" (masking) benötigt, die in der Transformer-Architektur implementiert ist. Diese Maskierung verhindert, dass während der Selbst-Attention in dem Decoder Informationen von zukünftigen Positionen (also von Tokens, die in der Sequenz nach dem aktuellen Token kommen) einbezogen werden, was wichtig für das Prinzip der Autoregressivität des Modells ist. Diese Maskierung sorgt dafür, dass jeder attention head nur innerhalb der bisherigen Sequenz attendieren kann und dabei nicht auf zukünftige Tokens zugreift.





****************************************************************************************
****************************************************************************************




Answer to Question 3-2
a: Für das greedy decoding von $t_{k+1}$ im Schritt $n+1$ muss gelten, dass die Bewertungsfunktion (eine Kombination aus scores von den Attention-Heads und der abschließenden Output-Schicht) für dieses Token höher ist als für alle anderen möglichen Tokens. Die Induktion heads müssen also das Pattern erkennen, dass $t_k$ und $t_n$ identisch sind und basierend auf der Historie vorhersagen, dass nach $t_n$ das Token $t_{k+1}$ folgt.

b: Damit der Attention Layer $l$ Head $h$ am meisten zu der Position $k+1$ attended, muss die attention score für diese Position nach der Anwendung der attention-Funktion (Softmax-Aktivierung über die Attention Scores) für Position $k+1$ höher sein als für alle anderen Positionen von $1$ bis $n$.

c: Es ist unwahrscheinlich, dass ein Transformer-Modell mit nur einem Attention Layer die Bedingung für beliebige Sequenzen und für beliebiges $k < n$ mit $t_k = t_n$ erfüllen kann. Der Grund liegt darin, dass ein einzelner Attention Layer nur eine begrenzte Menge an Kontextinformationen verwenden kann, um Relationen zwischen Tokens zu identifizieren und zu lernen. Es könnte für bestimmte Muster oder kurze Sequenzen funktionieren, aber für komplexe Muster oder längere Sequenzen ist es wahrscheinlich, dass mehrere, aufeinander abgestimmte Attention Layers erforderlich sind, um die nötige Informationstiefe und -redundanz zu generieren.

d: - Im gleichen Layer gibt es keinen direkten Kommunikationskanal zwischen den einzelnen Attention Heads. Vielmehr verarbeiten sie die Eingaben parallel und unabhängig voneinander (Fangfrage). 
   - In aufeinanderfolgenden Layern wird die Information durch die Ausgaben der Attention Heads weitergegeben, die dann als Eingaben für die nächste Schicht dienen. Der Teil der Self-Attention, der entscheidet, was in diesen "Kommunikationskanal" geschrieben wird, ist die Linearkombination der Ausgabe, die durch die Gewichte $W^{l, h}_O$ gebildet wird. Was aus dem Kommunikationskanal gelesen wird, wird durch die Berechnung der Matrixmultiplikation der Gewichte $W^{l+1, h}_Q$ (für Queries) mit den Ergebnissen der vorangegangenen Schicht bestimmt.

e: Für ein zwei-layer Transformer-Modell könnte die Sequenz von Self-Attention Operationen so aussehen, dass der erste Layer auf das Erkennen der wiederholten Tokens $t_k$ und $t_n$ fokussiert wird, indem der Attention Head $h$ trainiert wird, eine hohe Attention Score zwischen diesen beiden Tokens zu produzieren. Der zweite Layer könnte dann darauf abzielen, die Information über die Position $k+1$ zu verstärken, basierend auf der Information, die vom ersten Layer geliefert wurde. Das könnte beinhalten, dass die Ausgabe des ersten Layers, welche die Beziehung zwischen $t_k$ und $t_n$ hervorhebt, mit den Position Embeddings so kombiniert wird, dass in der zweiten Schicht eine starke Aufmerksamkeit zur Position $k+1$ entwickelt wird. Man kann hier lineare Abbildungen nutzen, um durch Rotation und Verschiebung im Embedding-Raum eine solche Aufmerksamkeit gezielt zu konfigurieren.





****************************************************************************************
****************************************************************************************




Answer to Question 4-1
Um das Eingabetoken \( s_k \) als Matrix-Vektor-Multiplikation zu beschreiben, müssen wir zuerst verstehen, wie das word embedding \( E \) funktioniert.

Die vektorielle Eingabe für das \( i \)-te Vokabularwort \( s_k \) kann als one-hot-encoded Vektor \( v_k \) dargestellt werden, der die Länge \( |V| \) hat (wobei \( |V| \) die Größe des Vokabulars ist) und an der \( i \)-ten Stelle eine "1" hat, während alle anderen Einträge "0" sind.

Um die vektorielle Repräsentation \( x_k \) zu erhalten, wird dieser Vektor \( v_k \) mit der word embedding Matrix \( W_E \) multipliziert. Die Matrix \( W_E \) hat die Größe \( |V| \times d \) und enthält die vektoriellen Repräsentationen aller Wörter des Vokabulars in ihren Spalten.

Also, die Matrix-Vektor-Multiplikation sieht wie folgt aus:

\( x_k = W_E \cdot v_k \)

Hierbei ist \( x_k \) der vektorielle Output, also die Embedding-Repräsentation des Wortes \( s_k \). \( W_E \) ist die word embedding Matrix und \( v_k \) ist der one-hot-encoded Vektor des Eingabetokens \( s_k \).





****************************************************************************************
****************************************************************************************




Answer to Question 4-2
a: Die Abbildung $g$ muss differenzierbar sein, damit Gradientenabstieg möglich ist.

b: Angenommen $l = \mathcal{L}(f(w), t)$ für ein festes $t \in \mathbb{R}^d$. Der Gradient $\nabla l$ bezüglich $W_E$ ist die Ableitung von $l$ nach $W_E$. Nach der Kettenregel erhalten wir:
$$
\nabla l = \frac{\partial \mathcal{L}}{\partial f(w)} \cdot \frac{\partial f(w)}{\partial E(w)} \cdot \frac{\partial E(w)}{\partial W_E}.
$$
Da $f(w) = g(E(w))$, ist der Gradient von $f(w)$ nach $E(w)$ gleich $\frac{\partial g}{\partial E(w)}$. Also, der Gradient $\nabla l$ bezüglich $W_E$ ist:
$$
\nabla l = \frac{\partial \mathcal{L}}{\partial f(w)} \cdot \frac{\partial g}{\partial E(w)}.
$$
Hierbei ist $\frac{\partial g}{\partial E(w)}$ der einzige verbleibende partielle Gradiententerm.

c: Für $i \neq k$ ist der Gradient $\frac{\partial l}{\partial w_{ij}} = 0$, da Änderungen der Embedding-Vektoren von anderen Wörtern als $w$ keine Auswirkungen auf den Loss haben, wenn das Netz mit dem Eingabewort $w$ arbeitet.

d: Aus dem Ergebnis in Teil c) geht hervor, dass während des Forwärtspasses nur Werte für das Eingabewort $w$ berechnet und gespeichert werden müssen. Dies bedeutet, dass der Speicher- und Berechnungsaufwand relativ niedrig ist, da nur die Vektoren für das spezifische Eingabewort und nicht für das gesamte Vokabular benötigt werden. 

Für den Rückwärtspass bedeutet dies ebenfalls, dass der Berechnungsaufwand geringer ist, weil die Gradienten nur für das spezifische Eingabewort $w$ berechnet werden müssen. Es gibt keine Notwendigkeit, Gradienten für die gesamte Matrix $W_E$ zu berechnen, was zu einer signifikanten Reduzierung der Berechnungskomplexität führt.





****************************************************************************************
****************************************************************************************




