Selected Topics of Deep Learning for Audio, Speech, and Music Processing - Exam

Aufgabe 1)

In einem neuronalen Netz werden verschiedene Optimierungsmethoden verwendet, um die Gewichte und Parameter so anzupassen, dass die Fehlerfunktion minimiert wird. Zu den gebräuchlichsten Methoden zählen der Gradientenabstieg und seine Erweiterungen wie Adam, RMSProp und Adagrad. Die Fehlerfunktion wird typischerweise durch MSE oder Cross-Entropy bestimmt. Wesentliche Parameter für den Lernprozess sind die Lernrate und die Batch-Größe. Darüber hinaus spielen Regularisierungsmethoden wie L2 und Dropout eine wichtige Rolle, um Overfitting zu vermeiden.

a)

Erkläre den Grundgedanken des Gradientenabstiegs und wie er zur Anpassung der Gewichte in einem neuronalen Netz verwendet wird. Illustriere Deine Antwort durch die Schritt-für-Schritt-Beschreibung des Algorithmus und diskutiere potenzielle Herausforderungen wie die Wahl der Lernrate.

Lösung:

Grundgedanke des Gradientenabstiegs: Anpassung der Gewichte in einem neuronalen Netz

Der Gradientenabstieg ist eine fundamentale Optimierungsmethode zur Anpassung der Gewichte und Parameter eines neuronalen Netzwerks. Der Hauptgedanke besteht darin, die Gewichte so anzupassen, dass die Fehlerfunktion minimiert wird, indem man in die Richtung des negativen Gradienten der Fehlerfunktion geht.

Schritt-für-Schritt-Beschreibung

• Initialisierung der Gewichte: Die Gewichte werden zu Beginn zufällig initialisiert.
• Berechnung der Vorhersagen: Das neuronale Netz nimmt die Input-Daten auf und berechnet die Vorhersagen basierend auf den aktuellen Gewichten.
• Fehlerberechnung: Die Fehlerfunktion (z.B. Mean Squared Error (MSE) oder Cross-Entropy) berechnet, wie weit die Vorhersagen von den tatsächlichen Werten entfernt sind.
• Berechnung des Gradienten: Mithilfe des Rückwärtsdurchlaufs (Backpropagation) wird der Gradient der Fehlerfunktion hinsichtlich jedes Gewichts berechnet. Dieser Gradient zeigt die Richtung und das Ausmaß an, in der die Gewichte angepasst werden sollten, um den Fehler zu reduzieren.
• Gewichtsanpassung: Die Gewichte werden durch Subtraktion des Lernprodukts (Lernrate \(\eta\) mal Gradient) aktualisiert:

  \[W_{neu} = W_{alt} - \eta \frac{dF}{dW}\]

• Wiederholung: Diese Schritte werden über viele Epochen wiederholt, bis die Fehlerfunktion minimiert ist oder ein Abbruchkriterium erfüllt ist.

Potenzielle Herausforderungen

• Wahl der Lernrate: Eine zu hohe Lernrate kann dazu führen, dass der Algorithmus über das Minimum hinaus schießt und die Fehlerfunktion nicht minimiert wird. Eine zu niedrige Lernrate führt dagegen zu einem sehr langsamen Lernprozess. Eine geeignete Lernrate kann durch Experimentieren und Validieren gefunden werden.
• Lokale Minima: Der Gradientenabstieg kann in lokalen Minima der Fehlerfunktion hängen bleiben. Erweiterungen wie der Momentum-Gradientenabstieg können helfen, dieses Problem zu überwinden.
• Rechenaufwand: Der Gradientenabstieg kann aufgrund der vielen Berechnungen langsam sein. Stochastic Gradient Descent (SGD) benutzt Mini-Batches statt des gesamten Datensatzes, um die Effizienz und Geschwindigkeit zu erhöhen.

c)

Gegeben sei folgende Cross-Entropy-Loss-Funktion für ein binäres Klassifikationsproblem: \[ L(y, \tilde{y}) = - \frac{1}{n} \times \big( y \times \text{log}(\tilde{y}) + (1 - y) \times \text{log}(1 - \tilde{y}) \big) \] Implementiere in Python den Gradientenabstiegsalgorithmus, um die Gewichte zu aktualisieren. Stelle sicher, dass Dein Code die Lernrate und die Batch-Größe als Parameter berücksichtigt. Beachte dabei auch die Regularisierung in Form von L2.

Lösung:

Implementierung des Gradientenabstiegs für die Cross-Entropy-Loss-Funktion

Wir werden den Gradientenabstiegsalgorithmus implementieren, um die Gewichte für ein binäres Klassifikationsproblem unter Verwendung der angegebenen Cross-Entropy-Loss-Funktion zu aktualisieren. Zudem berücksichtigen wir eine Regularisierung in Form von L2.

Schritt-für-Schritt Implementierung

import numpy as np# Cross-Entropy-Loss-Funktion mit L2 Regularisierungdef cross_entropy_loss(y, y_pred, weights, lambda_reg):  n = len(y)  loss = -(1/n) * np.sum(y * np.log(y_pred) + (1 - y) * np.log(1 - y_pred))  lasso = lambda_reg * (1/2) * np.sum(weights**2)  # L2 Regularisierungsterm  return loss + lasso# Sigmoid-Funktiondef sigmoid(z):  return 1 / (1 + np.exp(-z))# Gradientenabstiegs-Algorithmusdef gradient_descent(X, y, learning_rate, batch_size, epochs, lambda_reg):  m, n = X.shape  weights = np.zeros(n)  bias = 0# Verlauf der Kostenfunktion  loss_history = []  for epoch in range(epochs):   indices = np.arange(m)    np.random.shuffle(indices) //Mini-Batches erstellen  for i in range(0 , m, batch_size):    batch_indices = indices[i:i+batch_size]    X_batch = X[batch_indices]   y_batch = y[batch_indices] //Vorhersagen  y_pred = sigmoid(np.dot(X_batch, weights) + bias)  //Gradienten berechnen  weight_grad = (1/batch_size) * np.dot(X_batch.T, (y_pred - y_batch)) + lambda_reg * weights    bias_grad = (1/batch_size) * np.sum(y_pred - y_batch)//Parameter aktualisieren  weights -= learning_rate * weight_grad     bias -= learning_rate * bias_grad// Verlust berechnen und speichern  loss = cross_entropy_loss(y, sigmoid(np.dot(X, weights) + bias), weights, lambda_reg)  loss_history.append(loss)return weights , bias , loss_history  # Beispiel für die Verwendung der ImplementierungX = np.array([[0.1 , 0.2],[0.3 , 0.4],[0.5 , 0.6],[0.7 , 0.8]])   y = np.array([0, 0,1, 1])  learning_rate = 0.01   batch_size = 2  epochs = 1000   lambda_reg = 0.1optimal_weights , optimal_bias , loss_hist = gradient_descent(X,y,learning_rate,batch_size,epochs,lambda_reg)print('Optimal Weights:', optimal_weights)print('Optimal Bias:', optimal_bias) print ('Loss history:',loss_hist)

Diese Implementierung umfasst:

• Definieren der Cross-Entropy-Loss-Funktion mit L2 Regularisierung.
• Berechnung des Sigmoid von z für die Vorhersagen.
• Gradientenabstiegs-Algorithmus, der die Gewichte und den Bias iterativ unter Berücksichtigung der Lernrate, der Batch-Größe und der L2-Regularisierung aktualisiert.

Verwende die Beispielwerte für die Features (X) und die Labels (y) zum Testen und Überprüfen der Implementierung.

Aufgabe 2)

Spectrogramme spielen eine zentrale Rolle in der Audiobearbeitung, da sie die Frequenzen eines Audiosignals visuell über die Zeit darstellen. Dies geschieht durch die Anwendung der Fourier-Transformation auf zeitlich segmentierte Teile des Signals. Es gibt verschiedene Arten von Spectrogrammen, wie die Kurzzeit-Fourier-Transformation (STFT) und das Mel-Spectrogramm. Spectrogramme sind nützlich für die Erkennung von Mustern, Frequenzanalyse, Rauschunterdrückung und Merkmalsextraktion. In der Anwendung von Deep Learning dienen sie als Eingabe für neuronale Netze bei Aufgaben wie Spracherkennung und Musikklassifikation.

a)

Gegeben sei ein Audiosignal \(x(t)\), das eine Dauer von 10 Sekunden hat und mit einer Samplerate von 1 kHz aufgenommen wurde. Beschreibe den Prozess der Erstellung eines STFT-Spectrogramms für dieses Signal und erkläre, wie die Fenstergröße und die Überlappung die Ausgabe beeinflussen.

Lösung:

Erstellung eines STFT-Spectrogramms für das gegebene Audiosignal:

Gegeben sei ein Audiosignal \(x(t)\), das eine Dauer von 10 Sekunden hat und mit einer Samplerate von 1 kHz aufgenommen wurde.

Um ein STFT-Spectrogramm zu erstellen, folgen wir den folgenden Schritten:

• 1. Segmentierung: Das Audiosignal wird in kurze, überlappende Segmente (zeitliche Fenster) unterteilt.
• 2. Fensterung: Auf jedes dieser Segmente wird ein Fenster (z.B. Hamming- oder Hanning-Fenster) angewendet, um die Randeffekte zu glätten und Übergangseffekte zu minimieren.
• 3. Fourier-Transformation: Für jedes Segment wird die Fourier-Transformation durchgeführt, um das Frequenzspektrum dieses Segments zu erhalten.
• 4. Spektrogramm-Erstellung: Die resultierenden Frequenzspektren werden über die Zeitachse angeordnet, um ein Spektrogramm zu erstellen, das die Frequenzen visuell über die Zeit darstellt.

Diese Schritte können auch mit Pseudocode beschrieben werden:

// Parameterssignal = x(t)sampling_rate = 1000 // 1 kHzwindow_size = N // number of samples per windowoverlap = M // number of overlapping samples// Apply STFTSpectrogram = []for each segment in signal:    windowed_segment = apply_window(segment)    spectrum = Fourier_Transform(windowed_segment)    Spectrogram.append(spectrum)

Auswirkungen der Fenstergröße und Überlappung auf die Ausgabe:

• Fenstergröße (N):
• - Kleine Fenster: Bieten eine hohe Zeitauflösung, da sie schnellere Veränderungen im Signal erkennen können. Allerdings leidet die Frequenzauflösung darunter, d.h., es wird schwieriger, nahe beieinander liegende Frequenzen zu unterscheiden.
• - Große Fenster: Erhöhen die Frequenzauflösung, da mehr Datenpunkte für die Fourier-Transformation zur Verfügung stehen. Dies ermöglicht eine genauere Unterscheidung von Frequenzen, jedoch leidet die Zeitauflösung, da schnelle Änderungen nicht so präzise detektiert werden.
• Überlappung (M):
• - Hohe Überlappung: Führt zu einer flüssigeren und detaillierteren Darstellung im Spektrogramm, da die Segmente enger beieinander liegen. Dies verbessert die Kontinuität und gleicht die zeitlichen Übergänge zwischen den Fenstern aus.
• - Geringe Überlappung: Reduziert die Berechnungen und die Datenmenge, was zu weniger glatten und detaillierten Spektrogrammen führt. Es gibt größere Sprünge zwischen den Segmenten, was die Erkennung feiner zeitlicher Details erschwert.

Zur Verdeutlichung des Einflusses der Fenstergröße und Überlappung, kannst Du Dir vorstellen, dass kleine Fenster wie eine Lupe auf das zeitliche Verhalten des Signals wirken, während große Fenster und hohe Überlappung die feinen Details der Frequenzkomponenten klarer darstellen.

b)

Implementiere in Python eine Funktion, die das Mel-Spectrogramm eines gegebenen Audiosignals berechnet. Nutze dabei die Bibliothek librosa und spezifiziere die Parameter für n_fft, hop_length und n_mels. Füge dem Code dazu geeignete Kommentare hinzu.

Lösung:

Implementierung eines Mel-Spectrogramms in Python mit der Bibliothek librosa:

Hier ist eine Python-Funktion, die das Mel-Spectrogramm eines gegebenen Audiosignals unter Verwendung der Bibliothek librosa berechnet. Diese Funktion spezifiziert die Parameter n_fft, hop_length und n_mels.

import librosaimport numpy as npimport matplotlib.pyplot as pltdef compute_mel_spectrogram(audio_path, n_fft=2048, hop_length=512, n_mels=128):    # Laden des Audiosignals    y, sr = librosa.load(audio_path, sr=None)        # Berechnung des Mel-Spectrogramms    mel_spectrogram = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=n_fft, hop_length=hop_length, n_mels=n_mels)    # Umwandlung des Mel-Spectrogramms in Dezibel-Skala    mel_spectrogram_db = librosa.power_to_db(mel_spectrogram, ref=np.max)    return mel_spectrogram_db# Beispielaufruf:audio_path = 'path/to/your/audiofile.wav'mel_spectrogram = compute_mel_spectrogram(audio_path)# Mel-Spectrogramm anzeigenplt.figure(figsize=(10, 4))librosa.display.specshow(mel_spectrogram, sr=22050, hop_length=512, x_axis='time', y_axis='mel')plt.colorbar(format='%+2.0f dB')plt.title('Mel-Spectrogramm')plt.tight_layout()plt.show()

Erklärung der wichtigsten Codezeilen:

• import librosa: Importieren der librosa-Bibliothek für die Audiobearbeitung.
• import numpy as np: Importieren der NumPy-Bibliothek für numerische Operationen.
• import matplotlib.pyplot as plt: Importieren der Matplotlib-Bibliothek zum Plotten.
• y, sr = librosa.load(audio_path, sr=None): Laden des Audiosignals und Abtastrate.
• mel_spectrogram = librosa.feature.melspectrogram(...): Berechnen des Mel-Spectrogramms.
• mel_spectrogram_db = librosa.power_to_db(mel_spectrogram, ref=np.max): Umwandlung des Mel-Spectrogramms in eine Dezibel-Skala.
• plt.figure(figsize=(10, 4)): Erstellen einer neuen Abbildung mit spezifizierter Größe.
• librosa.display.specshow(...): Anzeigen des Mel-Spectrogramms.
• plt.colorbar(format='%+2.0f dB'): Hinzufügen einer Farbskala.
• plt.title('Mel-Spectrogramm'): Festlegen des Titels der Abbildung.
• plt.tight_layout(): Optimierung des Layouts der Abbildung.
• plt.show(): Anzeigen des Plots.

c)

Angenommen, Du möchtest ein neuronales Netzwerk zur Spracherkennung trainieren, das Mel-Spectrogramme als Eingabe verwendet. Beschreibe den gesamten Prozess von der Datenvorbereitung über die Auswahl und das Design des Modells bis hin zur Evaluierung der Modellleistung. Welche Herausforderungen könnten dabei auftreten und wie würdest Du diesen begegnen?

Lösung:

Prozess zur Vorbereitung und Implementierung eines neuronalen Netzwerks zur Spracherkennung mit Mel-Spectrogrammen:

• 1. Datenvorbereitung:
• - Datenerfassung: Sammle und organisiere Sprachaufnahmen in verschiedenen Formaten und von verschiedenen Sprechern. Dies kann durch vorhandene Datensätze oder eigene Aufnahmen geschehen.
• - Datenanreicherung: Augmentiere die Daten durch Hinzufügen von Rauschen, Änderung der Tonlage oder Geschwindigkeit, um die Vielfalt der Daten zu erhöhen und das Modell robuster zu machen.
• - Mel-Spectrogramm-Berechnung: Verwende die zuvor implementierte Funktion, um Mel-Spectrogramme für jedes Audiosegment zu berechnen. Dies bedeutet, jedes Audiofile in ein Mel-Spectrogramm umzuwandeln, das dann als Eingabe für das Modell dient.
• 2. Modellauswahl und -design:
• - Modelltyp: Wähle ein geeignetes Modell. Bei Spracherkennung sind CNNs (Convolutional Neural Networks) und RNNs (Recurrent Neural Networks) oder deren Kombination (z.B. CRNNs) häufig verwendete Architekturtypen.
• - Modellarchitektur: Designe das neuronale Netzwerk. Beispielsweise:

from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, LSTM, TimeDistributeddef create_model(input_shape):    model = Sequential()        # Convolutional layers    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=input_shape))    model.add(MaxPooling2D((2, 2)))    model.add(Conv2D(64, (3, 3), activation='relu'))    model.add(MaxPooling2D((2, 2)))    model.add(Conv2D(128, (3, 3), activation='relu'))    model.add(MaxPooling2D((2, 2)))        # Flatten and dense layers    model.add(Flatten())    model.add(Dense(128, activation='relu'))    model.add(Dense(num_classes, activation='softmax'))        return model

• Passe die Architektur mit RNN-Schichten (z.B. LSTM) an, falls notwendig.

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

• - Datenaufteilung: Teile die Daten in Trainings-, Validierungs- und Testdatensätze. Dies ermöglicht eine faire Evaluierung des Modells.
• - Training: Trainiere das Modell mit den vorbereiteten Daten. Beispiel:

model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_val, y_val))

• - Testen des Modells: Evaluiere die Leistung auf dem Testdatensatz:

test_loss, test_accuracy = model.evaluate(X_test, y_test)print('Test accuracy:', test_accuracy)

• - Visualisierung: Verwende Konfusionsmatrizen, ROC-Kurven oder andere Metriken, um die Leistung des Modells zu bewerten und die Fehler zu analysieren.

• - Datenqualität: Hochwertige und vielfältige Datensätze sind wichtig. Hier können Rauschunterdrückungstechniken und Datenaugmentation helfen.
• - Datenmenge: Bei begrenzten Datenmengen können Techniken wie Transfer Learning oder das Hinzufügen synthetischer Daten angewendet werden.
• - Modellüberanpassung: Vermeide Overfitting durch Regularisierungstechniken wie Dropout, Early Stopping und Cross-Validation.
• - Architekturkomplexität: Stelle sicher, dass die Modellarchitektur zur Problemgröße und den verfügbaren Rechenressourcen passt.

Indem Du diese Schritte befolgst und die Herausforderungen meisterst, kannst Du ein robustes neuronales Netzwerk zur Spracherkennung mit Mel-Spectrogrammen als Eingabe erfolgreich implementieren.

Aufgabe 3)

In dieser Aufgabe geht es um die Analyse und Implementierung von Recurrent Neural Networks (RNN) und Long Short-Term Memory (LSTM) Netzwerken. Diese Modelle sind besonders geeignet für die Verarbeitung von sequenziellen Daten, wie sie in der Audio-, Sprach- und Musikverarbeitung häufig vorkommen.

Ein Recurrent Neural Network (RNN) nutzt Rückkopplungen, um Informationen in Sequenzen zu verarbeiten. Dies kann jedoch zum Problem der verschwindenden Gradienten führen, bei dem die Gradienten mit jeder zurückliegenden Zeiteinheit exponentiell kleiner werden und somit das Training des Netzes erschwert wird.

Ein LSTM-Netzwerk ist ein spezieller Typ von RNN, der durch den Einsatz von Vergessens- und Erinnerungszellen dieses Problem adressiert. LSTMs bauen auf den Grundprinzipien der RNNs auf, erweitern diese jedoch mit speziellen Mechanismen, um sich besser längerfristige Abhängigkeiten merken zu können.

a)

(a) RNN Formeln und Implementierung:

Erkläre die Hauptkomponenten eines einfachen RNNs. Zeige die Formel für das Update der versteckten Zustände und beschreibe den Rückkopplungsmechanismus. Implementiere anschließend ein einfaches RNN in Python mit der NumPy-Bibliothek, welches eine Sequenz verarbeitet und die verborgenen Zustände ausgibt.

Hinweis: Nutze folgende Formel für das Update der versteckten Zustände:

h_t = \tanh(W_{hx}x_t + W_{hh}h_{t-1} + b_h)

Lösung:

In dieser Aufgabe wirst Du die Hauptkomponenten eines einfachen Recurrent Neural Networks (RNN) kennenlernen und implementieren. Wir beginnen mit einer Erklärung der Komponenten und schreiten dann zur Implementierung in Python mit der NumPy-Bibliothek voran. Hauptkomponenten eines einfachen RNNs:

• Eingangsvektor \(x_t\): Der Eingangsvektor zur Zeit \(t\).
• Gewichtsmatrix \(W_{hx}\): Die Gewichtsmatrix, die die Eingaben auf den versteckten Zustand projiziert.
• Gewichtsmatrix \(W_{hh}\): Die Gewichtsmatrix, die den versteckten Zustand der vorherigen Zeitschritte auf den aktuellen versteckten Zustand projiziert.
• Bias-Term \(b_h\): Der Bias-Term für den versteckten Zustand.
• Aktivierungsfunktion: Üblicherweise verwenden einfache RNNs die \(\tanh\)-Funktion oder die \(\text{ReLU}\)-Funktion als Aktivierungsfunktion.
• Aktueller versteckter Zustand \(h_t\): Der versteckte Zustand zur Zeit \(t\).

h_t = \tanh(W_{hx}x_t + W_{hh}h_{t-1} + b_h)

Der Rückkopplungsmechanismus in einem RNN ermöglicht es dem Netzwerk, Informationen aus vorherigen Zeitschritten zu speichern und zu verwenden. Dies wird durch die Verwendung des vorherigen versteckten Zustands (\(h_{t-1}\)) im Update-Prozess sichergestellt.

Beim Vorwärtsschritt eines RNN wird der aktuelle versteckte Zustand \(h_t\) berechnet, indem die aktuelle Eingabe \(x_t\), der vorherige versteckte Zustand \(h_{t-1}\), und ein Bias \(b_h\) durch die Aktivierungsfunktion \(\tanh\) geschleust werden. Dieser Prozess wird für jedes Zeitschritt \(t\) der gegebenen Sequenz wiederholt.

 import numpy as np  def rnn_step(x_t, h_prev, W_hx, W_hh, b_h): h_t = np.tanh(np.dot(W_hx, x_t) + np.dot(W_hh, h_prev) + b_h) return h_t  def simple_rnn(X, W_hx, W_hh, b_h): # X is the input sequence, an array of input vectors T = len(X) h_t = np.zeros(W_hh.shape[0]) # Initialize hidden state for t in range(T): x_t = X[t] h_t = rnn_step(x_t, h_t, W_hx, W_hh, b_h) print(f'versteckter Zustand bei Zeitschritt {t + 1}: {h_t}') return h_t  # Beispiel für die Verwendung des einfachen RNNs X = [np.array([1, 2]), np.array([3, 4]), np.array([5, 6])] W_hx = np.random.rand(3, 2) W_hh = np.random.rand(3, 3) b_h = np.random.rand(3) simple_rnn(X, W_hx, W_hh, b_h) 

In diesem Beispiel implementieren wir eine einfache RNN-Funktion in Python. Die Funktion rnn_step berechnet den versteckten Zustand für einen gegebenen Zeitschritt. Die Funktion simple_rnn iteriert durch die gesamte Eingabesequenz und gibt die versteckten Zustände aus.

b)

(b) Vanishing Gradient Problem:

Beschreibe das Problem des verschwindenden Gradienten bei einem RNN. Warum tritt es auf und wie wirkt es sich auf das Training der Modelle aus? Verwende dazu geeignete mathematische Herleitungen und Erläuterungen. Gehe dabei auf die Kettenregel der Ableitung ein und zeige, wie die Gradienten mit zunehmender Länge der Sequenz beeinflusst werden:

\(\delta_t = \frac{\partial L}{\partial h_t} \cdot \frac{\partial h_t}{\partial h_{t-1}} \cdot … \cdot \frac{\partial h_1}{\partial h_0}\)

Lösung:

Das Problem des verschwindenden Gradienten ist ein bekanntes mathematisches Phänomen, das besonders bei Recurrent Neural Networks (RNNs) auftritt und das Training dieser Modelle erheblich erschweren kann. Dieses Problem tritt auf, wenn die Gradienten, die während des Backpropagation Through Time (BPTT) berechnet werden, exponentiell kleiner werden.

• Das Problem resultiert aus der Kettenregel der Ableitung, die bei der Rückpropagierung durch viele Zeitschritte angewendet wird. Bei jedem Zeitschritt wird der Gradient um einen weiteren Part, der kleiner als 1 sein kann, multipliziert.
• Mathematisch kann dies wie folgt dargestellt werden:

\(\delta_t = \frac{\partial L}{\partial h_t} \cdot \frac{\partial h_t}{\partial h_{t-1}} \cdot \frac{\partial h_{t-1}}{\partial h_{t-2}} \cdot ... \cdot \frac{\partial h_1}{\partial h_0}\)

Hierbei bezeichnet \(\delta_t\) den Gradienten des Verlusts \( L \) bezüglich des versteckten Zustands \( h_t \).

• Für ein RNN gilt die folgende Update-Formel für den versteckten Zustand:

\( h_t = \tanh(W_{hx} x_t + W_{hh} h_{t-1} + b_h) \)

• Die Ableitung der Verlustfunktion \( L \) bezüglich \( h_t \) kann durch die Kettenregel geschrieben werden als:

\( \frac{\partial L}{\partial h_t} \cdot \frac{\partial h_t}{\partial h_{t-1}} = \frac{\partial L}{\partial h_t} \cdot \frac{\partial \tanh(W_{hx} x_t + W_{hh} h_{t-1} + b_h)}{\partial h_{t-1}} \)

• Die Ableitung der \(\tanh\)-Funktion führt zu einem Faktor, der kleiner als 1 ist.
• Wenn wir dies über viele Zeitschritte zurück propagieren, insbesondere wenn \(W_{hh}\) kleine Werte hat, führt dies dazu, dass:

\( \delta_t = \delta_t \cdot c^t \)

wobei \(c\) eine Konstante kleiner als 1 ist, was bedeutet, dass \(\delta_t\) exponentiell kleiner wird.

Je länger die Sequenz ist, desto kleiner werden die Gradienten, was zum sogenannten „Verlust von Langzeiterinnerungen“ führt.

Wie wirkt es sich auf das Training aus?
• Die Gewichte in den früheren Schichten des Netzwerks werden fast nicht aktualisiert, da die Gradienten fast zu null werden.
• Das Netzwerk hat Schwierigkeiten, Langzeitabhängigkeiten in den Daten zu erlernen, was die Qualität des Modells verringert.

Ein Diagramm, das die schrittweise Abnahme der Gradienten zeigt, könnte hilfreich sein, um das exponentielle Schrumpfen visualisieren. Man kann sehen, wie die Gradienten für tiefe Schichten gegen null tendieren, was langfristige Abhängigkeiten im Modell zerstört.

Lösungsansätze:
• Long Short-Term Memory (LSTM)-Netzwerke sind speziell darauf ausgelegt, dieses Problem zu mildern. Sie verwenden Vergessens- und Erinnerungszellen, um sich längerfristige Abhängigkeiten besser zu merken.

Zusammenfassend tritt das Problem des verschwindenden Gradienten auf, weil die Gradienten bei der Rückpropagierung durch die vielen Zeitschritte des RNNs exponentiell kleiner werden können. Dies erschwert das Training der Modelle und verhindert, dass das Netzwerk Langzeitabhängigkeiten erlernt.

c)

(c) LSTM Zellzustände und Gates:

Beschreibe die Hauptkomponenten eines LSTM Netzwerks, insbesondere die Struktur der LSTM-Zelle. Erkläre die Funktion der verschiedenen Gates: das Eingangstor, das Vergessens-Tor, und das Ausgangstor. Zeige die mathematischen Formeln für die Updates der Zellzustände und die Berechnung der Ausgabe der Zelle:

• Eingangstor Formel:

  \(i_t = \sigma(W_{ix}x_t + W_{ih}h_{t-1} + b_i)\)

• Vergessens-Tor Formel:

  \(f_t = \sigma(W_{fx}x_t + W_{fh}h_{t-1} + b_f)\)

• Ausgangstor Formel:

  \(o_t = \sigma(W_{ox}x_t + W_{oh}h_{t-1} + b_o)\)

• Zellzustands Update:

  \(C_t = f_t * C_{t-1} + i_t * \tanh(W_{cx}x_t + W_{ch}h_{t-1} + b_c)\)

• Output:

  \(h_t = o_t * \tanh(C_t)\)

Implementiere eine Beispiel-LSTM Zelle in Python unter Nutzung der NumPy Bibliothek.

Lösung:

Ein Long Short-Term Memory (LSTM) Netzwerk stellt eine spezielle Art von RNN dar, das entwickelt wurde, um das Problem des verschwindenden Gradienten zu vermeiden und sich besser langfristige Abhängigkeiten in Daten zu merken. Eine LSTM-Zelle besteht aus verschiedenen speziellen Komponenten und Gates, die ihre Funktion ermöglichen.

Hauptkomponenten eines LSTM Netzwerks:
• Zellzustand (\(C_t\)): Dieser speichert die Informationen über längere Zeiträume.
• Eingangs-, Vergessens- und Ausgangs-Gates: Diese steuern den Fluss der Informationen innerhalb der Zelle.
Funktion der verschiedenen Gates:

Gates verwenden die Sigmoid-Funktion (\(\sigma\)), die einen Wert zwischen 0 und 1 ausgibt. Dies erlaubt dem Modell, bestimmte Informationen mehr oder weniger durchzulassen.

• Eingangstor (Input Gate \(i_t\)): Entscheidet, wie viel der neuen Informationen gespeichert werden.
• Vergessens-Tor (Forget Gate \(f_t\)): Entscheidet, welche Teile der Informationen vergessen werden sollen.
• Ausgangstor (Output Gate \(o_t\)): Entscheidet, welche Informationen als Ausgang gesendet werden.
Mathematische Formeln und Berechnungen:
• Eingangstor Formel:

  \(i_t = \sigma(W_{ix}x_t + W_{ih}h_{t-1} + b_i)\)

• Vergessens-Tor Formel:

  \(f_t = \sigma(W_{fx}x_t + W_{fh}h_{t-1} + b_f)\)

• Ausgangstor Formel:

  \(o_t = \sigma(W_{ox}x_t + W_{oh}h_{t-1} + b_o)\)

• Zellzustands-Update:

  \(C_t = f_t * C_{t-1} + i_t * \tanh(W_{cx}x_t + W_{ch}h_{t-1} + b_c)\)

• Output:

  \(h_t = o_t * \tanh(C_t)\)

Implementierung einer Beispiel-LSTM Zelle in Python:

import numpy as np  def sigmoid(x): return 1 / (1 + np.exp(-x))  def lstm_cell(x_t, h_prev, C_prev, W_i, W_f, W_o, W_c, b_i, b_f, b_o, b_c): # Eingangs-Gate i_t = sigmoid(np.dot(W_i, x_t) + np.dot(W_i.T, h_prev) + b_i)  # Vergessens-Tor f_t = sigmoid(np.dot(W_f, x_t) + np.dot(W_f.T, h_prev) + b_f)  # Ausgangstor o_t = sigmoid(np.dot(W_o, x_t) + np.dot(W_o.T, h_prev) + b_o)  # Zellzustands-Update C_t = f_t * C_prev + i_t * np.tanh(np.dot(W_c, x_t) + np.dot(W_c.T, h_prev) + b_c)  # Zellausgabe h_t = o_t * np.tanh(C_t)  return h_t, C_t  # Beispielwerte für Gewichte und Biases input_dim = 4 hidden_dim = 3  W_i = np.random.rand(hidden_dim, input_dim) W_f = np.random.rand(hidden_dim, input_dim) W_o = np.random.rand(hidden_dim, input_dim) W_c = np.random.rand(hidden_dim, input_dim)  b_i = np.random.rand(hidden_dim) b_f = np.random.rand(hidden_dim) b_o = np.random.rand(hidden_dim) b_c = np.random.rand(hidden_dim)  # Beispiel-Input x_t = np.random.rand(input_dim) h_prev = np.random.rand(hidden_dim) C_prev = np.random.rand(hidden_dim)  h_t, C_t = lstm_cell(x_t, h_prev, C_prev, W_i, W_f, W_o, W_c, b_i, b_f, b_o, b_c)  print(f'h_t: {h_t}') print(f'C_t: {C_t}') 

In dieser Implementierung haben wir eine einfache LSTM Zelle in Python mit der NumPy Bibliothek erstellt. Die Funktion lstm_cell berechnet den Zustand und die Ausgabe der LSTM Zelle basierend auf den Eingangs-, Vergessens- und Ausgangs-Gates sowie dem vorherigen Zustand und Input.

Aufgabe 4)

Emotionserkennung in MusikIn dieser Aufgabe wirst Du die emotionale Klassifikation von Musikstücken mithilfe von Deep-Learning-Techniken untersuchen. Du wirst tiefer in die Verwendung von neuronalen Netzen für die Merkmalsextraktion und Klassifikation eintauchen und verschiedene Leistungsbewertungsmetriken anwenden.

• Verwendung neuronaler Netze wie CNNs oder RNNs zur Merkmalsextraktion und Klassifikation.
• Oft genutzte Merkmale: Melodie, Harmonie, Rhythmus, Tempo, Timbre.
• Beispiele für Datensätze: DEAM (Database for Emotion Analysis in Music), EMO-DB.
• Leistungsbewertung: Precision, Recall, F1-Score, ROC-Kurve.

a)

Gegeben sei ein Datensatz mit Musiktiteln und ihren zugehörigen emotionalen Labels.Entwerfe ein neuronales Netzwerkmodell basierend auf Convolutional Neural Networks (CNNs), um die emotionalen Inhalte in den Musikstücken zu klassifizieren. Beschreibe detailliert die Architektur des Modells und erkläre die Wahl der Hyperparameter. Nutze den DEAM-Datensatz für dein Modelltraining und evaluiere die Modellleistung anhand von Precision, Recall und F1-Score.

Lösung:

Entwurf eines neuronalen Netzwerks zur Emotionserkennung in Musik

• Einleitung: In dieser Teilaufgabe wirst Du ein neuronales Netzwerk auf Basis von Convolutional Neural Networks (CNNs) entwerfen, um Emotionen in Musik zu klassifizieren. Du wirst den DEAM-Datensatz verwenden und die Leistung des Modells anhand von Precision, Recall und F1-Score bewerten.
• Schritt-für-Schritt-Lösung:

1. Vorverarbeitung der Daten:Zuerst extrahierst Du relevante Merkmale wie Melodie, Harmonie, Rhythmus, Tempo und Timbre aus den Musikstücken im DEAM-Datensatz. Dies kann durch Feature-Extraction-Tools wie Librosa erfolgen.

import librosaimport numpy as npimport osdef extract_features(file_path):    y, sr = librosa.load(file_path, duration=30)    # Mel Spectrogram    mel_spec = librosa.feature.melspectrogram(y, sr=sr, n_mels=128)    mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)    return mel_spec_db

2. Architektur des CNN-Modells:Die Architektur sollte mindestens drei Convolutional Layers, gefolgt von Max-Pooling, dann ein oder zwei Fully-Connected Layers beinhalten. Dies sind die typischen Schichten eines CNN zur Merkmalsextraktion und Klassifikation.

   from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Densefrom tensorflow.keras.optimizers import Adammodel = Sequential()# 1st Conv Layermodel.add(Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 1)))model.add(MaxPooling2D((2, 2)))# 2nd Conv Layermodel.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D((2, 2)))# 3rd Conv Layermodel.add(Conv2D(128, (3, 3), activation='relu'))model.add(MaxPooling2D((2, 2)))# Flattenmodel.add(Flatten())# Fully Connected Layermodel.add(Dense(128, activation='relu'))# Output Layermodel.add(Dense(num_classes, activation='softmax'))model.compile(optimizer=Adam(),              loss='categorical_crossentropy',              metrics=['accuracy'])

3. Erklärung der Hyperparameter:Die Wahl der Hyperparameter wie die Anzahl der Filter (32, 64, 128) und die Filtergrößen (3x3) basiert auf der Fähigkeit, unterschiedliche Merkmale in den Musikdaten zu erfassen. - Die Aktivierungsfunktion 'ReLU' hilft dabei, nicht-lineare Muster zu erlernen.- Der Optimizer 'Adam' wird wegen seiner Effizienz und geringen Speicheranforderungen verwendet.- 'categorical_crossentropy' wird als Verlustfunktion genutzt, weil es sich um ein mehrklassiges Klassifikationsproblem handelt.
4. Training des Modells:Trainiere das Modell mit dem DEAM-Datensatz und evaluiere die Leistung:

from tensorflow.keras.utils import to_categoricalfrom sklearn.model_selection import train_test_split# Annahme: features und labels sind numpy arrays mit den Extrahierten Features bzw. LabelsX_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)y_train = to_categorical(y_train, num_classes)y_test = to_categorical(y_test, num_classes)history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

5. Leistungsbewertung:Berechne Precision, Recall und F1-Score für die Modellbewertung:

   from sklearn.metrics import classification_reporty_pred = model.predict(X_test)y_pred_classes = np.argmax(y_pred, axis=1)y_test_classes = np.argmax(y_test, axis=1)report = classification_report(y_test_classes, y_pred_classes, target_names=emotion_labels)print(report)

   Ergebnis:Der Bericht liefert Precision, Recall und F1-Score für jede Emotion und eine Gesamtbewertung.

b)

Erweiterung der Übung:Implementiere Recurrent Neural Networks (RNNs) für dieselbe Aufgabe. Vergleiche die Ergebnisse mit denen des CNN-Modells. Betrachte dabei nicht nur die Leistungsmetriken Precision, Recall und F1-Score, sondern auch die ROC-Kurve. Diskutiere, welches Modell besser zur Emotionserkennung in Musik geeignet ist und warum.

Lösung:

Implementierung und Vergleich von Recurrent Neural Networks (RNNs) zur Emotionserkennung in Musik

• Einleitung: In dieser erweiterten Aufgabe wirst Du Recurrent Neural Networks (RNNs) für die emotionale Klassifikation von Musikstücken implementieren und die Ergebnisse vergleichen mit dem CNN-Modell aus der vorherigen Übung. Der Vergleich erfolgt anhand der Leistungsmetriken Precision, Recall, F1-Score und ROC-Kurve.

1. Vorverarbeitung der Daten:Die Merkmalsextraktion erfolgt wie vorher beschrieben mit Librosa.

   import librosaimport numpy as npimport osdef extract_features(file_path):    y, sr = librosa.load(file_path, duration=30)    # Mel Spectrogram    mel_spec = librosa.feature.melspectrogram(y, sr=sr, n_mels=128)    mel_spec_db = librosa.power_to_db(mel_spec, ref=np.max)    return mel_spec_db

2. Architektur des RNN-Modells:Die Architektur des RNN-Modells enthält LSTM-Schichten (Long Short-Term Memory) zur Sequenzverarbeitung und kann z.B. so aussehen:

   from tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import LSTM, Dense, Dropoutfrom tensorflow.keras.optimizers import Adammodel = Sequential()# LSTM Layermodel.add(LSTM(128, return_sequences=True, input_shape=(128, 128)))model.add(Dropout(0.3))model.add(LSTM(128, return_sequences=True))model.add(Dropout(0.3))model.add(LSTM(128))model.add(Dropout(0.3))# Fully Connected Layermodel.add(Dense(128, activation='relu'))# Output Layermodel.add(Dense(num_classes, activation='softmax'))model.compile(optimizer=Adam(),              loss='categorical_crossentropy',              metrics=['accuracy'])

3. Erklärung der Hyperparameter:- Die LSTM-Schichten mit 128 Einheiten helfen, zeitliche Abhängigkeiten in den Musikdaten zu erlernen.- 'Dropout' wird verwendet, um Überanpassung (Overfitting) zu reduzieren.- Es wird der gleiche Optimizer und die gleiche Verlustfunktion wie beim CNN verwendet.
4. Training des Modells:Trainiere das RNN-Modell mit dem DEAM-Datensatz wie vorher:

   from tensorflow.keras.utils import to_categoricalfrom sklearn.model_selection import train_test_split# Annahme: features und labels sind numpy arrays mit den Extrahierten Features bzw. LabelsX_train, X_test, y_train, y_test = train_test_split(features, labels, test_size=0.2, random_state=42)y_train = to_categorical(y_train, num_classes)y_test = to_categorical(y_test, num_classes)history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_test, y_test))

5. Leistungsbewertung:Berechne Precision, Recall, F1-Score und ROC-Kurve für beide Modelle:

   from sklearn.metrics import classification_report, roc_curve, aucimport matplotlib.pyplot as plt# CNN Modelly_pred_cnn = cnn_model.predict(X_test)y_pred_cnn_classes = np.argmax(y_pred_cnn, axis=1)print(classification_report(y_test_classes, y_pred_cnn_classes, target_names=emotion_labels))# RNN Modelly_pred_rnn = rnn_model.predict(X_test)y_pred_rnn_classes = np.argmax(y_pred_rnn, axis=1)print(classification_report(y_test_classes, y_pred_rnn_classes, target_names=emotion_labels))# ROC-Kurve für CNN Modellfpr_cnn, tpr_cnn, _ = roc_curve(y_test.ravel(), y_pred_cnn.ravel())roc_auc_cnn = auc(fpr_cnn, tpr_cnn)plt.plot(fpr_cnn, tpr_cnn, label='ROC curve of CNN (area = %0.2f)' % roc_auc_cnn)# ROC-Kurve für RNN Modellfpr_rnn, tpr_rnn, _ = roc_curve(y_test.ravel(), y_pred_rnn.ravel())roc_auc_rnn = auc(fpr_rnn, tpr_rnn)plt.plot(fpr_rnn, tpr_rnn, label='ROC curve of RNN (area = %0.2f)' % roc_auc_rnn)plt.xlabel('False Positive Rate')plt.ylabel('True Positive Rate')plt.legend(loc='best')plt.show()

6. Diskussion der Ergebnisse:Vergleiche die Ergebnisse aus den Leistungsmetriken und der ROC-Kurve:

• Performance Metriken: Anhand von Precision, Recall und F1-Score lässt sich ablesen, welches Modell in der Emotionserkennung besser abschneidet.
• ROC-Kurve: Die Fläche unter der ROC-Kurve (AUC) gibt an, wie gut das Modell zwischen Klassen unterscheidet. Ein höherer AUC-Wert bedeutet eine bessere Unterscheidung.
• Erklärung: CNNs sind oft besser bei der Verarbeitung von räumlichen Merkmalen und Mustern, während RNNs besser für die Analyse von zeitlichen Sequenzen geeignet sind. Je nach den Eigenschaften der Musikanalyse könnte eines der beiden Modelle besser geeignet sein.