Advanced Deep Learning - Exam

Aufgabe 1)

Kontext: In Convolutional Neural Networks (CNNs) spielen Faltungsmathematik und verschiedene Techniken wie Stride und Padding eine wesentliche Rolle bei der Reduzierung der Dimensionsgröße und Mustererkennung. Ein grundlegendes Verständnis dieser Konzepte ist entscheidend für den Aufbau und das Training leistungsstarker neuronaler Netze.

a)

Angenommen, Du hast eine Eingabematrix der Größe 7x7 und einen Faltungskern (Filter) der Größe 3x3.

• Erkläre, wie das Konzept der diskreten Faltung auf diese Matrizen angewendet wird. Veranschauliche dabei den Faltungsprozess für die oberen linken 3x3 des Eingabebereichs.
• Rechne die Faltungsergebnisse für eine vollständige Verschiebung des Kerns über die Eingabematrix ohne Padding und mit einem Stride von 1. Zeige alle Schritte und Zwischenresultate auf.

Lösung:

Kontext: In Convolutional Neural Networks (CNNs) spielen Faltungsmathematik und verschiedene Techniken wie Stride und Padding eine wesentliche Rolle bei der Reduzierung der Dimensionsgröße und Mustererkennung. Ein grundlegendes Verständnis dieser Konzepte ist entscheidend für den Aufbau und das Training leistungsstarker neuronaler Netze.

Angenommen, Du hast eine Eingabematrix der Größe 7x7 und einen Faltungskern (Filter) der Größe 3x3.

• Erkläre, wie das Konzept der diskreten Faltung auf diese Matrizen angewendet wird. Veranschauliche dabei den Faltungsprozess für die oberen linken 3x3 des Eingabebereichs.
• Rechne die Faltungsergebnisse für eine vollständige Verschiebung des Kerns über die Eingabematrix ohne Padding und mit einem Stride von 1. Zeige alle Schritte und Zwischenresultate auf.

Erklärung des Faltungskonzepts: Die diskrete Faltung wird verwendet, um Muster in einer Eingabematrix zu erkennen, indem ein Faltungskern systematisch über die Eingabematrix bewegt wird. Bei jedem Schritt wird ein dot-Produkt zwischen dem Kern und einem Teil der Eingabematrix berechnet. Dieses dot-Produkt wird als Wert in der entsprechenden Position der Ausgabematrix gespeichert.

Veranschaulichung des Faltungsprozesses für die oberen linken 3x3 des Eingabebereichs: Angenommen, die obere linke 3x3-Matrix des Eingabebereichs sieht wie folgt aus:

[2 0 1][1 3 2][0 1 1]

Und der 3x3-Kern sieht wie folgt aus:

[1 0 2][2 3 0][1 0 1]

Der Faltungsprozess für diese beiden Matrizen umfasst die Berechnung des dot-Produkts:

2*1 + 0*0 + 1*2 + 1*2 + 3*3 + 2*0 + 0*1 + 1*0 + 1*1 = 2 + 0 + 2 + 2 + 9 + 0 + 0 + 0 + 1 = 16

Also ist das Ergebnis der Faltung der oberen linken 3x3-Matrix mit dem Kern 16.

Faltungsergebnisse für eine vollständige Verschiebung des Kerns über die Eingabematrix ohne Padding und mit einem Stride von 1:

Angenommen die gesamte 7x7-Eingabematrix sieht wie folgt aus:

[2 0 1 3 2 1 0][1 3 2 1 0 1 2][0 1 1 3 2 0 1][1 2 3 0 1 1 0][0 1 3 2 1 0 2][1 2 0 1 3 2 1][1 0 1 2 1 0 0]

Der Filterkern bleibt derselbe:

[1 0 2][2 3 0][1 0 1]

Um den Faltungsprozess für die gesamte Eingabematrix durchzuführen, wird der Kern mit einem Stride von 1 über die Eingabematrix verschoben. Hier sind die Berechnungen für jede Position:

[2 0 1]   [0 1 3]   [1 3 2]   [0 1 2]   [1 2 1][1 3 2]   [3 2 1]   [2 1 0]   [1 0 1]   [2 1 0][0 1 1]   [1 1 3]   [1 3 2]   [3 2 0]   [2 0 1]

berechnet wie der linkeste Faltungsprozess. Naechste 6 Ergebnisse:

16 -...-... Deine Textformel hier. 

b)

Stelle Dir vor, Du implementierst ein Convolutional Neural Network.

• Erkläre mathematisch, wie die Eigenschaften der Linearität, Kommutativität und Assoziativität in der Faltung genutzt werden können, um die Berechnungen innerhalb des Netzwerkes zu optimieren. Nenne Beispiele und führe entsprechende Formeln und Gleichungen an.
• Beschreibe, wie Stride und Padding die Ausgangsgröße einer Faltung beeinflussen. Berechne die Ausgangsgrößen für die Fallbeispiele: Eingabematrix 7x7, Filter 3x3, Padding = 1, Stride = 2.

Lösung:

Kontext: In Convolutional Neural Networks (CNNs) spielen Faltungsmathematik und verschiedene Techniken wie Stride und Padding eine wesentliche Rolle bei der Reduzierung der Dimensionsgröße und Mustererkennung. Ein grundlegendes Verständnis dieser Konzepte ist entscheidend für den Aufbau und das Training leistungsstarker neuronaler Netze.

Stelle Dir vor, Du implementierst ein Convolutional Neural Network.

• Erkläre mathematisch, wie die Eigenschaften der Linearität, Kommutativität und Assoziativität in der Faltung genutzt werden können, um die Berechnungen innerhalb des Netzwerkes zu optimieren. Nenne Beispiele und führe entsprechende Formeln und Gleichungen an.
• Beschreibe, wie Stride und Padding die Ausgangsgröße einer Faltung beeinflussen. Berechne die Ausgangsgrößen für die Fallbeispiele: Eingabematrix 7x7, Filter 3x3, Padding = 1, Stride = 2.

Mathematische Eigenschaften der Faltung:

• Linearität:Die Linearität der Faltung besagt, dass die Faltung einer linearen Kombination von Funktionen gleich der linearer Kombination der Faltungen dieser Funktionen ist:
\[ \text{Faltung}(a \text{Input}_1 + b \text{Input}_2) = a \text{Faltung}(\text{Input}_1) + b \text{Faltung}(\text{Input}_2) \]Hierbei sind a und b Konstanten. Diese Eigenschaft ist nützlich, weil sie es ermöglicht, Berechnungen zu skalieren und aufteilen.

• Kommutativität:Die Kommutativität der Faltung besagt, dass die Reihenfolge, in der zwei Funktionen gefaltet werden, keinen Unterschied macht:
\[ \text{Input} \bigast \text{Kern} = \text{Kern} \bigast \text{Input} \]Diese Eigenschaft kann zur Verbesserung der Berechnungseffizienz verwendet werden, indem man die Reihenfolge der Operationen innerhalb eines Netzwerks ändert.

• Assoziativität:Die Assoziativität der Faltung besagt, dass das Falten einer Funktion mit der Faltung zweier anderer Funktionen gleich der Faltung der Funktion mit der kombinierten Faltung der beiden Funktionen ist:
\[ \text{Input} \bigast (\text{Kern}_1 \bigast \text{Kern}_2) = (\text{Input} \bigast \text{Kern}_1) \bigast \text{Kern}_2 \]Diese Eigenschaft kann genutzt werden, um mehrstufige Faltungen zu berechnen, indem sie zu einer einzigen Faltung zusammengefasst werden.

Durch Ausnutzung dieser Eigenschaften können wir Schritte in der Faltungsberechnung umordnen oder kombinieren, um die Berechnungen zu optimieren, was in der Praxis zu schnelleren Berechnungszeiten führen kann.

Effekt von Stride und Padding auf die Ausgangsgröße einer Faltung:

Die Ausgangsgröße einer Faltung wird durch die Größe der Eingabematrix, die Größe des Filters (Kerns), die Menge des Paddings und den Stride bestimmt. Mathematisch wird das wie folgt berechnet:

• Formel für die Ausgangsgröße:
\[ \text{Ausgangsgröße} = \frac{\text{Eingabematrix-Größe} - \text{Filter-Größe} + 2 \times \text{Padding}}{\text{Stride}} + 1 \]

• Für das Fallbeispiel Eingabematrix 7x7, Filter 3x3, Padding = 1, Stride = 2:
\[ \text{Horizontale Ausgangsgröße} = \text{Vertikale Ausgangsgröße} \]\[ = \frac{7 - 3 + 2 \times 1}{2} + 1 \]\[ = \frac{7 - 3 + 2}{2} + 1 \]\[ = \frac{6}{2} + 1 \]\[ = 3 + 1 \]\[ = 4 \]

Das bedeutet, dass die endgültige Ausgangsgröße für dieses Beispiel 4x4 ist.

Aufgabe 2)

Gegeben sind zwei häufig verwendete rekurrente neuronale Netzwerkarchitekturen: LSTM (Long Short-Term Memory) und GRU (Gated Recurrent Unit). Beide Architekturen sollen Langzeitabhängigkeiten in sequentiellen Daten lernen und das Vanishing-Gradient-Problem reduzieren. Die Hauptgleichungen für das LSTM und das GRU-Netzwerk sind wie folgt gegeben:

• LSTM Hauptgleichungen: \[ i_t = \text{sigmoid}(W_i x_t + U_i h_{t-1} + b_i) \] \[ f_t = \text{sigmoid}(W_f x_t + U_f h_{t-1} + b_f) \] \[ o_t = \text{sigmoid}(W_o x_t + U_o h_{t-1} + b_o) \] \[ c_t = f_t \times c_{t-1} + i_t \times \text{tanh}(W_c x_t + U_c h_{t-1} + b_c) \] \[ h_t = o_t \times \text{tanh}(c_t) \]
• GRU Hauptgleichungen: \[ z_t = \text{sigmoid}(W_z x_t + U_z h_{t-1}) \] \[ r_t = \text{sigmoid}(W_r x_t + U_r h_{t-1}) \] \[ \tilde{h}_t = \text{tanh}(W_h x_t + U_h (r_t \times h_{t-1})) \] \[ h_t = (1 - z_t) \times h_{t-1} + z_t \times \tilde{h}_t \]

a)

Betrachtet das folgende LSTM-Modell:

import torch import torch.nn as nn # Definiere eine einfache LSTM Klasse class SimpleLSTM(nn.Module):  def __init__(self, input_dim, hidden_dim, output_dim):  super(SimpleLSTM, self).__init__()  self.hidden_dim = hidden_dim  self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)  self.linear = nn.Linear(hidden_dim, output_dim)   def forward(self, x):  h0 = torch.zeros(1, x.size(0), self.hidden_dim)  c0 = torch.zeros(1, x.size(0), self.hidden_dim)  out, _ = self.lstm(x, (h0, c0))  out = out[:, -1, :]  out = self.linear(out)  return out  # Initialisiere das Modell model = SimpleLSTM(input_dim=10, hidden_dim=20, output_dim=1) # Beispiel Ein- und Ausgabe x_example = torch.randn(5, 10, 10) output = model(x_example) 

Erkläre die Hauptaufgaben der LSTM-Gleichungen in Bezug auf das oben definierte Modell. Berechne explizit die Eingang-, Ausgaben- und Aktivierungsfunktionen der einzelnen LSTM-Gleichungen.

Lösung:

Erläuterung der Hauptaufgaben der LSTM-Gleichungen im definierten Modell

Das oben definierte Modell verwendet ein einfaches LSTM, um sequentielle Eingabedaten (hier eine Tensor-Repräsentation der Daten) zu verarbeiten und basierend auf den erlernten Langzeitabhängigkeiten eine Ausgabe zu erzeugen. Die Grundidee besteht darin, dass das LSTM in der Lage ist, Langzeitabhängigkeiten zu lernen und das Vanishing-Gradient-Problem zu vermeiden.

• Input-Gate Gleichung:Formel: \[ i_t = \text{sigmoid}(W_i x_t + U_i h_{t-1} + b_i) \]Der Input-Gate \( i_t \) bestimmt, wie viel der neuen Informationen aus dem aktuellen Eingangsvektor \( x_t \) in die Zellen des Speichers \( c_t \) fließen sollen. Es wird eine Sigmoid-Aktivierungsfunktion verwendet, um die Werte zu skalieren.
• Forget-Gate Gleichung:Formel: \[ f_t = \text{sigmoid}(W_f x_t + U_f h_{t-1} + b_f) \]Das Forget-Gate \( f_t \) bestimmt, wie viel der bisherigen Informationen in \( c_{t-1} \) behalten werden sollen. Auch hier wird eine Sigmoid-Aktivierungsfunktion verwendet.
• Output-Gate Gleichung:Formel: \[ o_t = \text{sigmoid}(W_o x_t + U_o h_{t-1} + b_o) \]Das Output-Gate \( o_t \) bestimmt, wie viel der Zellinformationen in die neue verborgene Zustandsvorlage \( h_t \) fließen sollen. Dies wird erneut mit einer Sigmoid-Aktivierungsfunktion hergestellt.
• Zustandsaktualisierung:Formel: \[ c_t = f_t \times c_{t-1} + i_t \times \text{tanh}(W_c x_t + U_c h_{t-1} + b_c) \]Hier wird der Zellzustand \( c_t \) mit Hilfe der neuen Eingangs- und Vergessensinformationen aktualisiert. Eine Tanh-Aktivierungsfunktion wird auf den neuen Kandidatenwert \( \text{tanh}(W_c x_t + U_c h_{t-1} + b_c) \) angewendet.
• Aktualisierung des versteckten Zustands:Formel: \[ h_t = o_t \times \text{tanh}(c_t) \]Der aktualisierte versteckte Zustand \( h_t \) wird durch das Produkt aus der Output-Gate-Information und der Tanh-Aktivierung des neuen Zellzustands \( c_t \) berechnet.

Berechnung und Implementierung:

import torchimport torch.nn as nn# Definiere eine einfache LSTM Klasseclass SimpleLSTM(nn.Module):    def __init__(self, input_dim, hidden_dim, output_dim):        super(SimpleLSTM, self).__init__()        self.hidden_dim = hidden_dim        self.lstm = nn.LSTM(input_dim, hidden_dim, batch_first=True)        self.linear = nn.Linear(hidden_dim, output_dim)    def forward(self, x):        # Initialisierte den versteckten Zustand und den Zellzustand        h0 = torch.zeros(1, x.size(0), self.hidden_dim)        c0 = torch.zeros(1, x.size(0), self.hidden_dim)        # Gewinne die LSTM-Ausgabe inklusive des neuen Zellzustands        out, _ = self.lstm(x, (h0, c0))        # Verarbeite nur die letzte Ausgabe des LSTM        out = out[:, -1, :]        # Lineares Mapping zur endgültigen Ausgabe        out = self.linear(out)        return out# Initialisiere das Modellmodel = SimpleLSTM(input_dim=10, hidden_dim=20, output_dim=1)# Beispiel Ein- und Ausgabex_example = torch.randn(5, 10, 10)output = model(x_example)

Das Modell führt die oben beschriebenen Gleichungen schrittweise aus, um die Ausgabe zu berechnen. Die wichtigste Arbeit erfolgt innerhalb des LSTM-Layers, der diese Gleichungen automatisch implementiert und aktualisiert.

b)

In einer Textvorhersageaufgabe wurde ein GRU-Modell wie folgt implementiert:

import torch import torch.nn as nn # Definiere eine einfache GRU Klasse class SimpleGRU(nn.Module):  def __init__(self, input_dim, hidden_dim, output_dim):  super(SimpleGRU, self).__init__()  self.hidden_dim = hidden_dim  self.gru = nn.GRU(input_dim, hidden_dim, batch_first=True)  self.linear = nn.Linear(hidden_dim, output_dim)   def forward(self, x):  h0 = torch.zeros(1, x.size(0), self.hidden_dim)  out, _ = self.gru(x, h0)  out = out[:, -1, :]  out = self.linear(out)  return out  # Initialisiere das Modell model = SimpleGRU(input_dim=10, hidden_dim=20, output_dim=1) # Beispiel Ein- und Ausgabe x_example = torch.randn(5, 10, 10) output = model(x_example) 

Basierend auf dem Modell und den gegebenen Hauptgleichungen des GRU, analysiere die Funktionsweise des GRU-Modells. Vergleiche die Ausdruckskraft und Vorteile des GRUs gegenüber LSTMs in der Textvorhersageaufgabe. Nutze mathematische Gleichungen und begründe Deine Aussagen.

Lösung:

Analyse der Funktionsweise des GRU-Modells

Das vorgegebene GRU-Modell verwendet eine Gated Recurrent Unit (GRU) Architektur, um sequentielle Eingabedaten in einem Textvorhersagekontext zu verarbeiten. Der Netzwerkaufbau soll Langzeitabhängigkeiten in den Textdaten erkennen und verwerten. Im Folgenden beschreiben wir die Arbeitsweise des GRU-Modells im Detail und vergleichen seine Vorteile gegenüber dem LSTM-Modell.

Die Hauptgleichungen des GRU-Modells lauten:

• Update-Gate Gleichung:Formel: \( z_t = \text{sigmoid}(W_z x_t + U_z h_{t-1}) \)Das Update-Gate \( z_t \) entscheidet, wie viel des vorherigen Zustands \( h_{t-1} \) beibehalten werden soll und wie viel durch den neuen Zustandskandidaten ersetzt wird.
• Reset-Gate Gleichung:Formel: \( r_t = \text{sigmoid}(W_r x_t + U_r h_{t-1}) \)Das Reset-Gate \( r_t \) bestimmt, wie sehr die vorherigen Informationen für das Erzeugen des neuen Zustandswerte \( \tilde{h}_t \) zurückgesetzt werden sollen.
• Neuer Kandidatenzustand:Formel: \( \tilde{h}_t = \text{tanh}(W_h x_t + U_h (r_t \times h_{t-1})) \)Der neue Kandidatenzustand \( \tilde{h}_t \) wird durch die Aktivierung des aktuellen Inputs \( x_t \) und den durch das Reset-Gate bestimmten vorherigen Zustand \( r_t \times h_{t-1} \) berechnet.
• Aktualisierung des verborgenen Zustands:Formel: \( h_t = (1 - z_t) \times h_{t-1} + z_t \times \tilde{h}_t \)Der neue verborgene Zustand \( h_t \) ist eine lineare Kombination aus dem vorherigen Zustand \( h_{t-1} \) und dem neuen Kandidatenzustand \( \tilde{h}_t \), gewichtet durch das Update-Gate \( z_t \).

Implementierung im Code:

import torchimport torch.nn as nn# Definiere eine einfache GRU Klasseclass SimpleGRU(nn.Module):    def __init__(self, input_dim, hidden_dim, output_dim):        super(SimpleGRU, self).__init__()        self.hidden_dim = hidden_dim        self.gru = nn.GRU(input_dim, hidden_dim, batch_first=True)        self.linear = nn.Linear(hidden_dim, output_dim)    def forward(self, x):        # Initialisiere den versteckten Zustand        h0 = torch.zeros(1, x.size(0), self.hidden_dim)        out, _ = self.gru(x, h0)        # Verarbeite nur die letzte Ausgabe des GRU        out = out[:, -1, :]        # Lineares Mapping zur endgültigen Ausgabe        out = self.linear(out)        return out# Initialisiere das Modellmodel = SimpleGRU(input_dim=10, hidden_dim=20, output_dim=1)# Beispiel Ein- und Ausgabex_example = torch.randn(5, 10, 10)output = model(x_example)

Vergleich: GRU vs. LSTM

Beide Architekturen, GRU und LSTM, sind darauf ausgelegt, Langzeitabhängigkeiten zu lernen und das Vanishing-Gradient-Problem zu mildern. Hier sind einige Vergleiche bezüglich ihrer Ausdruckskraft und spezifischen Vorteile in der Textvorhersageaufgabe:

• Modelkomplexität:GRUs haben weniger Parameter als LSTMs, da sie keine separaten Zellzustände haben. Das führt zu geringerem Speicherbedarf und schnelleren Trainingszeiten.
• Training und Konvergenz:GRUs konvergieren in der Regel schneller als LSTMs und können in bestimmten Aufgaben effizienter lernen, insbesondere wenn die Trainingsdatensätze kleiner oder weniger komplex sind.
• Ableitung der Zellzustandskomplexität:LSTMs haben getrennte Zellzustands- und Output-Gates (i_t, f_t, o_t und c_t), wodurch sie unter Umständen besser in der Lage sind, spezifische Langzeitabhängigkeiten zu modifizieren und zu lernen. Dies kann bei sehr langen und komplexen sequentiellen Daten von Vorteil sein.

In der Textvorhersageaufgabe kann ein GRU-Modell möglicherweise schneller gute Ergebnisse erzielen, insbesondere bei umfangreichen Datensätzen, aufgrund der geringeren Modellkomplexität. Ein LSTM-Modell könnte jedoch bei komplizierteren Texten, die feinere Langzeitabhängigkeiten enthalten, besser performen, aufgrund der expliziteren Zellzustandsverwaltung.

Aufgabe 3)

Minimax-Spiel und Trainingsverfahren von GANsGenerative Adversarial Networks (GANs) bestehen aus zwei sich gegenseitig herausfordernden Modellen: einem Generator (G), der versucht, Daten zu generieren, die von echten Daten nicht zu unterscheiden sind, und einem Diskriminator (D), der versucht, echte von generierten Daten zu unterscheiden. Der Trainingsprozess von GANs wird als ein Minimax-Spiel formuliert, bei dem G und D gegeneinander konkurrieren. Die Zielsetzung wird durch das Minimax-Ziel beschrieben: \(\min_G \max_D V(D, G)\). Um das Training zu stabilisieren und zu optimieren, können Anpassungen wie Batch-Normalisierung und spezifische Varianten wie Wasserstein-GANs angewendet werden. Ein typisches Verfahren beinhaltet das abwechselnde Trainieren von G und D.\

\
• GANs bestehen aus einem Generator (G) und einem Diskriminator (D).
\
• G: erzeugt Daten, um D zu täuschen.
\
• D: unterscheidet zwischen echten und generierten Daten.
\
• Minimax-Ziel: \(\min_G \max_D V(D, G)\)
\
• Loss-Funktionen:
\
• Anpassungen für Training: z.B. Batch-Normalisierung, Wasserstein-GANs.
\
• Optimierung: Abwechselnd G und D trainieren.
\

a)

Teil A: Angenommen, das Minimax-Ziel eines GANs ist gegeben durch \(\min_G \max_D V(D, G)\), wobei die Zielfunktion \(V(D, G)\) wie folgt definiert ist: \[V(D, G) = \mathbb{E}_{\text{x} \thicksim p_\text{data}(x)}[\log D(x)] + \mathbb{E}_{\text{z} \thicksim p_\text{z}(z)}[\log (1 - D(G(z)))]\] Zeige, dass das Minimax-Spiel eines GANs die optimale Lösung für \(D\) erreicht, wenn \(D(x) = \frac{p_\text{data}(x)}{p_\text{data}(x) + p_\text{G}(x)}\), wobei \(p_\text{data}(x)\) die Wahrscheinlichkeitsverteilung echter Daten und \(p_\text{G}(x)\) die Wahrscheinlichkeitsverteilung generierter Daten beschreibt.

Lösung:

Teil A: Um zu zeigen, dass das Minimax-Spiel eines GANs die optimale Lösung für den Diskriminator (\textit{D}) erreicht, wenn \textit{D(x)} die Form \textit{ \frac{p_\text{data}(x)}{p_\text{data}(x) + p_\text{G}(x)} } hat, folgen wir den folgenden Schritten: Schritt 1: Zielfunktion des DiskriminatorsSchreiben wir die Zielfunktion \textit{V(D, G)} des Diskriminators auf:

• V(D, G) = \mathbb{E}_{x \sim p_\text{data}(x)}[\text{log } D(x)] + \mathbb{E}_{z \sim p_\text{z}(z)}[\text{log } (1 - D(G(z)))]

Schritt 2: Bedingungen für das OptimumDer Diskriminator \textit{D(x)} wird optimal, wenn die Zielfunktion maximiert ist. Dazu setzen wir den Gradienten der Zielfunktion bezüglich \textit{D(x)} gleich null.Betrachten wir den Ausdruck \textit{V(D,G)} unter der Annahme, dass \textit{G} fest ist:

• V(D, G) = \int_{x} \left[ p_{data}(x) \log D(x) + p_\text{G}(x) \log (1 - D(x)) \right] \text{d}x

Schritt 3: Ableitung bildenBilden wir die Ableitung von \textit{V(D, G)} nach \textit{D(x)}:

\frac{\text{d}V}{\text{d}D(x)} = \left[ \frac{p_\text{data}(x)}{D(x)} - \frac{p_\text{G}(x)}{1 - D(x)} \right] = 0

Durch Vereinfachen erhalten wir:

p_\text{data}(x) \left(1 - D(x)\right) = p_\text{G}(x) D(x)

Schritt 4: D(x) isolierenIsolieren wir D(x):

p_\text{data}(x) = D(x) \left(p_\text{data}(x) + p_\text{G}(x)\right) \Rightarrow D(x) = \frac{p_\text{data}(x)}{p_\text{data}(x) + p_\text{G}(x)}

Schlussfolgerung:Wir haben gezeigt, dass der Diskriminator \textit{D} die optimale Lösung erreicht, wenn:

• D(x) = \frac{p_\text{data}(x)}{p_\text{data}(x) + p_\text{G}(x)}

b)

Teil B: Beschreibe den Trainingsprozess eines Wasserstein-GANs (WGAN). Erkläre, wie die Wasserstein-Distanz den GAN-Training stabilisiert und weshalb die Gewichtsklippung bzw. die Einführung von Gewichtsschranken notwendig ist. Beschreibe zusätzlich, was bei WGAN anstelle der herkömmlichen Minimax-Zielfunktion verwendet wird.

Lösung:

Teil B: Der Trainingsprozess eines Wasserstein-GANs (WGAN) unterscheidet sich in mehreren wesentlichen Punkten von dem eines herkömmlichen GANs. Im Folgenden beschreibe ich die Schlüsselkonzepte und Schritte im Trainingsprozess eines WGAN und erkläre, warum diese Modifikationen notwendig sind.Trainingsprozess eines WGAN:

• Ein Wasserstein-GAN besteht ebenfalls aus einem Generator (\textit{G}) und einem Diskriminator (genannt 'Kritiker', \textit{D}).
• Der Kritiker \textit{D} approximiert keine Wahrscheinlichkeit mehr, sondern bewertet die 'Erdbewegungskosten' der Verteilung der generierten Daten relativ zu den echten Daten unter Verwendung einer sogenannten Wasserstein-Distanz.

Wasserstein-Distanz:

• Die Wasserstein-Distanz, auch Monge-Kantorovich-Distanz genannt, ist eine Metrik, die die Differenz zwischen zwei Verteilungen \(p_{data}(x)\) und \(p_{G}(x)\) misst. Sie wird so berechnet, dass sie die 'Mindestkosten', also die minimalen Erdbewegungskosten, darstellt, um eine Verteilung in eine andere zu überführen.
• Im Vergleich zur Jensen-Shannon-Divergenz, die in regulären GANs verwendet wird, bietet die Wasserstein-Distanz den Vorteil, dass sie selbst dann aussagekräftig ist, wenn sich die Unterstützung der beiden Verteilungen kaum überschneidet.
• Dies führt zu einem stabileren Trainingsprozess, der leichter zu optimieren ist, da der Gradient der Wasserstein-Distanz sinnvoll ist und realistische Werte liefert.

Gewichtsklippung:

• Um sicherzustellen, dass der Kritiker 1-Lipschitz-beschränkt bleibt (eine Bedingung für die Wasserstein-Distanz), müssen die Gewichte des Kritikers nach jeder Optimierungsschritt durch Clipping an einem festen Intervall gehalten werden, z.B. auf \([-c, c]\), wobei \textit{c} ein kleiner konstanter Wert ist.
• Dadurch werden die Gewichte des Kritikers innerhalb eines begrenzten Bereichs gehalten, was sicherstellt, dass die Lipschitz-Stetigkeitsbedingung eingehalten wird.
• Diese Maßnahme ist notwendig, um übermäßiges Wachstum der Gewichtswerte zu verhindern, das zu unkontrolliertem Verhalten und Fehlern im Training führen könnte.

Zielfunktion von WGAN:

• Anstelle der herkömmlichen Minimax-Zielfunktion verwendet ein WGAN die folgende Zielfunktion:

• Für den Kritiker (\textit{D}):
• \[V(D, G) = \mathbb{E}_{x \sim p_{data}(x)}[D(x)] - \mathbb{E}_{z \sim p_{z}(z)}[D(G(z))]\]

• Für den Generator (\textit{G}):
• \[\min_G V(D, G) = - \mathbb{E}_{z \sim p_{z}(z)}[D(G(z))]\]

• Der Kritiker wird so trainiert, dass er die Wasserstein-Distanz zwischen den echten und den generierten Daten maximiert, wohingegen der Generator trainiert wird, diese Distanz zu minimieren.

Optimierung:

• Der Trainingsprozess erfolgt abwechselnd, indem zuerst der Kritiker mehrere Male (z.B. 5 mal) aktualisiert wird, während der Generator nur einmal aktualisiert wird. Dies führt dazu, dass der Kritiker stabile und sinnvolle Gradienten für den Generator liefert.

Zusammengefasst stabilisiert die Anwendung der Wasserstein-Distanz das Training von GANs und die Einführung einer Gewichtsklippung hält den Kritiker in den Lipschitz-Beschränkungen. Dies ergibt zusammen einen robusteren und effizienteren Trainingsprozess als bei herkömmlichen GANs.

Aufgabe 4)

Betrachte das Q-Learning und Deep Q-Networks (DQN) Verfahren. Q-Learning ist ein modelfreies Reinforcement-Learning-Verfahren zur Bestimmung der optimalen Aktionsauswahlspolitik mittels der Q-Funktion. Deep Q-Networks erweitern Q-Learning durch die Verwendung von neuronalen Netzen, speziell von Convolutional Neural Networks (CNNs), zur Approximation der Q-Funktion.

• Die Aktualisierungsformel für Q-Learning ist gegeben durch:
• Die Bellman-Gleichung lautet:
• DQN kombiniert Q-Learning mit neuronalen Netzen für die Werte-Funktions-Approximation in hochdimensionalen Zustandsräumen.
• Zur Stabilisierung des Lernprozesses wird Replay-Memory verwendet.
• Um Korrelationen während des Trainings zu reduzieren, wird ein Target-Netzwerk eingesetzt.