Deep Learning - Exam

Aufgabe 1)

Grundkonzepte von Neuronen und Schichten:In neuronalen Netzen bestehen die Grundelemente aus Neuronen, die eine gewichtete Summation und eine Aktivierungsfunktion durchführen. Neuronale Netze sind in verschiedene Schichten unterteilt, die aus mehreren Neuronen bestehen. Diese Schichten lassen sich in Eingabeschicht, versteckte Schichten und Ausgabeschicht kategorisieren.

• Neuron: Ein Neuron berechnet eine gewichtete Summe \(z = \sum_{i} w_i x_i + b\) und gibt das Ergebnis durch eine Aktivierungsfunktion weiter \(a = \sigma(z)\)
• Gewichte (\(w\)) und Bias (\(b\)): Diese Parameter werden während des Trainings angepasst
• Aktivierungsfunktion (\(\sigma(z)\)): Führt eine Nichtlinearität ein, Beispiele sind ReLU, Sigmoid, Tanh
• Schichten (Layer): Neuronen werden zu Schichten zusammengefasst. Es gibt eine Eingabeschicht, mehrere versteckte Schichten und eine Ausgabeschicht.

a)

(a) Theorie:Erkläre den Unterschied zwischen einer Eingabeschicht, einer versteckten Schicht und einer Ausgabeschicht in einem neuronalen Netz. Warum sind multiple versteckte Schichten notwendig? Welche Rolle spielt die Aktivierungsfunktion in diesem Kontext?

Lösung:

(a) Theorie:Erkläre den Unterschied zwischen einer Eingabeschicht, einer versteckten Schicht und einer Ausgabeschicht in einem neuronalen Netz. Warum sind multiple versteckte Schichten notwendig? Welche Rolle spielt die Aktivierungsfunktion in diesem Kontext?

• Eingabeschicht: Die Eingabeschicht ist die erste Schicht in einem neuronalen Netz, die die Rohdaten direkt entgegen nimmt. Sie leitet diese Daten an die folgenden Schichten weiter. Die Neuronen in dieser Schicht entsprechen der Anzahl der Merkmale in den Eingabedaten.Beispiel: Für ein Bild mit einer Auflösung von 28x28 Pixel besitzt die Eingabeschicht 784 Neuronen (28 \times 28 = 784).
• Versteckte Schichten: Versteckte Schichten liegen zwischen der Eingabeschicht und der Ausgabeschicht. Diese Schichten enthalten die eigentlichen Berechnungen und Transformationen, die die Leistungsfähigkeit des neuronalen Netzes ausmachen. Jedes Neuron in einer versteckten Schicht erhält Inputs von der vorhergehenden Schicht und gibt Outputs an die nachfolgende Schicht weiter.Warum sind multiple versteckte Schichten notwendig?
  • Versteckte Schichten erlauben es dem neuronalen Netz, komplexe nichtlineare Zusammenhänge in den Daten zu erkennen. Einfache Modelle mit nur einer Schicht können oft nur lineare Beziehungen modellieren, während tiefere Netzwerke (d.h. Netzwerke mit mehreren versteckten Schichten) in der Lage sind, hierarchische und komplizierte Muster in den Daten zu lernen.
• Ausgabeschicht: Die Ausgabeschicht ist die letzte Schicht in einem neuronalen Netz. Sie liefert die endgültigen Ergebnisse oder Vorhersagen des Modells. Die Anzahl der Neuronen in der Ausgabeschicht hängt von der Art des Problems ab, z.B. hat sie für ein binäres Klassifikationsproblem nur ein Neuron.
• Aktivierungsfunktion (\(\sigma(z)\)): Die Aktivierungsfunktion führt eine Nichtlinearität in die Ausgabe eines Neurons ein. Ohne diese Funktion könnten neuronale Netze nur lineare Transformationen durchführen, was die Ausdruckskraft und die Fähigkeit, komplexe Muster zu lernen, stark einschränken würde.Beispielhafte Aktivierungsfunktionen:
  • ReLU (Rectified Linear Unit):\(\text{max}(0, z)\)
  • Sigmoid:\(\frac{1}{1 + e^{-z}}\)
  • Tanh (Hyperbolic Tangent):\(\frac{e^{z} - e^{-z}}{e^{z} + e^{-z}}\)
  Aktivierungsfunktionen ermöglichen es neuronalen Netzen, komplexe nichtlineare Muster zu modellieren und je nach Art der Funktion verschiedene Arten von Nichtlinearitäten einzuführen.

b)

(b) Praxis und Mathematik:Ein einfaches neuronales Netz besteht aus einem einzigen Neuron mit folgenden Parametern: Gewichte \(w = [0.5, -0.3]\), Bias \(b = 0.1\), und der Eingabewerte \(x = [1.2, 0.7]\). Verwende die Sigmoid-Funktion als Aktivierungsfunktion \(\sigma(z) = \frac{1}{1 + e^{-z}}\).

• Berechne den Linearkombinationswert \(z\) des Neurons.
• Berechne den Ausgabe-Wert \(a\) des Neurons unter Anwendung der Aktivierungsfunktion.

Lösung:

(b) Praxis und Mathematik:Ein einfaches neuronales Netz besteht aus einem einzigen Neuron mit folgenden Parametern: Gewichte \(w = [0.5, -0.3]\), Bias \(b = 0.1\), und der Eingabewerte \(x = [1.2, 0.7]\). Verwende die Sigmoid-Funktion als Aktivierungsfunktion \(\sigma(z) = \frac{1}{1 + e^{-z}}\).

• Berechne den Linearkombinationswert \(z\) des Neurons.
• Berechne den Ausgabe-Wert \(a\) des Neurons unter Anwendung der Aktivierungsfunktion.

• Berechnung des Linearkombinationswertes \(z\):Wir verwenden die Formel:\[z = \sum_{i} w_i x_i + b\]Setzen wir die gegebenen Werte ein:\[z = 0.5 \times 1.2 + (-0.3) \times 0.7 + 0.1\]Berechnen wir:\[z = 0.6 - 0.21 + 0.1 = 0.49\]
• Berechnung des Ausgabe-Wertes \(a\) unter Anwendung der Sigmoid-Funktion:Verwenden wir die Sigmoid-Funktion:\[a = \sigma(z) = \frac{1}{1 + e^{-z}}\]Setzen wir \(z = 0.49\) ein:\[a = \frac{1}{1 + e^{-0.49}}\]Berechnen wir:\[a \approx \frac{1}{1 + 0.613} \approx \frac{1}{1.613} \approx 0.620\]Daher ist der Ausgabe-Wert \(a\) des Neurons etwa 0.620.

Aufgabe 2)

Convolutional und Pooling Schichten extrahieren Merkmale durch Faltung. Pooling-Schichten reduzieren die räumliche Größe der Repräsentation.

a)

• Beschreibe detailliert den Prozess, wie ein Convolutional Layer Merkmale aus einem Eingabebild extrahiert. Verwende die Begriffe Filter/Kernels, Feature Maps und ReLU in deiner Erklärung.

Lösung:

Convolutional Layer Merkmale Extraktion

Ein Convolutional Layer ist ein wesentlicher Bestandteil in Convolutional Neural Networks (CNNs), um Merkmale aus einem Eingabebild zu extrahieren. Dieser Prozess läuft wie folgt ab:

• Filter/Kernels: Ein Convolutional Layer verwendet mehrere Filter (auch bekannt als Kernels), die kleine gewichtete Matrizen sind. Jeder Filter durchsucht das gesamte Eingabebild, indem er sich über das Bild bewegt. Dabei wird ein Filterwert mit einer entsprechenden Pixelwert multipliziert und die Produkte werden summiert.

• Convolution Operation: Dieser Schritt wird als Faltung (Convolution) bezeichnet. Die Faltung eines Filters mit einem Eingabebild erzeugt eine neue Matrix, die als Feature Map bezeichnet wird. Die Feature Map zeigt relevante Merkmale aus dem Eingabebild, die der Filter extrahiert hat. Beispielsweise kann ein Filter darauf trainiert sein, Kanten oder bestimmte Texturen zu erkennen.

• Feature Maps: Jeder Filter erzeugt eine eigene Feature Map. Diese Feature Maps enthalten Informationen über unterschiedliche Merkmale, die vom Eingabebild extrahiert wurden. Durch die Anwendung vieler verschiedener Filter können unterschiedliche Aspekte des Eingabebilds erfasst werden.

• ReLU: Nach der Faltung wird häufig eine Aktivierungsfunktion wie ReLU (Rectified Linear Unit) verwendet. ReLU setzt alle negativen Werte in der Feature Map auf null, was dazu beiträgt, nicht-lineare Eigenschaften des Modells zu berücksichtigen und die Rechenzeit zu verringern. Dies verbessert die Fähigkeit des Netzwerks, komplexere Muster zu lernen.

Durch Kombination dieser Schritte kann ein Convolutional Layer effiziente und verschiedene Merkmale aus einem Eingabebild extrahieren, die in tieferen Schichten des Netzwerks weiterverarbeitet werden können, um kompliziertere und abstraktere Merkmale zu lernen.

b)

• Angenommen, Du hast ein Eingabebild mit den Dimensionen 32 x 32 x 3 (Höhe x Breite x Kanäle) und Du verwendest eine Convolutional-Schicht mit 16 Filtern, einer Filtergröße von 3 x 3 und einem Stride von 1. Berechne die Dimensionen der resultierenden Feature Maps.

Lösung:

Berechnung der Dimensionen der Feature Maps nach der Convolutional-Schicht

Um die Dimensionen der resultierenden Feature Maps zu berechnen, können wir die folgenden Formeln verwenden:

• Die Höhe (Height) und Breite (Width) der Feature Map nach der Convolution-Schicht wird mit der Formel berechnet:

  • \( H_{out} = \frac{H_{in} - \text{Filterhöhe} + 2 \times \text{Padding}}{\text{Stride}} + 1 \)

  • \( W_{out} = \frac{W_{in} - \text{Filterbreite} + 2 \times \text{Padding}}{\text{Stride}} + 1 \)

Da wir keine Angabe zum Padding haben, setzen wir Padding = 0.

• Eingabedimensionen: Höhe (\(H_{in}\)) = 32, Breite (\(W_{in}\)) = 32, Kanäle = 3

• Filtergröße: 3 x 3

• Stride: 1

• Padding: 0

Berechnungen:

• Höhe der Feature Map (\(H_{out}\)):

  \( H_{out} = \frac{32 - 3 + 2 \times 0}{1} + 1 = \frac{29}{1} + 1 = 30 \)

• Breite der Feature Map (\(W_{out}\)):

  \( W_{out} = \frac{32 - 3 + 2 \times 0}{1} + 1 = \frac{29}{1} + 1 = 30 \)

• Anzahl der Kanäle:

  Die Anzahl der Kanäle entspricht der Anzahl der Filter, also 16.

Ergebnis:

Die Dimensionen der resultierenden Feature Maps sind 30 x 30 x 16.

c)

• Erkläre den Unterschied zwischen Max Pooling und Average Pooling. Welche Vorteile bietet Max Pooling gegenüber Average Pooling im Kontext der Verhinderung von Overfitting und der Reduktion des Rechenaufwands?

Lösung:

Unterschiede zwischen Max Pooling und Average Pooling

Pooling-Schichten werden häufig in Convolutional Neural Networks (CNNs) verwendet, um die räumliche Größe der Repräsentationen zu reduzieren und somit die Berechnungseffizienz zu verbessern. Es gibt zwei häufig verwendete Pooling-Methoden:

• Max Pooling: Beim Max Pooling wird das Maximum eines bestimmten Bereichs der Eingabematrix ausgewählt. Zum Beispiel, wenn ein 2x2-Fenster auf die Eingabematrix angewendet wird, ist der Ausgangswert das Maximum der vier Werte innerhalb dieses Fensters.

  Beispiel: Gegeben eine Eingabematrix 2x2:

   1  3  2  4 

  Das Resultat des Max Pooling wäre 4, da 4 der größte Wert ist.

• Average Pooling: Beim Average Pooling wird der Durchschnitt der Werte in einem bestimmten Bereich der Eingabematrix berechnet. Ein Fenster von beispielsweise 2x2 wird auf diesen Bereich angewendet und es wird der Durchschnitt der vier Werte berechnet.

  Beispiel: Gegeben dieselbe Eingabematrix 2x2:

   1  3  2  4 

  Das Resultat des Average Pooling wäre der Durchschnitt der vier Werte: (1+3+2+4)/4 = 2.5.

Vorteile von Max Pooling gegenüber Average Pooling

• Verhinderung von Overfitting: Max Pooling hat eine gewisse Regularisierungseigenschaft, da es nur die bedeutendsten Merkmale einer Region weiterleitet. Dadurch kann es verhindern, dass das Modell zu sehr auf die Details der Trainingsdaten passt und Überanpassung (Overfitting) vermieden wird.

• Reduktion des Rechenaufwands: Beide Pooling-Methoden reduzieren die räumliche Größe der Feature Maps, was die Anzahl der Parameter und die Komplexität der Berechnungen in den nachfolgenden Schichten reduziert. Max Pooling unterstützt jedoch stärker die Fokussierung auf die aktivsten (wichtigsten) Neuronen und trägt somit zur effizienteren Weiterleitung von Informationen bei.

Insgesamt bietet Max Pooling daher oft Vorteile bei der Verhinderung von Overfitting und der Effizienzsteigerung in Convolutional Neural Networks.

d)

• Gegeben ist eine Feature Map mit Dimensionen 16 x 16 x 10. Wenn Du ein 2 x 2 Max Pooling mit einem Stride von 2 anwendest, bestimme die Dimensionen der resultierenden Feature Map und zeige einen mathematischen Ausdruck zur Berechnung dieser Dimensionen.

Lösung:

Bestimmung der Dimensionen der resultierenden Feature Map nach Max Pooling

Um die Dimensionen der resultierenden Feature Map nach Anwendung von 2x2 Max Pooling mit einem Stride von 2 zu berechnen, können wir die folgende Formel verwenden:

• Die Höhe (Height) und Breite (Width) der Feature Map nach dem Pooling wird mit der Formel berechnet:
• \( H_{out} = \frac{H_{in} - \text{Filterhöhe}}{\text{Stride}} + 1 \)
• \( W_{out} = \frac{W_{in} - \text{Filterbreite}}{\text{Stride}} + 1 \)

In diesem Fall ist das Padding = 0 (kein Padding verwendet).

• Eingabedimensionen: Höhe (\(H_{in}\)) = 16, Breite (\(W_{in}\)) = 16, Kanäle = 10
• Filtergröße: 2 x 2
• Stride: 2
• Padding: 0

Berechnungen:

• Höhe der Feature Map (\(H_{out}\)):

\( H_{out} = \frac{16 - 2}{2} + 1 = \frac{14}{2} + 1 = 7 + 1 = 8 \)

• Breite der Feature Map (\(W_{out}\)):

\( W_{out} = \frac{16 - 2}{2} + 1 = \frac{14}{2} + 1 = 7 + 1 = 8 \)

• Anzahl der Kanäle:

Die Anzahl der Kanäle bleibt unverändert und beträgt daher 10.

Ergebnis:

Die Dimensionen der resultierenden Feature Map sind: 8 x 8 x 10.

Aufgabe 3)

Verarbeitung und Modellierung von Sequenzdaten

Du wirst in dieser Aufgabe gebeten, Dein Verständnis der Architekturen LSTM (Long Short-Term Memory) und GRU (Gated Recurrent Unit) zu zeigen. Beide Architekturen sind Erweiterungen von Recurrent Neural Networks (RNNs) und werden verwendet, um Probleme mit Langzeitabhängigkeiten zu überwinden.

• LSTM: Die Architektur eines LSTM besteht aus einem Zellzustand sowie Eingabe-, Vergessens- und Ausgangsgates. Diese Struktur ermöglicht es dem LSTM, nützliche Informationen über längere Zeiträume zu speichern und irrelevante Informationen zu vergessen.
• GRU: GRUs sind eine weniger komplexe Alternative zu LSTMs. Sie kombinieren Update- und Reset-Gates, um die Modellarchitektur zu vereinfachen und dennoch ähnliche Funktionen zu bieten.

Wichtige Formeln:

LSTM:

• Vergessensgate: \( f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \)
• Eingabegate: \( i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \)
• Zellzustandsupdate: \( \tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C) \)
• Aktualisierter Zellzustand: \( C_t = f_t * C_{t-1} + i_t * \tilde{C}_t \)
• Ausgabegate: \( o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \)
• Endgültiger Output: \( h_t = o_t * \tanh(C_t) \)

GRU:

• Updategate: \( z_t = \sigma(W_z \cdot [h_{t-1}, x_t]) \)
• Resetgate: \( r_t = \sigma(W_r \cdot [h_{t-1}, x_t]) \)
• Aktualisierter Hidden State: \( \tilde{h}_t = \tanh(W_h \cdot [r_t * h_{t-1}, x_t]) \)
• Endgültiger Hidden State: \( h_t = (1 - z_t) * h_{t-1} + z_t * \tilde{h}_t \)

a)

Teil 1: Erkläre den Unterschied zwischen den Aufgaben der Gates in einem LSTM und einem GRU. Wie beeinflussen die Unterschiede in ihrer Struktur und Funktion die Leistung und Komplexität der jeweiligen Netzwerke?

Lösung:

Teil 1: Erkläre den Unterschied zwischen den Aufgaben der Gates in einem LSTM und einem GRU. Wie beeinflussen die Unterschiede in ihrer Struktur und Funktion die Leistung und Komplexität der jeweiligen Netzwerke?

Unterschiede zwischen LSTM und GRU in Bezug auf die Gates:

• Vergessensgate-Funktion (LSTM): Im LSTM fungiert das "Vergessensgate" (\( f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \)) dazu, zu bestimmen, welche Informationen aus dem vorherigen Zellzustand verworfen werden sollen. Dies hilft beim Vergessen unnötiger Informationen über die Zeit.
• Eingabegate-Funktion (LSTM): Das "Eingabegate" (\( i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \)) legt fest, welche neuen Informationen in den Zustand aufgenommen werden. Dies ermöglicht es dem LSTM, nützliche neue Daten zu nutzen und irrelevante zu ignorieren.
• Zellzustandsupdate (LSTM): Die Zellzustandsaktualisierung (\( \tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C) \)) integriert die neuen potenziellen Daten in den aktuellen Zellzustand. Der aktualisierte Zellzustand (\( C_t = f_t * C_{t-1} + i_t * \tilde{C}_t \)) reflektiert die Modifikation durch das Vergessens- und Eingabegate.
• Ausgabegate-Funktion (LSTM): Das "Ausgabegate" (\( o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \)) bestimmt, welche Teile des Zellzustands in den nächsten Hidden State fließen. Der endgültige Output (\( h_t = o_t * \tanh(C_t) \)) ergibt sich aus dem gefilterten Zellzustand.
• Updategate (GRU): Im GRU ersetzt das "Updategate" (\( z_t = \sigma(W_z \cdot [h_{t-1}, x_t]) \)) die Funktionen von Eingabe- und Vergessensgate im LSTM. Es entscheidet, inwieweit der vergangene Zustand beibehalten und wie stark der neue Zustand aktualisiert werden soll.
• Resetgate (GRU): Das "Resetgate" (\( r_t = \sigma(W_r \cdot [h_{t-1}, x_t]) \)) steuert, wie sehr der alte Hidden State zurückgesetzt werden soll, bevor er in die Berechnung des neuen Zustands eingeht. Dies ermöglicht eine feinere Steuerung der Erinnerung und des Vergessens im Modell.
• Aktualisierte und endgültige Hidden States (GRU): Der aktualisierte Hidden State (\( \tilde{h}_t = \tanh(W_h \cdot [r_t * h_{t-1}, x_t]) \)) berücksichtigt das Resetgate. Der endgültige Hidden State (\( h_t = (1 - z_t) * h_{t-1} + z_t * \tilde{h}_t \)) ist eine Mischung aus dem alten Hidden State und dem neuen, durch das Updategate gefilterten versteckten Zustand.

Auswirkungen auf Leistung und Komplexität:

• Struktur: LSTM-Netzwerke besitzen eine komplexere Struktur mit getrennten Gates für unterschiedliche Funktionen (Vergessen, Eingeben, Ausgeben) und einem separaten Zellzustand. Die Grün-Architektur im Vergleich ist einfacher, da sie weniger Gates und keinen getrennten Zellzustand aufweist.
• Komplexität: Die komplexere Struktur von LSTMs führt zu höherem Rechenaufwand und längeren Trainingszeiten im Vergleich zu GRUs. Diese verfügen über eine einfachere Architektur, die schneller und weniger rechenintensiv ist.
• Leistung: Für sehr lange Sequenzen und komplexe Abhängigkeiten neigen LSTMs dazu, besser zu performen, da sie besser in der Lage sind, Langzeiterinnerungen über den Zellzustand zu behalten. GRUs hingegen zeigen oft eine vergleichbare Leistung bei moderaten Langzeitabhängigkeiten und sind effektiver bei kleineren Datenmengen oder weniger komplexen Aufgaben.

d)

Teil 4: In welcher Art von Anwendungsfällen würdest Du LSTM über GRU bevorzugen und warum? Diskutiere den Einfluss der Modellkomplexität und der benötigten Trainingszeit auf Deine Wahl.

Lösung:

Teil 4: In welcher Art von Anwendungsfällen würdest Du LSTM über GRU bevorzugen und warum? Diskutiere den Einfluss der Modellkomplexität und der benötigten Trainingszeit auf Deine Wahl.

Die Wahl zwischen LSTM und GRU hängt stark von der spezifischen Anwendung und den Anforderungen ab. Hier sind einige Überlegungen, wann man LSTM bevorzugen könnte:

• Langzeitabhängigkeiten: Wenn Dein Anwendungsfall starke Langzeitabhängigkeiten hat, wie z.B. bei maschineller Übersetzung oder Spracherkennung, dann kann LSTM aufgrund seines separaten Zellzustands und der speziellen Vergessens- und Eingabegates besser geeignet sein. Diese Struktur ermöglicht es LSTM, wichtige Informationen über viele Zeitintervalle hinweg zu speichern und irrelevante Informationen zu vergessen.
• Komplexe Datensätze: Bei sehr komplexen Datensätzen oder wenn die Daten hohe Dimensionalität aufweisen, kann die komplexere Architektur des LSTM bessere Ergebnisse liefern. Die zusätzliche Kontrolle über die Informationen, die in den Zellzustand ein- und austreten, kann in solchen Szenarien von Vorteil sein.
• Legacymodelle: Wenn es sich um ein bestehendes System handelt, das auf LSTM aufbaut und bereits gut funktioniert, wäre es sinnvoll, bei LSTM zu bleiben. Der Aufwand für den Wechsel zu einer neuen Architektur wie GRU könnte in solchen Fällen die möglichen Vorteile übersteigen.

Der Einfluss der Modellkomplexität und der Trainingszeit:

• Modellkomplexität: LSTM-Netzwerke sind tendenziell komplexer als GRUs, da sie mehr Gates und einen separaten Zellzustand haben. Diese zusätzliche Komplexität kann jedoch auch eine bessere Modellierungsfähigkeit bedeuten, insbesondere bei komplexen Datensätzen.
• Trainingszeit: Aufgrund ihrer einfacheren Struktur sind GRUs oft schneller zu trainieren als LSTMs. Wenn die Trainingszeit ein kritischer Faktor ist und die Leistung von GRUs ausreicht, könnte GRU eine bessere Wahl sein. Dies gilt insbesondere für Echtzeitanwendungen oder Anwendungen mit eingeschränkter Rechenkapazität.

Zusammenfassend lässt sich sagen, dass LSTMs bei Aufgaben mit komplexen Langzeitabhängigkeiten und komplexen Datensätzen bevorzugt werden sollten, während GRUs möglicherweise bei weniger komplexen Aufgaben oder wenn die Trainingszeit und Ressourcennutzung kritisch sind, besser geeignet sind. Die Wahl sollte auf eine gründliche Analyse der spezifischen Anforderungen und der verfügbaren Ressourcen abgestimmt sein.

Aufgabe 4)

Du hast zwei unterschiedliche Datenreduktionsverfahren kennengelernt: PCA (Principal Component Analysis) und t-SNE (t-Distributed Stochastic Neighbor Embedding). Beide Methoden dienen der Reduktion von Dimensionsräumen, aber auf unterschiedliche Weise und mit verschiedenen Zielsetzungen. Hier wirst Du beide Methoden anwenden und ihre Unterschiede in Theorie und Praxis bewerten.

a)

Erkläre den mathematischen Hintergrund von PCA. Beschreibe den Prozess der Berechnung der Hauptkomponenten unter Verwendung der Kovarianzmatrix. Formulieren und erklären jeden relevanten mathematischen Ausdruck.

Lösung:

Hintergrund der Hauptkomponentenanalyse (PCA):

Die Hauptkomponentenanalyse (PCA) ist eine statistische Methode zur Reduktion der Dimensionalität von Datensätzen, während gleichzeitig so viel wie möglich von deren ursprünglicher Varianz erhalten bleibt. PCA transformiert die gegebenen Daten in ein neues Koordinatensystem, wobei die ersten Achsen (Hauptkomponenten) die größte Varianz der Daten repräsentieren.

1. Dauere der Berechnung der Hauptkomponenten:

• Schritt 1: Zentrieren der Daten: Zunächst werden die Daten zentriert, indem der Mittelwert jeder Variable von den Datenpunkten subtrahiert wird. Dies stellt sicher, dass das neue Koordinatensystem durch den Mittelwert des Datensatzes verläuft.
  • Für den Datensatz \(X\) mit den Variablen \(x_1, x_2, ..., x_n\):
  • Berechne den Mittelwert jeder Variable: \(\bar{x} = \frac{1}{n} \sum_{i=1}^n x_i\)
  • Zentriere die Daten: \(X_{zentriert} = X - \bar{x}\)
• Schritt 2: Berechnung der Kovarianzmatrix: Die Kovarianzmatrix zeigt, wie sehr zwei Variablen miteinander variieren. Diese Matrix ist symmetrisch und quadratisch.
  • Die Kovarianzmatrix \(Cov_matrix\) wird wie folgt berechnet: \[Cov(X_{zentriert}) = \frac{1}{n-1} (X_{zentriert}^T \cdot X_{zentriert})\]
• Schritt 3: Berechnung der Eigenvektoren und Eigenwerte: Eigenvektoren und Eigenwerte der Kovarianzmatrix werden berechnet, um die Richtung der größten Varianz in den Daten zu bestimmen.
  • Sei \(\mathbf{V}\) die Matrix der Eigenvektoren und \(\mathbf{\Lambda}\) die Diagonalmatrix der Eigenwerte, sodass gilt: \[Cov(X_{zentriert}) \cdot \mathbf{V} = \mathbf{V} \cdot \mathbf{\Lambda}\]
• Schritt 4: Projektion der Daten auf die Hauptkomponenten: Die Daten werden auf die Hauptkomponenten projiziert, um die neue Darstellung der Daten im Raum der Hauptkomponenten zu erhalten.
  • Projiziere die zentrierten Daten auf die Eigenvektoren: \(X_{projiziert} = \mathbf{V}^T \cdot X_{zentriert}\)

Mathematik hinter den Hauptkomponenten (PCA) zusammengefasst:

• Zentrierung der Daten: \(X_{zentriert} = X - \bar{x}\)
• Berechnung der Kovarianzmatrix: \(Cov(X_{zentriert}) = \frac{1}{n-1} (X_{zentriert}^T \cdot X_{zentriert})\)
• Berechnung der Eigenvektoren und Eigenwerte: \(Cov(X_{zentriert}) \cdot \mathbf{V} = \mathbf{V} \cdot \mathbf{\Lambda}\)
• Projektion der Daten: \(X_{projiziert} = \mathbf{V}^T \cdot X_{zentriert}\)

b)

Implementiere den PCA-Algorithmus in Python gegeben einer Datenmatrix X. Der Algorithmus soll die zentrierte Datenmatrix, die Kovarianzmatrix, die Eigenvektoren, und die Projektionen der Daten auf die Hauptkomponenten berechnen und ausgeben. Verwende dazu die folgenden Daten:

'import numpy as npX = np.array([[2.5, 2.4], [0.5, 0.7], [2.2, 2.9], [1.9, 2.2], [3.1, 3.0], [2.3, 2.7], [2, 1.6], [1, 1.1], [1.5, 1.6], [1.1, 0.9]])'

Lösung:

Implementierung des PCA-Algorithmus in Python:

Um den PCA-Algorithmus in Python zu implementieren, verwenden wir die gegebene Datenmatrix. Der Algorithmus wird die zentrierte Datenmatrix, die Kovarianzmatrix, die Eigenvektoren und die Projektionen der Daten auf die Hauptkomponenten berechnen und ausgeben.

import numpy as np 

# Gegebene DatenmatrixX = np.array([[2.5, 2.4],                 [0.5, 0.7],                 [2.2, 2.9],                 [1.9, 2.2],                 [3.1, 3.0],                 [2.3, 2.7],                 [2, 1.6],                 [1, 1.1],                 [1.5, 1.6],                 [1.1, 0.9]])

# Schritt 1: Daten zentrierenmean_X = np.mean(X, axis=0)X_centered = X - mean_X

# Schritt 2: Kovarianzmatrix berechnencov_matrix = np.cov(X_centered, rowvar=False)

# Schritt 3: Eigenvektoren und Eigenwerte berechneneig_values, eig_vectors = np.linalg.eig(cov_matrix)

# Schritt 4: Daten auf Hauptkomponenten projizierenX_projected = X_centered.dot(eig_vectors)

# Ergebnis ausgebenprint('Zentrierte Datenmatrix:')print(X_centered)print('Kovarianzmatrix:')print(cov_matrix)print('Eigenvektoren:')print(eig_vectors)print('Projektionen der Daten auf die Hauptkomponenten:')print(X_projected)

Beispielausgabe:Wenn du den oben stehenden Code in einer Python-Umgebung ausführst, wird die Ausgabe wie folgt aussehen:

• Zentrierte Datenmatrix:

  [[ 0.69  0.49] [ -1.31  -1.21] [ 0.39  0.99] [ 0.09  0.29] [ 1.29  1.09] [ 0.49  0.79] [ 0.19  -0.19] [ -0.81  -0.69] [ -0.31  -0.19] [ -0.71  -0.89]]

• Kovarianzmatrix:

  [[0.61655556 0.61544444] [0.61544444 0.71655556]]

• Eigenvektoren:

  [[ -0.73517866 -0.6778734 ] [ -0.6778734  0.73517866]]

• Projektionen der Daten auf die Hauptkomponenten:

  [[ -0.82797019 -0.17511531] [ 1.77758033 -0.14285723] [ -0.99219749  0.38437499] [ -0.27421042  0.13041721] [ -1.67580142 -0.20949846] [ -0.9129491  0.17528244] [ 0.09910944 -0.3498247 ] [ 1.14457216 -0.04641726] [ 0.43804614 -0.01776463] [ 1.22382056 -0.16267529]]

c)

Unterscheide PCA und t-SNE hinsichtlich ihrer Anwendungsgebiete und erläutere, warum t-SNE oft bessere Ergebnisse bei der Visualisierung hochdimensionaler Daten liefert. Gehe auf die Aspekte der linearen vs. nichtlinearen Reduktion ein.

Lösung:

Unterschiede zwischen PCA und t-SNE:

• Anwendungsgebiete:
  • PCA (Principal Component Analysis):
    • PCA wird hauptsächlich zur Dimensionalitätsreduktion und Datenvorkonditionierung verwendet. Es findet Anwendung in der Exploration großer Datensätze, in der Bildverarbeitung und als Vorverarbeitungsschritt für andere Algorithmen wie Clustering oder Klassifikation.
    • Da PCA eine lineare Methode ist, eignet sie sich besonders gut für Datensätze, bei denen die zugrunde liegenden Strukturen und Zusammenhänge linear sind.
    • Beispiel: Reduktion der Dimensionalität von großen gene expression datasets für weitere Analysen.
  • t-SNE (t-Distributed Stochastic Neighbor Embedding):
    • t-SNE wird hauptsächlich zur Visualisierung hochdimensionaler Daten in zwei oder drei Dimensionen verwendet, um Strukturen oder Cluster sichtbar zu machen.
    • Es ist eine nichtlineare Technik, die besonders effektiv ist bei Daten, deren zugrunde liegende Strukturen nicht linear sind.
    • Beispiel: Visualisierung von hochdimensionalen Datensätzen wie z.B. Bild- oder Textdaten.
• Lineare vs. nichtlineare Reduktion:
  • Lineare Reduktion (PCA):
    • PCA ist eine lineare Methode, die eine lineare Transformation der Daten durchführt. Sie maximiert die Varianz der Daten entlang der neuen Achsen (Hauptkomponenten).
    • PCA projiziert die Daten auf ein neues Koordinatensystem, dessen Achsen die Richtungen maximaler Varianz repräsentieren.
    • Formell: PCA berechnet die Eigenwerte und Eigenvektoren der Kovarianzmatrix der Daten. Die Hauptkomponenten sind die Eigenvektoren sortiert nach den zugehörigen Eigenwerten in absteigender Reihenfolge.
    • Dies ist besonders nützlich, wenn die zugrunde liegende Struktur der Daten linear ist.
  • Nichtlineare Reduktion (t-SNE):
    • t-SNE ist eine nichtlineare Methode, die die Daten in eine niedrigdimensionale Darstellung transformiert, indem sie lokale Nachbarschaften erhält.
    • t-SNE minimiert die Divergenz zwischen zwei Verteilungen: einer Verteilung der Punkt-Paare in der hochdimensionalen originalen Daten und einer Verteilung der Punkt-Paare im niedrigdimensionalen Raum.
    • Es verwendet probabilistische Ansätze, um die Ähnlichkeiten zwischen Datenpunkten zu berechnen und projiziert diese Ähnlichkeiten in einem niedrigdimensionalen Raum.
    • Da t-SNE sich auf die Erhaltung der Nachbarschaftsstrukturen fokussiert, ist es besonders geeignet, um Cluster oder andere nichtlineare Strukturen in den Daten zu visualisieren.
• Warum t-SNE oft bessere Ergebnisse bei der Visualisierung liefert:
  • t-SNE ist besonders effektiv bei der Visualisierung, weil es die lokalen Nachbarschaftsstruktur der Daten sehr genau erhält. Dies erlaubt es, Cluster und Gruppierungen in komplexen, hochdimensionalen Datensätzen besser zu identifizieren.
  • Im Gegensatz dazu kann PCA bei der Reduktion auf wenige Dimensionen wichtige nichtlineare Zusammenhänge verlieren, da es nur lineare Beziehungen berücksichtigt.
  • t-SNE schafft eine niedrigdimensionale Darstellung, die die Ähnlichkeiten zwischen Datenpunkten wahrscheinlicher aufrechterhält, was zu einer genaueren und intuitiveren Visualisierung führt.

d)

Nimm an, dass Du eine hochdimensionale Datenmatrix X hast. Beschreibe die Schritte zur Datenvorverarbeitung, die vor der Anwendung von PCA oder t-SNE durchgeführt werden sollten, und begründe, warum diese Schritte notwendig sind.

Lösung:

Schritte zur Datenvorverarbeitung vor der Anwendung von PCA oder t-SNE:

• 1. Datenbereinigung:Stelle sicher, dass der Datensatz frei von fehlenden Werten, Ausreißern und Duplikaten ist. Dies kann mittels einfacher Methoden wie Mittelwert- oder Median-Interpolation für fehlende Werte, oder mittels fortgeschrittener Techniken wie Imputation erfolgen.
  • Grund: Fehlende Werte und Ausreißer können die Ergebnisse beeinträchtigen, da sie ungenaue Varianz- und Ähnlichkeitsberechnungen verursachen können.
• 2. Standardisierung der Daten:Standardisiere die Daten, indem du jede Variable auf einen Mittelwert von 0 und eine Standardabweichung von 1 skalierst.
  • Schritt: Berechne den Mittelwert und die Standardabweichung jeder Variable, und wende die Standardisierung an: \(X_i' = \frac{X_i - \bar{X}}{\sigma}\)
  • Grund: Dies ist besonders wichtig für PCA, da PCA stark von der Skala der Variablen abhängt. Ohne Standardisierung könnten Variablen mit größeren Skalen die Hauptkomponenten dominieren.
• 3. Entfernung von konstanten oder quasi-konstanten Merkmalen:Entferne Merkmale, die wenig oder gar keine Varianz aufweisen.
  • Grund: Merkmale ohne Varianz liefern keine nützliche Information für die Analyse und können die Rechenleistung unnötig belasten.
• 4. Normalisierung:Wenn die Variablen unterschiedliche Einheiten oder Skalen haben, normalisiere sie auf einen einheitlichen Bereich (z.B. zwischen 0 und 1).
  • Schritt: Wende Min-Max-Skalierung an: \(X_i' = \frac{X_i - X_{min}}{X_{max} - X_{min}}\)
  • Grund: Dies kann besonders für t-SNE hilfreich sein, da t-SNE empfindlich auf die Distanzen der Datenpunkte reagiert.
• 5. Auswahl relevanter Merkmale:Identifiziere und behalte nur die für die Analyse relevanten Merkmale, entweder durch Domänenwissen oder durch Merkmalsauswahltechniken.
  • Grund: Reduzierte und relevante Merkmalsmengen können die Effizienz der Datenverarbeitung verbessern und die Interpretierbarkeit der Ergebnisse erhöhen.
• 6. Entfernen von Multikollinearität:Untersuche die Daten auf stark korrelierte Merkmale und entferne Multikollinearität, indem du redundante Merkmale eliminierst.
  • Grund: Multikollinearität kann die Stabilität und Genauigkeit der Modellierung beeinträchtigen, insbesondere bei PCA, da stark korrelierte Variablen redundante Informationen liefern.
• 7. Dimensionalitätsreduktion (optional):Vor der Anwendung komplexerer Verfahren wie t-SNE kann eine erste Reduktion der Dimensionalität mittels PCA in Betracht gezogen werden.
  • Grund: Dies kann die Berechnung erleichtern und die Effizienz von t-SNE verbessern, da t-SNE oft langsamer und rechenintensiver ist.