Answer to Question 1-1


Die Aktivierungsfunktionen in tiefen neuronalen Netzen müssen nichtlinear sein, aber es ist vorteilhaft, wenn sie es sind. Der Grund dafür ist, dass lineare Funktionen nur lineare Kombinationen der Eingaben erzeugen können. Wenn wir lineare Funktionen in mehreren Schichten hintereinander anwenden, erhalten wir immer noch nur eine lineare Funktion des Ursprungseingangs.

Um jedoch komplexere Funktionen und nichtlineare Beziehungen zwischen Eingaben und Ausgaben zu modellieren, ist es notwendig, nichtlineare Aktivierungsfunktionen in mindestens einer Schicht des neuronalen Netzes zu verwenden. Durch die Verkettung nichtlinearer Funktionen in verschiedenen Schichten können tiefen neuronalen Netzen komplexe Muster in den Daten erlernen und sogar nichtlineare Entscheidungsgrenzen zwischen verschiedenen Klassen definieren.

Daher sind nichtlineare Aktivierungsfunktionen in tiefen neuronalen Netzen wichtig, um die Leistungsfähigkeit und Flexibilität des Modells zu erhöhen und komplexe Beziehungen zwischen Eingaben und Ausgaben zu erfassen.





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




Answer to Question 1-2


LayerNorm, BatchNorm und InstanceNorm sind alle Normalisierungsschichten, die in neuronalen Netzen verwendet werden, um das Training zu stabilisieren. Sie unterscheiden sich in der Art und Weise, wie sie die Eingaben normalisieren.

LayerNorm normalisiert die Eingaben entlang der Feature-Achse. Das heißt, für jeden Beispielvektor in der Batch wird der Mittelwert und die Standardabweichung der Features berechnet und dann wird jeder Featurevektor normalisiert. Die Formel für LayerNorm ist wie folgt:

$y = \frac{x - \mu}{\sigma} * \gamma + \beta$

wobei x die Eingabe ist, μ der Mittelwert der Features, σ die Standardabweichung der Features, γ und β die Skalierung und Verschiebungsparameter sind, die während des Trainings gelernt werden.

BatchNorm normalisiert die Eingaben entlang der Batch-Achse. Das heißt, für jedes Feature wird der Mittelwert und die Standardabweichung der Beispiele in der Batch berechnet und dann wird jeder Beispielvektor normalisiert. Die Formel für BatchNorm ist wie folgt:

$y = \frac{x - \mu}{\sigma} * \gamma + \beta$

wobei x die Eingabe ist, μ der Mittelwert der Beispiele in der Batch, σ die Standardabweichung der Beispiele in der Batch, γ und β die Skalierung und Verschiebungsparameter sind, die während des Trainings gelernt werden.

InstanceNorm normalisiert die Eingaben für jedes Beispiel separat. Das heißt, für jedes Beispiel wird der Mittelwert und die Standardabweichung der Features berechnet und dann wird jeder Featurevektor normalisiert. Die Formel für InstanceNorm ist wie folgt:

$y = \frac{x - \mu}{\sigma} * \gamma + \beta$

wobei x die Eingabe ist, μ der Mittelwert der Features für dieses Beispiel, σ die Standardabweichung der Features für dieses Beispiel, γ und β die Skalierung und Verschiebungsparameter sind, die während des Trainings gelernt werden.

Diese Art von Normalisierungsschichten helfen bei der Stabilisierung des Trainings, indem sie die Größe der Eingaben skalieren und verschieben, um die Eingaben in eine ähnliche Größenordnung zu bringen. Dadurch wird das Problem der Vanshing Gradients oder Exploding Gradients reduziert, was zu einer stabilen Konvergenz führt. Darüber hinaus hilft die Normalisierung auch, die Korrelation zwischen den Features zu reduzieren, was zu einer besseren allgemeinen Leistung des neuronalen Netzes führt.





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




Answer to Question 1-3


Die Frage bezieht sich auf ein rekurrentes Netzwerk, das in der Abbildung "graphics/logistic_regression.jpg" dargestellt ist. Das Netzwerk besteht aus einer Eingabeschicht, einer verdeckten Schicht und einer Ausgabeschicht. Die Eingabeschicht hat zwei Neuronen, die verdeckte Schicht hat zwei Neuronen und die Ausgabeschicht hat ein Neuron.

Die Aktivierungsfunktion der Ausgabeschicht ist die Sigmoidfunktion, die durch die Formel f(x) = 1 / (1 + e^(-x)) definiert ist. Alle Biases im Netzwerk sind 0.

Die Eingabewerte sind skalare Ganzzahlen und die Länge der Eingabesequenz ist gerade.

Um die Werte des Ausgabeneurons im letzten Zeitschritt zu bestimmen, müssen wir das Netzwerk für jeden Zeitschritt berechnen.

Für den ersten Zeitschritt:

* Die Eingabewerte sind x1 und x2.
* Die Aktivierungen der Neuronen in der verdeckten Schicht werden wie folgt berechnet:
	+ a1 = f(w11 \* x1 + w21 \* x2)
	+ a2 = f(w12 \* x1 + w22 \* x2)
* Die Aktivierung des Ausgabeneurons wird wie folgt berechnet:
	+ y = f(v1 \* a1 + v2 \* a2)

Für den zweiten Zeitschritt:

* Die Eingabewerte sind die Aktivierungen der Neuronen in der verdeckten Schicht aus dem ersten Zeitschritt: a1 und a2.
* Die Aktivierungen der Neuronen in der verdeckten Schicht werden wie folgt berechnet:
	+ a1' = f(w11 \* a1 + w21 \* a2)
	+ a2' = f(w12 \* a1 + w22 \* a2)
* Die Aktivierung des Ausgabeneurons wird wie folgt berechnet:
	+ y' = f(v1 \* a1' + v2 \* a2')

Wir wiederholen diesen Prozess für jeden Zeitschritt, bis wir den letzten Zeitschritt erreichen.

Da die Länge der Eingabesequenz gerade ist, wird das Netzwerk für eine gerade Anzahl von Zeitschritten berechnet. Das bedeutet, dass das Ausgabeneuron im letzten Zeitschritt die gleichen Eingaben erhält wie im ersten Zeitschritt.

Da alle Biases 0 sind, ist die Aktivierung des Ausgabeneurons im letzten Zeitschritt gleich der Aktivierung des Ausgabeneurons im ersten Zeitschritt.

Daher ist der Wert des Ausgabeneurons im letzten Zeitschritt y.





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




Answer to Question 1-4


a) Zur Trainingszeit sind die Netzwerkeingaben die Wörter der Eingabesequenz, die in die Eingabeschicht des RNN eingespeist werden.

b) Zur Inferenzzeit sind die Netzwerkeingaben die Wörter der Eingabesequenz, die in die Eingabeschicht des RNN eingespeist werden. Allerdings wird hier das RNN-Modell nicht mit teacher forcing trainiert, sondern es wird autoregressiv vorgegangen. Das heißt, dass das RNN-Modell das nächste Wort in der Sequenz vorhersagt und dieses Wort dann als Eingabe für die nächste Zeitschrittebenen des RNN verwendet wird.





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




Answer to Question 1-5


Die Ausgabe der ersten Schicht, dem Input, ist 32x32x3, da die Eingabe eine 32x32 große Matrix mit 3 Kanälen ist. Die Anzahl der Parameter in dieser Schicht ist 0, da es sich um die Eingabe handelt und noch keine Parameter gelernt wurden. Das receptive field hat die Dimensionen 1x1, da noch kein Filter angewendet wurde.

Die Ausgabe der zweiten Schicht, CONV3-8, ist 32x32x8, da das Filter eine Größe von 3x3 hat und auf die Eingabe angewendet wird. Die Anzahl der Parameter in dieser Schicht beträgt 3x3x3 + 1 = 28, da es 8 Filter mit 3x3 Pixeln gibt und jeder Filter einen Bias-Parameter hat. Das receptive field hat die Dimensionen 3x3, da das Filter eine Größe von 3x3 hat.

Die Ausgabe der dritten Schicht, Leaky ReLU, ist 32x32x8, da es sich um eine Aktivierungsfunktion handelt und die Dimensionen der Eingabe beibehalten werden. Die Anzahl der Parameter in dieser Schicht ist 0, da es sich um eine Aktivierungsfunktion handelt und keine Parameter gelernt werden. Das receptive field hat die Dimensionen 3x3, da es sich um eine Aktivierungsfunktion handelt und die Dimensionen der Eingabe beibehalten werden.

Die Ausgabe der vierten Schicht, POOL-2, ist 16x16x8, da es sich um einen Max-Pooling-Layer mit einer Größe von 2x2 und einem Stride von 2 handelt. Die Anzahl der Parameter in dieser Schicht ist 0, da es sich um einen Pooling-Layer handelt und keine Parameter gelernt werden. Das receptive field hat die Dimensionen 4x4, da das Pooling-Fenster eine Größe von 2x2 hat und das Stride ebenfalls 2 ist.

Die Ausgabe der fünften Schicht, BATCHNORM, ist 16x16x8, da es sich um eine Batch-Normalisierung handelt und die Dimensionen der Eingabe beibehalten werden. Die Anzahl der Parameter in dieser Schicht ist 2 x 8 = 16, da es 8 Kanäle gibt und für jeden Kanal ein Skalierungsfaktor und ein Verschiebungsparameter gelernt wird. Das receptive field hat die Dimensionen 4x4, da es sich um eine Batch-Normalisierung handelt und die Dimensionen der Eingabe beibehalten werden.

Die Ausgabe der sechsten Schicht, CONV3-16, ist 16x16x16, da das Filter eine Größe von 3x3 hat und auf die Eingabe angewendet wird. Die Anzahl der Parameter in dieser Schicht beträgt 3x3x8 + 1 = 73, da es 16 Filter mit 3x3 Pixeln gibt und jeder Filter einen Bias-Parameter hat. Das receptive field hat die Dimensionen 7x7, da das Filter eine Größe von 3x3 hat und das Pooling-Fenster eine Größe von 2x2 hat.

Die Ausgabe der siebten Schicht, Leaky ReLU, ist 16x16x16, da es sich um eine Aktivierungsfunktion handelt und die Dimensionen der Eingabe beibehalten werden. Die Anzahl der Parameter in dieser Schicht ist 0, da es sich um eine Aktivierungsfunktion handelt und keine Parameter gelernt werden. Das receptive field hat die Dimensionen 7x7, da es sich um eine Aktivierungsfunktion handelt und die Dimensionen der Eingabe beibehalten werden.

Die Ausgabe der achten





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




Answer to Question 2-1


Die folgenden Aussagen über Gradientenabstieg treffen zu:

- (wahr) Vanishing gradient sorgt für langsameres Lernen in späten Layern als in frühen Layern.
- (wahr) Leaky ReLU leidet weniger unter dem vanishing gradient Problem als sigmoid.
- (wahr) Xavier Initialisierung kann dabei helfen, das vanishing gradient Problem zu vermeiden.

Die Aussage "tanh wird in der Regel gegenüber sigmoid bevorzugt, weil bei diesem das Vanishing Gradient Problem nicht auftritt" ist nicht ganz richtig. Obwohl tanh tatsächlich weniger anfällig für das Vanishing Gradient Problem ist als sigmoid, wird es nicht unbedingt bevorzugt, da es immer noch andere Nachteile hat.

Die Aussage "Keine der obigen Aussagen" ist ebenfalls falsch, da mindestens eine der obigen Aussagen korrekt ist.





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




Answer to Question 2-2


Die Größe des rezeptiven Feldes kann durch die Größe der Convolution Kernels erhöht werden.
Die Größe des rezeptiven Feldes kann durch die Anzahl von Kanälen in den Convolution Kernels erhöht werden.
Die Größe des rezeptiven Feldes kann durch die Aktivierungsfunktion in jedem Layer nicht erhöht werden.
Die Größe des rezeptiven Feldes kann durch die Größe des Pooling Layers erhöht werden.





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




Answer to Question 2-3


Die Antwort auf die Frage ist falsch. Wenn der Bias-Term weggelassen wird, kann eine Division durch 2 des Gewichtsvektors die Testgenauigkeit beeinflussen, da sich dadurch die Werte der logistischen Funktion ändern, die die Vorhersagen der logistischen Regression bestimmen.





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




Answer to Question 2-4


Die folgenden Funktionen können als praxistaugliche Aktivierungsfunktionen im Training von neuronalen Netzen benutzt werden:

1. f(x) = min(2,x)
2. f(x) = 3x + 1
3. f(x) = min(x, 0.5x) if x < 0; f(x) = min(x, 0.5x) if x >= 0 (diese Funktion ist identisch mit f(x) = x, da min(x, 0.5x) für alle x gleich x ist)
4. f(x) = min(x, 0.1x) if x < 0; f(x) = max(x, 0.1x) if x >= 0

Die letzte Funktion ist eine Stückweise-lineare Funktion, die oft als ReLU (Rectified Linear Unit) bezeichnet wird. Sie ist eine der beliebtesten Aktivierungsfunktionen in der Praxis, da sie einfach zu berechnen und zu differenzieren ist und oft bessere Ergebnisse liefert als andere Funktionen.

Die anderen Funktionen sind ebenfalls praxistauglich, da sie differenzierbar sind und keine unendlichen Werte annehmen. Allerdings sind sie möglicherweise nicht so effektiv wie ReLU oder andere Funktionen.

Daher sind die richtigen Antworten:

1. wahr
2. wahr
3. wahr
4. wahr





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




Answer to Question 2-5


Die folgenden Ansätze können overfitting reduzieren:
- Data augmentation (wahr)
- Dropout (wahr)
- Batch normalization (wahr)
- Benutzung von Adam anstelle von SGD (falsch)





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




Answer to Question 2-6


Die Antwort ist:

Der Gradient wird sich im Betrag verringern, die Polarität erhalten bleiben.





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




Answer to Question 3-1


a) Die Bedingung, dass der attention layer $l$ head $h$ am meisten zu der Position $n$ attended, ist, dass die Query $Q^{l, h}$ am meisten mit dem Key $K^{l, h}$ an der Position $n$ \*übereinstimmt\*.

b) Der self-attention Mechanismus benötigt die Multi-Head-Attention-Schicht, um diese Aufgabe für beliebige Eingabesequenzen erfüllen zu können. Diese Schicht ermöglicht es, die Aufmerksamkeit auf mehrere Positionen gleichzeitig zu richten und somit die Beziehungen zwischen den verschiedenen Teilen der Eingabesequenz besser zu verstehen.





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




Answer to Question 3-2


a) Die Bedingung, die im Dekodierungsschritt $n+1$ erfüllt sein muss, damit beim Greedy Decoding $t_{k+1}$ als nächstes Token prädiziert wird, ist, dass $t_{k+1}$ der höchstwertige Score hat, der durch den Dekoder berechnet wird. Dieser Score wird durch die Softmax-Funktion berechnet, die auf den Logits berechnet wird, die durch den Dekoder für jedes mögliche nächste Token erzeugt werden.

b) Die Bedingung, die im Dekodierungsschritt $n+1$ erfüllt sein muss, damit der Attention Layer $l$ Head $h$ am meisten zu der Position $k+1$ attended, ist, dass der Score für die Position $k+1$ der höchstwertige Score ist, der durch den Attention Layer berechnet wird. Dieser Score wird durch die Softmax-Funktion berechnet, die auf den Logits berechnet wird, die durch den Attention Layer für jede Position in der Eingabesequenz erzeugt werden.

c) Ein Transformer-Modell mit nur einem Attention Layer kann diese Bedingung nicht für beliebige Sequenzen und beliebige $k < n$ mit $t_k = t_n$ erfüllen. Der Grund dafür ist, dass ein einzelner Attention Layer nur Zugriff auf lokale Kontexte hat und nicht in der Lage ist, globale Abhängigkeiten in der Eingabesequenz zu erfassen.

d) Im Transformer ist der Kommunikationskanal um Information von einem Attention Head zu einem anderen Attention Head im gleichen Layer weiterzugeben die Eingabe der Self-Attention Schicht. Der Query-Tensor ist der Teil der Self-Attention, der entscheidet, was in den Kommunikationskanal geschrieben wird, und der Key-Tensor ist der Teil der Self-Attention, der entscheidet, was aus dem Kommunikationskanal gelesen wird. Im aufeinanderfolgenden Layer wird die Information durch den Value-Tensor weitergegeben.

e) Eine mögliche Sequenz von Self-Attention Operationen, die sicherstellt, dass der Attention Head $h$ in Layer $l > 1$ für beliebige Sequenzen zu Position $k+1$ attended (gegeben $t_k = t_n$), ist wie folgt:

1. Im ersten Layer wird die Self-Attention so konfiguriert, dass sie Informationen über die Positionen in der Nähe von $k$ sammelt und diese Informationen in den Query-Tensor schreibt.
2. Im zweiten Layer wird die Self-Attention so konfiguriert, dass sie Informationen über die Positionen in der Nähe von $n$ sammelt und diese Informationen in den Key-Tensor schreibt.
3. Im dritten Layer wird die Self-Attention so konfiguriert, dass sie Informationen über die Positionen in der Nähe von $k+1$ sammelt und diese Informationen in den Value-Tensor schreibt.

Dadurch wird sichergestellt, dass der Attention Head $h$ im dritten Layer zu Position $k+1$ attended, da er durch den Query-Tensor Zugriff auf Informationen über die Positionen in der Nähe von $k$ hat, durch den Key-Tensor Zugriff auf Informationen über die Positionen in der Nähe von $n$ hat und durch den Value-Tensor Zugriff auf Informationen über die Positionen in der Nähe von $k+1$ hat.





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




Answer to Question 4-1


Die vektorielle Eingabe für das i-te Vokabularwort $s_k$ ist ein One-Hot-Vektor, der die Länge des Vokabulars $|V|$ hat und an der Stelle $i$ eine 1 und sonst nur Nullen enthält. Dieser One-Hot-Vektor wird mit der i-ten Spalte der word embedding Matrix $W_E$ multipliziert, die die vektorielle Repräsentation des i-ten Vokabularworts enthält.





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




Answer to Question 4-2


a) Die Abbildung g muss differenzierbar sein, damit der Gradientenabstieg durchgeführt werden kann.

b) Der Gradient l bezüglich W\_E ist:

∇l = ∇l * ∇W\_E

Mit der Kettenregel:

∇l = ∇l * (∇g \* ∇E(w))

Der Gradient ∂g/∂E(w) ist der einzige übriggebliebene partielle Gradiententerm.

c) Der Gradient ∂l/∂w\_{ij} für i ≠ k ist 0, da die Eingabeworte unabhängig voneinander sind.

d) Die Erkenntnis aus Aufgabenteil (
ef{ex:gradient_input_word_i}) hat keine direkte Auswirkung auf die Speicher- und Berechnungskomplexität des Forward- und Backward-Passes, da die Größe der Eingabesequenz unverändert bleibt. Allerdings kann es die Implementierung des Backward-Passes vereinfachen, da der Gradient für ein Eingabewort unabhängig von den anderen Eingabeworten berechnet werden kann.





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




