Research Project on Intelligent Sensorimotor Systems - Exam

Aufgabe 2)

Algorithmen für Datenverarbeitung und -analyse: Du arbeitest an einem Projekt, bei dem es darum geht, Sensordaten von einem intelligenten Sensor zu verarbeiten und zu analysieren. Die Daten enthalten verschiedene Messwerte von mehreren Sensoren und haben einige Herausforderungen wie verrauschte Daten, fehlende Werte und unterschiedliche Skalierungen der Daten. Deine Aufgabe besteht darin, die Daten für die Analyse vorzubereiten und verschiedene Maschinelle Lernmodelle anzuwenden, um Erkenntnisse zu gewinnen. Du sollst die Daten zunächst vorverarbeiten und bereinigen, dann wichtige Features extrahieren und schließlich geeignete Analysealgorithmen verwenden.

a)

Die gesammelten Sensordaten enthalten viele fehlende Werte und sind in unterschiedlichen Skalen dargestellt. Beschreibe ausführlich, welche Schritte Du unternehmen würdest, um die Daten zu normalisieren und die fehlenden Werte zu behandeln. Verwende dazu die Methoden der Datenvorverarbeitung wie Normalisierung, Skalierung und Umgang mit fehlenden Werten. Verwende mathematische Formeln, wenn nötig, um Deine Vorgehensweise zu erläutern.

Lösung:

Schritte zur Normalisierung der Daten und Behandlung fehlender Werte:

• Verstehen der Daten: Zuerst muss ich die Daten einlesen und eine erste Analyse durchführen, um zu verstehen, welche Werte fehlen und wie die Daten skaliert sind. Dies umfasst die Verwendung von Deskriptivstatistiken und das Erstellen von Visualisierungen.
• Behandlung fehlender Werte: Es gibt verschiedene Strategien, um mit fehlenden Daten umzugehen:
  • Entfernen fehlender Werte: Wenn nur wenige Datenpunkte fehlen, könnten diese Zeilen oder Spalten entfernt werden. Dies kann jedoch zu einem erheblichen Verlust an Informationen führen.

     import pandas as pd data = data.dropna() 

  • Imputation: Fehlende Werte können durch den Durchschnitt, Median oder Modus der jeweiligen Spalte ersetzt werden.

     from sklearn.impute import SimpleImputer  imputer = SimpleImputer(strategy='mean') data_imputed = imputer.fit_transform(data) 

  • Erweiterte Imputation: Methoden wie k-Nearest Neighbors (k-NN) können verwendet werden, um fehlende Werte besser vorherzusagen.

     from sklearn.impute import KNNImputer  imputer = KNNImputer(n_neighbors=5) data_imputed = imputer.fit_transform(data) 

• Normalisierung und Skalierung: Unterschiedliche Sensoren könnten Daten auf verschiedenen Skalen erfassen. Um sicherzustellen, dass alle Daten auf einer vergleichbaren Skala liegen, müssen sie skaliert werden.
  • Min-Max Scalar: Diese Methode skaliert die Daten in einen Bereich \[0,1\] mit der folgenden Formel: \[ X_{norm} = \frac{X - X_{min}}{X_{max} - X_{min}} \]

     from sklearn.preprocessing import MinMaxScaler scaler = MinMaxScaler() data_normalized = scaler.fit_transform(data_imputed) 

  • Z-Score Skalierung (Standardisierung): Diese Methode skaliert die Daten, indem sie den Mittelwert subtrahiert und durch die Standardabweichung teilt. Sie ist nützlich, wenn die Daten eine Normalverteilung haben. \[ X_{scaled} = \frac{X - \mu}{\sigma} \]

     from sklearn.preprocessing import StandardScaler scaler = StandardScaler() data_scaled = scaler.fit_transform(data_imputed) 

• Feature-Engineering: Nachdem die Daten normalisiert und fehlende Werte behandelt wurden, können wichtige Features extrahiert werden, um die Leistungsfähigkeit der Maschinenlernmodelle zu verbessern. Dazu gehören Techniken wie PCA (Principal Component Analysis) oder Feature Selektion basierend auf der Bedeutung (Feature Importance).

   from sklearn.decomposition import PCA  pca = PCA(n_components=10) data_pca = pca.fit_transform(data_scaled) 

b)

Nimm an, dass die Sensordaten verrauschte und unnötige Daten enthalten. Erkläre detailliert, welche Techniken und Algorithmen Du anwenden würdest, um die Daten zu bereinigen. Gehe dabei auf Methoden zum Entfernen von Ausreißern und Rauschen ein. Implementiere einen einfachen Python-Code, der zeigt, wie man Ausreißer anhand der z-Score-Methode identifiziert und entfernt.

Lösung:

Techniken und Algorithmen zum Bereinigen von verrauschten und unnötigen Daten:

• Entfernen von Rauschen:
  • Glättung mittels gleitendem Durchschnitt: Diese Methode hilft, schwankende Daten zu glätten, indem sie den Durchschnitt einer festen Anzahl von benachbarten Datenpunkten berechnet. Die Formel für einen gleitenden Durchschnitt mit Fenstergröße \(w\) ist: \[ \text{MA}_t = \frac{1}{w} \sum_{i=t-w+1}^{t} x_i \]

     import pandas as pd data['smoothed'] = data['value'].rolling(window=5).mean() 

  • Median-Filter: Diese Methode ersetzt jeden Datenpunkt durch den Median der benachbarten Werte in einem definierten Fenster. Sie ist besonders effektiv bei impulsartigem Rauschen.

     from scipy.ndimage import median_filter data['filtered'] = median_filter(data['value'], size=3) 

• Entfernen von Ausreißern:
  • Z-Score-Methode: Diese Methode verwendet den z-Score, um Ausreißer zu identifizieren. Datenpunkte, deren z-Score einen bestimmten Schwellenwert überschreitet (typischerweise 3), werden als Ausreißer betrachtet und entfernt. Die Formel für den z-Score ist: \[ z = \frac{X - \mu}{\sigma} \] Implementierung der z-Score-Methode in Python:

     import numpy as np import pandas as pd from scipy import stats # Beispiel-Daten erstellen np.random.seed(0) data = pd.DataFrame({'value': np.random.randn(100)}) # Ausreißer hinzufügen data.loc[::10, 'value'] += np.random.rand(10) * 20 def remove_outliers_zscore(data, threshold=3): z_scores = np.abs(stats.zscore(data)) filtered_entries = (z_scores < threshold).all(axis=1) return data[filtered_entries] # Ausreißer entfernen data_cleaned = remove_outliers_zscore(data) 

  • Interquartilsabstand (IQR-Methode): Diese Methode verwendet den Interquartilsabstand, um Ausreißer zu identifizieren. Datenpunkte außerhalb des Bereichs \[Q1 - 1.5 \times IQR, Q3 + 1.5 \times IQR\] werden als Ausreißer betrachtet.

     def remove_outliers_iqr(data): Q1 = data.quantile(0.25) Q3 = data.quantile(0.75) IQR = Q3 - Q1 filter = (data >= (Q1 - 1.5 * IQR)) & (data <= (Q3 + 1.5 * IQR)) return data[filter] # Ausreißer entfernen data_cleaned_iqr = remove_outliers_iqr(data['value']) 

Diese Methoden ermöglichen eine effektive Bereinigung der Sensordaten, um die Qualität der nachfolgenden Analyse zu verbessern.

c)

Nachdem die Daten bereinigt wurden, möchtest Du wichtige Features extrahieren, um die Daten dimensional zu reduzieren. Diskutiere die Unterschiede zwischen Principal Component Analysis (PCA) und Linear Discriminant Analysis (LDA). Implementiere einen Python-Code, der PCA auf den bereinigten Datensatz anwendet, und visualisiere die ersten beiden Hauptkomponenten in einem Streudiagramm.

Lösung:

Unterschiede zwischen Principal Component Analysis (PCA) und Linear Discriminant Analysis (LDA):

• Ziel:
  • PCA: Ziel ist es, die Daten in eine Richtung zu transformieren, dass die Varianz maximiert wird. PCA ist eine unüberwachte Methode, das heißt, sie berücksichtigt keine Klasseninformationen.
  • LDA: Ziel ist es, die Klassenunterschiede zu maximieren. LDA ist eine überwachende Methode, das heißt, sie berücksichtigt die Klassenlabels der Daten.
• Anwendungsfall:
  • PCA: Wird zur Reduktion der Dimensionen verwendet und betont die lineare Variabilität im gesamten Datensatz.
  • LDA: Wird vor allem zur Reduktion der Dimension für Klassifikationsaufgaben genutzt, wobei sie die trenbaren Merkmale zwischen unterschiedlichen Klassen hervorhebt.
• Berechnung:
  • PCA: Berechnet die Eigenvektoren und Eigenwerte der Datenkovarianzmatrix und projiziert die Daten auf die Hauptkomponenten mit den höchsten Eigenwerten.
  • LDA: Berechnet die Eigenvektoren und Eigenwerte der Streuungsmatrizen zwischen und innerhalb der Klassen und maximiert das Verhältnis dieser Streuungen.

 import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.decomposition import PCA # Beispiel-Daten erstellen np.random.seed(0) data = pd.DataFrame({ 'feature1': np.random.randn(100), 'feature2': np.random.randn(100), 'feature3': np.random.randn(100) }) # Bereinigungsschritt: z-Score-Methode zum Entfernen von Ausreißern def remove_outliers_zscore(data, threshold=3): from scipy import stats z_scores = np.abs(stats.zscore(data)) filtered_entries = (z_scores < threshold).all(axis=1) return data[filtered_entries] # Bereinigte Daten data_cleaned = remove_outliers_zscore(data) # PCA anwenden pca = PCA(n_components=2) principal_components = pca.fit_transform(data_cleaned) # Zu DataFrame konvertieren principal_df = pd.DataFrame(data = principal_components, columns = ['PC1', 'PC2']) # Streudiagramm der ersten beiden Hauptkomponenten plt.figure(figsize=(8, 6)) plt.scatter(principal_df['PC1'], principal_df['PC2'], s = 50) plt.title('PCA - Erste zwei Hauptkomponenten') plt.xlabel('PC1') plt.ylabel('PC2') plt.grid() plt.show() 

• Wir erstellen Zufallsdaten für das Beispiel und bereinigen diese durch Entfernen von Ausreißern mittels der z-Score-Methode.
• Wir wenden PCA auf den bereinigten Datensatz an und extrahieren die ersten zwei Hauptkomponenten.
• Wir visualisieren diese Hauptkomponenten in einem Streudiagramm, um die Verteilung der Daten entlang der Hauptkomponenten zu sehen.

d)

Wende nun einen Klassifikationsalgorithmus auf die vorbereiteten Daten an. Beschreibe den Algorithmus der zu Anwendung kommt (z. B. k-Nächste-Nachbarn, Support Vector Machine, etc.) und erkläre, wie Du das Modell trainierst und evaluierst. Berechne die Metriken Accuracy, Precision, Recall und F1-Score. Implementiere den gesamten Prozess von der Datenaufbereitung bis zur Evaluierung des Klassifikationsmodells in Python.

Lösung:

Klassifikationsalgorithmus: Support Vector Machine (SVM)

Ein Support Vector Machine (SVM) ist ein überwacht lernender Klassifikationsalgorithmus, der versucht, eine optimale Trennlinie (Hyperplane) zwischen Datenpunkten verschiedener Klassen zu finden. Der Hauptvorteil von SVMs ist ihre Fähigkeit, sowohl lineare als auch nicht-lineare Klassifikationen durch Verwendung verschiedener Kernelfunktionen (z.B. linear, radial) durchzuführen.

• Datenaufbereitung: Datensätze laden, bereinigen, normalisieren und wichtige Features extrahieren. (Dieser Schritt basiert auf den vorherigen Antworten.)
• Modell-Training: Den SVM-Klassifikator auf den vorbereiteten Trainingsdaten trainieren.
• Modell-Evaluierung: Die Modellleistung anhand von Metriken wie Accuracy, Precision, Recall und F1-Score bewerten.

 import numpy as np import pandas as pd from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split from sklearn.svm import SVC from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # Beispiel-Daten erstellen np.random.seed(0) data = pd.DataFrame({ 'feature1': np.random.randn(200), 'feature2': np.random.randn(200), 'feature3': np.random.randn(200), 'label': np.random.choice([0, 1], size=200) }) # Bereinigungsschritt: z-Score-Methode zum Entfernen von Ausreißern def remove_outliers_zscore(data, threshold=3): from scipy import stats z_scores = np.abs(stats.zscore(data.drop(columns=['label']))) filtered_entries = (z_scores < threshold).all(axis=1) return data[filtered_entries] # Bereinigte Daten data_cleaned = remove_outliers_zscore(data) # Features und Labels trennen X = data_cleaned.drop(columns=['label']) y = data_cleaned['label'] # Normalisierung skaler = StandardScaler() X_scaled = skaler.fit_transform(X) # Train-Test-Split X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.3, random_state=42) # SVM-Modell erstellen und trainieren svm_model = SVC(kernel='linear') svm_model.fit(X_train, y_train) # Modell-Vorhersagen y_pred = svm_model.predict(X_test) # Evaluierung des Modells accuracy = accuracy_score(y_test, y_pred) precision = precision_score(y_test, y_pred) recall = recall_score(y_test, y_pred) f1 = f1_score(y_test, y_pred) print(f'Accuracy: {accuracy}') print(f'Precision: {precision}') print(f'Recall: {recall}') print(f'F1-Score: {f1}') 

• Erstelle zufällige Daten für das Beispiel inkl. Labels.
• Bereinige die Daten durch Entfernen von Ausreißern mittels der z-Score-Methode.
• Trenne die bereinigten Daten in Features und Labels und normalisiere die Features.
• Teile die Daten in Trainings- und Testmengen auf.
• Erstelle und trainiere den SVM-Klassifikator.
• Führe Vorhersagen auf dem Testdatensatz durch und berechne die Metriken Accuracy, Precision, Recall und F1-Score, um die Modellleistung zu bewerten.

Aufgabe 3)

Kalman-Filter und erweiterte Kalman-FilterIn diesem Übungsblatt wirst Du Kalman-Filter und erweiterte Kalman-Filter anwenden. Der Kalman-Filter ist ein Schätzverfahren, das Zustandsgrößen dynamischer Systeme mit Rauschen beschreibt. Der erweiterte Kalman-Filter ist eine Erweiterung für nichtlineare Systeme.

• Kalman-Filter nutzt Zustands- und Messrauschen, um Schätzwerte zu verbessern.
• Annahmen: Lineares Modell, Gaußsches Rauschen.
• Zustandsvorhersage: \( \bar{x}_k = A_k x_{k-1} + B_k u_{k} + w_{k} \)
• Messvorhersage: \( \bar{z}_k = H_k \bar{x}_k + v_k \)
• Aufdatierung: \( K_k = P_k H_k^T (H_k P_k H_k^T + R_k )^{-1} \)
• Ergebnis: \( x_k = \bar{x}_k + K_k (z_k - \bar{z}_k) \)
• Erweiterter Kalman-Filter: Approximiert nichtlineare Modelle durch Linearisierung.
• Zustandsvorhersage: \( \bar{x}_k = f(x_{k-1}, u_k) + w_k \)
• Messvorhersage: \( \bar{z}_k = h(\bar{x}_k) + v_k \)

• Zustandsraumdarstellung: \( \mathbf{x}_{k} = A \mathbf{x}_{k-1} + B \mathbf{u}_k + \mathbf{w}_k \)
• Beobachtungsmodell: \( \mathbf{z}_k = H \mathbf{x}_k + \mathbf{v}_k \)
• Nebenbedingungen: \(\mathbf{w}_k\) und \(\mathbf{v}_k\) sind unabhängige, gaußsche Zufallsgrößen mit Mittelwert null und Kovarianzmatrizen \(Q\) und \(R\) jeweils.

b)

2. Messvorhersage: Gegeben das Beobachtungsmodell: \( \mathbf{z}_k = H \mathbf{x}_k + \mathbf{v}_k \). Sei \( H = \begin{bmatrix} 1 & 0 \end{bmatrix} \). Bestimme die Messvorhersage \( \bar{z}_k \) unter der Annahme, dass \( \mathbf{v}_k \sim \mathcal{N}(\mathbf{0}, R) \) und \( R = \sigma_v^2 \).

Lösung:

Messvorhersage:

Gegeben sei das Beobachtungsmodell:

• \[ \mathbf{z}_k = H \mathbf{x}_k + \mathbf{v}_k \]

Sei \( H = \begin{bmatrix} 1 & 0 \end{bmatrix} \). Dann lautet die Messvorhersage \( \bar{z}_k \) unter der Annahme, dass \( \mathbf{v}_k \sim \mathcal{N}(\mathbf{0}, R) \) und \( R = \sigma_v^2 \):

• \[ \bar{z}_k = H \bar{x}_k + \mathbf{v}_k \]

Da \( H = \begin{bmatrix} 1 & 0 \end{bmatrix} \), wirkt es nur auf den ersten Eintrag des Zustandsvektors \( \bar{x}_k \). Somit:

• \[ \bar{z}_k = \begin{bmatrix} 1 & 0 \end{bmatrix} \begin{bmatrix} \bar{x}_k^1 \ \bar{x}_k^2 \end{bmatrix} \]

Das ergibt:

• \[ \bar{z}_k = \bar{x}_k^1 \]

Da \( \mathbf{v}_k \sim \mathcal{N}(\mathbf{0}, R) \) mit \( R = \sigma_v^2 \), ist der Messrauschterm \( \mathbf{v}_k \) ein gaußsches Rauschen mit Mittelwert null und Varianz \( \sigma_v^2 \). Dies fügt der Messvorhersage zufällige Variabilität hinzu.

c)

3. Kalman-Gain Berechnung: Berechne die Kalman-Gain-Matrix \( K_k \) mit \( P_k \) als Fehlerkovarianzmatrix, gegeben \( K_k = P_k H^T (H P_k H^T + R )^{-1} \). Verifiziere die Dimensionen der Matrizen für die Berechnung und gib an, wozu die Kalman-Gain-Matrix in diesem Kontext verwendet wird.

Lösung:

Kalman-Gain Berechnung:

Gegeben sei die Kalman-Gain-Matrix:

• \[K_k = P_k H^T (H P_k H^T + R )^{-1}\]

Angenommen, wir haben folgende Dimensionen:

• \(P_k\) ist die Fehlerkovarianzmatrix mit Dimension \(2 \times 2\),
• \(H\) ist die Beobachtungsmatrix mit Dimension \(1 \times 2\),
• \(R\) ist die Kovarianzmatrix des Messrauschens mit Dimension \(1 \times 1\).

Berechnung der Kalman-Gain-Matrix:

• Erster Schritt: Berechnung von \(H P_k H^T\)

• \[H P_k H^T = \begin{bmatrix} 1 & 0 \end{bmatrix} \begin{bmatrix} P_{k11} & P_{k12} \ P_{k21} & P_{k22} \end{bmatrix} \begin{bmatrix} 1 \ 0 \end{bmatrix} = P_{k11}\]

• Zweiter Schritt: Berechnung von \(H P_k H^T + R\)

• \[H P_k H^T + R = P_{k11} + \sigma_v^2\]

Da dies eine \(1 \times 1\) Matrix ist, ist der Inverse einfach:

• \[(H P_k H^T + R )^{-1} = \frac{1}{P_{k11} + \sigma_v^2}\]

• Dritter Schritt: Berechnung von \(P_k H^T\)

• \[P_k H^T = \begin{bmatrix} P_{k11} & P_{k12} \ P_{k21} & P_{k22} \end{bmatrix} \begin{bmatrix} 1 \ 0 \end{bmatrix} = \begin{bmatrix} P_{k11} \ P_{k21}\end{bmatrix}\]

• Letzter Schritt: Berechnung der Kalman-Gain-Matrix

• \[K_k = \begin{bmatrix} P_{k11} \ P_{k21} \end{bmatrix} \frac{1}{P_{k11} + \sigma_v^2} = \begin{bmatrix} \frac{P_{k11}}{P_{k11} + \sigma_v^2} \ \frac{P_{k21}}{P_{k11} + \sigma_v^2} \end{bmatrix}\]

Dimensionen-Verifikation:

• \(P_k: 2 \times 2\)
• \(H^T: 2 \times 1\)
• \(H P_k H^T: 1 \times 1\)
• \(R: 1 \times 1\)
• \((H P_k H^T + R)^{-1}: 1 \times 1\)
• \(P_k H^T: 2 \times 1\)
• \(K_k: 2 \times 1\)

Die Dimensionen stimmen überein, da \(K_k\) als Produkt einer \(2 \times 1\) Matrix und einer \(1 \times 1\) Matrix definiert ist.

Verwendung der Kalman-Gain-Matrix:

Die Kalman-Gain-Matrix \(K_k\) wird verwendet, um die Zustandsvorhersage \(\bar{x}_k\) mit der Messvorhersage \(\bar{z}_k\) zu aktualisieren. Dies geschieht nach der folgenden Formel:

• \[x_k = \bar{x}_k + K_k (z_k - \bar{z}_k)\]

Hier wird der Innovationsvektor \(z_k - \bar{z}_k\), der die Diskrepanz zwischen der tatsächlichen Messung und der vorhergesagten Messung darstellt, mit der Kalman-Gain-Matrix \(K_k\) gewichtet und zu der Zustandsvorhersage \(\bar{x}_k\) addiert. Diese Gewichtung ermöglicht es dem Filter, Unsicherheiten in Messungen und Modellvorhersagen effektiv zu berücksichtigen und somit genauere Schätzungen des Systemzustands zu generieren.

d)

4. Zustandsaufdatierung: Aktualisiere den Zustand \( \mathbf{x}_k \) anhand der Messung \( \mathbf{z}_k \) mit der Gleichung: \ \mathbf{x}_k = \bar{\mathbf{x}}_k + K_k (\mathbf{z}_k - \bar{\mathbf{z}}_k) \ Gehe dabei von gegebenen Messungen \( \mathbf{z}_k \) und den in den vorherigen Aufgaben berechneten Größen aus. Beschreibe den Prozess der Zustandsaufdatierung im Kontext eines Kalman-Filters.

Lösung:

Zustandsaufdatierung:

Sei der Zustand des Systems durch den Vektor \( \mathbf{x}_k \) beschrieben, und sei \( \mathbf{z}_k \) die aktuelle Messung. Die Zustandsaufdatierung erfolgt gemäß der folgenden Gleichung:

• \[ \mathbf{x}_k = \bar{\mathbf{x}}_k + K_k (\mathbf{z}_k - \bar{\mathbf{z}}_k) \]

Die Zustandsaufdatierung umfasst die folgenden Schritte:

1. Zustandsvorhersage: Berechne die vorhergesagte Zustandsgröße \( \bar{\mathbf{x}}_k \) basierend auf dem vorangegangenen Zustand, den Kontrollgrößen und dem Systemrauschen:

2. \[ \bar{\mathbf{x}}_k = A \mathbf{x}_{k-1} + B \mathbf{u}_k + \mathbf{w}_k \]

3. Messvorhersage: Berechne die vorhergesagte Messgröße \( \bar{\mathbf{z}}_k \) basierend auf der vorhergesagten Zustandsgröße:

4. \[ \bar{\mathbf{z}}_k = H \bar{\mathbf{x}}_k + \mathbf{v}_k \]

5. Kalman-Gain Berechnung: Bestimme die Kalman-Gain-Matrix \( K_k \) mit der bereits berechneten Formel:

6. \[ K_k = P_k H^T (H P_k H^T + R)^{-1} \]

7. Innovationsvektor: Berechne den Innovationsvektor, der die Diskrepanz zwischen der tatsächlichen Messung \( \mathbf{z}_k \) und der vorhergesagten Messung \( \bar{\mathbf{z}}_k \) darstellt:

8. \[ \mathbf{y}_k = \mathbf{z}_k - \bar{\mathbf{z}}_k \]

9. Zustandsaufdatierung: Aktualisiere den vorhergesagten Zustand \( \bar{\mathbf{x}}_k \) unter Verwendung des Innovationsvektors und der Kalman-Gain-Matrix:

10. \[ \mathbf{x}_k = \bar{\mathbf{x}}_k + K_k \mathbf{y}_k \]

Hier ist ein detaillierterer Überblick über den Prozess der Zustandsaufdatierung:

1. **Zustandsvorhersage**: Dies ist der Schritt, bei dem der aktuelle Zustand des Systems geschätzt wird, basierend auf dem vorherigen Zustand und steuerbaren Einflüssen. In unserem Modell:

• \[ \bar{\mathbf{x}}_k = \begin{bmatrix} 1 & \Delta t \ 0 & 1 \end{bmatrix} \mathbf{x}_{k-1} + \begin{bmatrix} \frac{\Delta t^2}{2} \ \Delta t \end{bmatrix} \mathbf{u}_k + \mathbf{w}_k \]

2. **Messvorhersage**: Dies ist der Schritt, bei dem die erwartete Messung basierend auf der vorhergesagten Zustandsgröße berechnet wird. In unserem Modell:

• \[ \bar{\mathbf{z}}_k = \begin{bmatrix} 1 & 0 \end{bmatrix} \bar{\mathbf{x}}_k \]

3. **Kalman-Gain Berechnung**: Dies ist der gewichtete Faktor, der angibt, wie stark die Messung im Vergleich zur Zustandsvorhersage berücksichtigt werden soll.

• \[ K_k = P_k H^T (H P_k H^T + R)^{-1} \]

4. **Innovationsvektor**: Die Differenz zwischen der tatsächlichen Messung und der vorhergesagten Messung.

• \[ \mathbf{y}_k = \mathbf{z}_k - \bar{\mathbf{z}}_k \]

5. **Zustandsaufdatierung**: Der vorhergesagte Zustand wird mit dem Innovationsvektor korrigiert, gewichtet durch die Kalman-Gain-Matrix.

• \[ \mathbf{x}_k = \bar{\mathbf{x}}_k + K_k \mathbf{y}_k \]

Diese Schritte ermöglichen es dem Kalman-Filter, die Unsicherheiten in Messungen und Zuständen zu berücksichtigen und dadurch genauere Schätzungen des aktuellen Zustands des Systems zu liefern.

Aufgabe 4)

Du arbeitest an einem Forschungsprojekt über intelligente Sensorimotor-Systeme. Dein Ziel ist es, ein System zu entwickeln, das in der Lage ist, eine präzise und effiziente Bewegungssteuerung zu erreichen. Dabei nutzt Du verschiedene Modelle und Algorithmen zur Kontrolle und Koordination von Bewegungen. Verwende Dein Wissen über Computational Neuroscience, inverse Kinematik, inverse Dynamik, Regelungstechniken und maschinelles Lernen, um die folgenden Aufgaben zu lösen.

a)

Erkläre das Konzept der inversen Kinematik und beschreibe einen Algorithmus, der zur Lösung dieses Problems verwendet werden kann. Integriere eine formale mathematische Darstellung, wie die Gelenkwinkel für eine gegebene Endposition berechnet werden.

Lösung:

Konzept der Inversen Kinematik

Die inverse Kinematik ist ein Konzept in den Bereichen Robotik und Computergrafik, das sich mit der Bestimmung der Gelenkwinkel eines Systems beschäftigt, um eine spezifische Zielposition des Endeffektors zu erreichen. Während die direkte Kinematik die Position und Orientierung des Endeffektors aufgrund gegebener Gelenkwinkel berechnet, löst die inverse Kinematik das umgekehrte Problem: Sie berechnet die Gelenkwinkel, um den Endeffektor in eine gewünschte Position und Orientierung zu bringen.

Die inverse Kinematik ist von zentraler Bedeutung für die Bewegungssteuerung von Robotersystemen und die Animation von Figuren in Computerspielen und Filmen. Ein typisches Beispiel dafür ist die Berechnung der benötigten Gelenkwinkel für einen Roboterarm, um ein Objekt an einer bestimmten Position zu greifen.

Algorithmus zur Lösung des Problems der Inversen Kinematik

Ein bekannter Ansatz zur Lösung der Inversen Kinematik ist der Jacobian Transpose Algorithmus. Dieser iterative Algorithmus passt die Gelenkwinkel an, um die Differenz zwischen der aktuellen Position und der Zielposition des Endeffektors zu minimieren.

• Initialisierung: Starte mit einer anfänglichen Schätzung der Gelenkwinkel, \( \theta_{\text{initial}} \).
• Fehlerschätzung: Berechne den Positionsfehler zwischen der aktuellen Position des Endeffektors, \( \boldsymbol{p}_{\text{current}} \), und der Zielposition, \( \boldsymbol{p}_{\text{target}} \): \( \boldsymbol{e} = \boldsymbol{p}_{\text{target}} - \boldsymbol{p}_{\text{current}} \).
• Berechnung der Jacobian-Matrix: Die Jacobian-Matrix \( \textbf{J} \) beschreibt, wie Änderungen der Gelenkwinkel die Position des Endeffektors beeinflussen. Sie wird durch die partiellen Ableitungen der Position des Endeffektors bezüglich der Gelenkwinkel dargestellt: \[ \textbf{J} = \frac{\text{d} \boldsymbol{p}}{\text{d} \boldsymbol{\theta}} \]
• Aktualisierung der Gelenkwinkel: Aktualisiere die Gelenkwinkel basierend auf der transponierten Jacobian-Matrix: \( \theta_{\text{new}} = \theta_{\text{current}} + \beta \textbf{J}^T \boldsymbol{e} \). Hierbei ist \( \beta \) eine Schrittweite, die zur Stabilisierung und Konvergenzbeschleunigung dient.
• Iterative Wiederholung: Wiederhole die Schritte 2 bis 4, bis der Fehler \( \boldsymbol{e} \) kleiner als ein vorgegebener Schwellenwert \( \text{tol} \) ist: \( \text{if } ||\boldsymbol{e}|| < \text{tol} \text{ then STOP} \).

Formale mathematische Darstellung

Die Berechnung der Gelenkwinkel \( \theta \) für eine gegebene Endposition \( \boldsymbol{p} \) kann durch die iterative Anwendung der folgenden Schritte beschrieben werden:

1. Fehlervektor berechnen: \( \boldsymbol{e} = \boldsymbol{p}_{\text{target}} - \boldsymbol{p}_{\text{current}} \).
2. Jacobian-Matrix berechnen: \[ \textbf{J} = \frac{\text{d} \boldsymbol{p}}{\text{d} \boldsymbol{\theta}} \].
3. Gelenkwinkel aktualisieren: \( \theta_{\text{new}} = \theta_{\text{current}} + \beta \textbf{J}^T \boldsymbol{e} \).
4. Abbruchbedingung prüfen: \( \text{if } ||\boldsymbol{e}|| < \text{tol} \text{ then STOP} \).

Dieser iterative Prozess nähert sich den korrekten Gelenkwinkeln an, sodass der Endeffektor die gewünschte Zielposition erreicht. Aufgrund von Nichtlinearitäten und potenziellen Singularitäten in der Jacobian-Matrix kann es notwendig sein, zusätzliche Techniken wie Dämpfung oder die Verwendung der pseudoinversen Jacobian-Matrix anzuwenden.

b)

Inverse Dynamik wird häufig zur Bestimmung der notwendigen Kräfte und Momente verwendet, um eine bestimmte Bewegung auszuführen. Berechne für einen manipulierenden Roboterarm mit zwei Gelenken die notwendigen Kräfte, um eine vorgegebene Endposition zu erreichen. Verwende dazu die Dynamikgleichungen und ermittle die Kräfte basierend auf den Bewegungsbedingungen. Denke an das Trägheitsmoment, die Coriolis- und Zentrifugalkräfte sowie die Gravitationskräfte.

Lösung:

Berechnung der notwendigen Kräfte für einen manipulierenden Roboterarm mit zwei Gelenken

Um die notwendigen Kräfte und Momente für einen Roboterarm mit zwei Gelenken zu berechnen, verwenden wir die Prinzipien der inversen Dynamik. Dabei werden die Dynamikgleichungen berücksichtigt, die verschiedene Kräfte beinhalten: Trägheitsmomente, Coriolis- und Zentrifugalkräfte sowie Gravitationskräfte.

Wir nehmen an, dass der Roboterarm zwei Rotationsgelenke hat. Die Gelenkwinkel seien \( \theta_1 \) und \( \theta_2 \), die Längen der Segmente seien \( l_1 \) und \( l_2 \), und die Massen der Segmente seien \( m_1 \) und \( m_2 \). Die Dynamikgleichungen für ein solches System können unter Einsatz der Lagrange-Formulierung aufgestellt werden.

Die Berechnung erfolgt in folgenden Schritten:

• Trägheitsmomente berechnen: Die Trägheitsmomente \( I_1 \) und \( I_2 \) für die beiden Segmente können mittels der Massen und Längen der Segmente berechnet werden. Wenn wir die Segmente als stäbeförmig betrachten: \[ I_1 = \frac{1}{3} m_1 l_1^2 \] \[ I_2 = \frac{1}{3} m_2 l_2^2 \]
• Jacobian-Matrix aufstellen: Die Jacobian-Matrix \( J \) beschreibt die Abhängigkeit der Positionen von den Gelenkwinkeln. Für einen zweigliedrigen Roboterarm lautet sie: \[ J = \begin{bmatrix} -l_1 \sin \theta_1 - l_2 \sin(\theta_1 + \theta_2) & -l_2 \sin(\theta_1 + \theta_2) \ l_1 \cos \theta_1 + l_2 \cos(\theta_1 + \theta_2) & l_2 \cos(\theta_1 + \theta_2) \end{bmatrix} \]
• System der Dynamikgleichungen aufstellen: Dynamikgleichungen umfassen Trägheitsmatrix \( M(\theta) \), Coriolis- und Zentrifugalkräfte \( C(\theta, \dot{\theta}) \) sowie Gravitationskräfte \( G(\theta) \): \[ M(\theta) \ddot{\theta} + C(\theta, \dot{\theta}) \dot{\theta} + G(\theta) = \tau \]

Für ein System mit zwei Gelenken sieht die Trägheitsmatrix wie folgt aus: \[ M(\theta) = \begin{bmatrix} I_1 + I_2 + m_2 l_1^2 + 2m_2 l_1 l_2 \cos \theta_2 & I_2 + m_2 l_1 l_2 \cos \theta_2 \ I_2 + m_2 l_1 l_2 \cos \theta_2 & I_2 \end{bmatrix} \]

Die Coriolis- und Zentrifugalkräfte setzen sich wie folgt zusammen: \[ C(\theta, \dot{\theta}) = \begin{bmatrix} -m_2 l_1 l_2 \sin \theta_2 \dot{\theta_2} & -m_2 l_1 l_2 \sin \theta_2 (\dot{\theta_1} + \dot{\theta_2}) \ m_2 l_1 l_2 \sin \theta_2 \dot{\theta_1} & 0 \end{bmatrix} \]

Die Gravitationskräfte sind: \[ G(\theta) = \begin{bmatrix} (m_1 + m_2) g l_1 \cos \theta_1 + m_2 g l_2 \cos(\theta_1+\theta_2) \ m_2 g l_2 \cos(\theta_1+\theta_2) \end{bmatrix} \]

• Kräfte berechnen: Setze die Zielbeschleunigungen \( \ddot{\theta} \), Geschwindigkeiten \( \dot{\theta} \), und Winkel \( \theta \) in das System der Dynamikgleichungen ein, um die notwendigen Gelenkdrehmomente \( \tau \) zu berechnen: \[ \tau = M(\theta) \ddot{\theta} + C(\theta, \dot{\theta}) \dot{\theta} + G(\theta) \]

Zur Veranschaulichung nehmen wir spezifische Werte für \( \theta, \dot{\theta}, \ddot{\theta} \) sowie die Segmentparameter und berechnen somit die entsprechenden Drehmomente:

1. Werteannahmen: Setze \( \theta_1 = 30^\text{o} \), \( \theta_2 = 45^\text{o} \), \( \dot{\theta_1} = 0.1 \text{rad/s} \), \( \dot{\theta_2} = 0.1 \text{rad/s} \), \( \ddot{\theta_1} = 0.2 \text{rad/s}^2 \), \( \ddot{\theta_2} = 0.2 \text{rad/s}^2 \).
2. Berechne Trägheitsmomente: \( I_1 = \frac{1}{3} m_1 l_1^2 \), \( I_2 = \frac{1}{3} m_2 l_2^2 \).
3. Berechne Dynamikgleichungen: \( M(\theta) \), \( C(\theta, \dot{\theta}) \), \( G(\theta) \).
4. Berechne Drehmomente: \( \tau = M(\theta) \ddot{\theta} + C(\theta, \dot{\theta}) \dot{\theta} + G(\theta) \).

Durch diese Schritte wird die Berechnung der erforderlichen Kräfte und Momente für die Bewegung eines manipulierenden Roboterarms bestimmt.

c)

PID-Regler sind eine grundlegende Regelungstechnik in der Robotik. Erkläre den Aufbau eines PID-Reglers und beschreibe, wie er zur Bewegungssteuerung eingesetzt werden kann. Zeige mathematisch, wie die Parameter des PID-Reglers (K_p, K_i, K_d) die Systemantwort beeinflussen. Implementiere einen einfachen PID-Regler in Python, um die Position eines Roboterarms zu steuern.

Lösung:

Aufbau eines PID-Reglers und seine Anwendung in der Bewegungssteuerung

Ein PID-Regler (Proportional-Integral-Derivative Controller) ist eine der grundlegenden Regelungstechniken in der Robotik und in vielen anderen Bereichen der Regelungstechnik. Er wird verwendet, um die Position, Geschwindigkeit oder andere Zustände eines Systems präzise zu steuern. Ein PID-Regler besteht aus drei Komponenten:

• Proportionalanteil (P): Dieser Anteil ist direkt proportional zum Fehler (der Differenz zwischen Sollwert und Istwert). Er versucht, den Fehler möglichst klein zu halten.

  Mathematisch: \( P = K_p e(t) \).

• Integralanteil (I): Dieser Anteil berücksichtigt die Summe der Fehler über die Zeit. Er dient dazu, fortwährenden Fehler zu eliminieren, die nicht vom Proportionalanteil behoben werden können.

  Mathematisch: \( I = K_i \int_0^t e(\tau) d\tau \).

• Derivativeanteil (D): Dieser Anteil reagiert auf die Änderungsrate des Fehlers. Er versucht, schnelle Änderungen zu dämpfen und das System zu stabilisieren.

  Mathematisch: \( D = K_d \frac{d}{dt} e(t) \).

Die Gesamtausgabe des PID-Reglers ist die Summe dieser drei Anteile: \( u(t) = K_p e(t) + K_i \int_0^t e(\tau) d\tau + K_d \frac{d}{dt} e(t) \).

Einfluss der PID-Parameter auf die Systemantwort

• K_p (Proportionaler Verstärkungsfaktor): Erhöht die Reaktionsgeschwindigkeit auf Fehler, kann jedoch zu Überschwingen und Instabilität führen, wenn er zu hoch ist.
• K_i (Integraler Verstärkungsfaktor): Reduziert den stationären Fehler und beseitigt den Offset. Ein zu hoher Wert kann jedoch zu langsamen Reaktionen und Schwingungen führen.
• K_d (Differentialer Verstärkungsfaktor): Glättet die Reaktion und reduziert Schwingungen, kann jedoch bei zu hohem Wert zu Verzögerungen und Trägheit führen.

Durch die richtige Anpassung dieser Parameter kann ein PID-Regler eingesetzt werden, um die Stabilität, Genauigkeit und Geschwindigkeit der Bewegungssteuerung zu optimieren.

Implementierung eines einfachen PID-Reglers in Python

import timeclass PIDController:     def __init__(self, Kp, Ki, Kd, setpoint):         self.Kp = Kp         self.Ki = Ki         self.Kd = Kd         self.setpoint = setpoint         self.last_error = 0         self.integral = 0         self.last_time = time.time()     def update(self, feedback_value):         current_time = time.time()         delta_time = current_time - self.last_time         error = self.setpoint - feedback_value         # Proportional term         P_out = self.Kp * error         # Integral term         self.integral += error * delta_time         I_out = self.Ki * self.integral         # Derivative term         derivative = (error - self.last_error) / delta_time         D_out = self.Kd * derivative         # Save last_error and last_time for next iteration         self.last_error = error         self.last_time = current_time         # Control output         output = P_out + I_out + D_out         return output# Beispiel:setpoint = 1.0  # gewünschte Positionfeedback = 0.0  # aktuelle Position des Roboterarmspid = PIDController(1.0, 0.1, 0.01, setpoint)for _ in range(100):     output = pid.update(feedback)     feedback += output  # Simuliere die Änderung der Position     print(f'PID-Reglerausgabe: {output}, Position: {feedback}')     time.sleep(0.1)  # Annahme von 100 ms Schleifenzeit (entspricht 10 Hz)

Dieser einfache PID-Regler in Python berechnet die Korrektur basierend auf der Differenz zwischen der aktuellen Position des Roboterarms und der Zielposition (Sollwert). Die update-Funktion berechnet den Proportional-, Integral- und Differentialanteil und summiert diese, um die Ausgangssteuerung für das System zu bestimmen.

d)

Maschinelles Lernen, insbesondere Reinforcement Learning (RL), eignet sich gut für die Bewegungsplanung in intelligenten Systemen. Beschreibe den Prozess des Reinforcement Learnings im Kontext der Bewegungsplanung. Entwickle, mithilfe von Pseudocode, einen RL-Algorithmus, der einen Roboter lernen lässt, eine vorgegebene Bewegungsaufgabe optimal auszuführen. Achte darauf, die Definition der Belohnungsfunktion, den Zustandsraum und die Auswahl der Aktionen zu berücksichtigen.

Lösung:

Reinforcement Learning (RL) im Kontext der Bewegungsplanung

Reinforcement Learning (RL) ist eine Methode des maschinellen Lernens, bei der ein Agent durch Interaktion mit der Umwelt lernt, optimale Aktionen auszuführen, um Belohnungen zu maximieren. Im Kontext der Bewegungsplanung für intelligente Systeme bedeutet dies, dass ein Roboter lernt, durch Versuch und Irrtum Aktionen auszuwählen, um bestimmte Bewegungsaufgaben erfolgreich und effizient auszuführen.

Der Prozess des Reinforcement Learnings umfasst folgende Elemente:

• Agent: Der Roboter, der lernt, die Bewegungsaufgabe auszuführen.
• Umgebung: Der Kontext, in dem der Roboter operiert, einschließlich aller physikalischen Bedingungen und Hindernisse.
• Zustandsraum: Die Menge aller möglichen Zustände, in denen sich der Roboter befinden kann. Ein Zustand könnte beispielsweise die Position und Orientierung des Roboters sein.
• Aktionsraum: Die Menge aller Aktionen, die der Roboter ausführen kann, z.B. Bewegungsschritte oder Regelungsparameter ändern.
• Belohnungsfunktion: Eine Funktion, die bewertet, wie gut eine bestimmte Aktion in einem bestimmten Zustand ist. Diese Funktion treibt den Lernprozess an.

Das Ziel des RL-Algorithmus ist es, eine Politik (policy) zu lernen, die angibt, welche Aktion in einem bestimmten Zustand die maximale zukünftige Belohnung bringt. Die Politik wird häufig durch die Q-Funktion repräsentiert, die den erwarteten Nutzen einer Handlung in einem bestimmten Zustand bewertet.

Entwicklung eines RL-Algorithmus zur Bewegungsplanung

Hier ist ein Pseudocode für einen einfachen Q-Learning-Algorithmus, der einen Roboter lernen lässt, eine vorgegebene Bewegungsaufgabe optimal auszuführen:

class QLearningAgent:     def __init__(self, state_space, action_space, alpha, gamma, epsilon):         self.state_space = state_space         self.action_space = action_space         self.alpha = alpha  # Lernrate         self.gamma = gamma  # Diskontierungsfaktor         self.epsilon = epsilon  # Erkunden-gegen-Ausbeuten-Rate         self.q_table = {state: {action: 0 for action in action_space} for state in state_space}     def choose_action(self, state):         if random.random() < self.epsilon:             return random.choice(list(self.action_space))  # Zufällige Aktion (Erkunden)         else:             return max(self.q_table[state], key=self.q_table[state].get)  # Beste Aktion (Ausbeuten)     def update_q(self, state, action, reward, next_state):         best_next_action = max(self.q_table[next_state], key=self.q_table[next_state].get)         td_target = reward + self.gamma * self.q_table[next_state][best_next_action]         td_error = td_target - self.q_table[state][action]         self.q_table[state][action] += self.alpha * td_error # Pseudocode für das Training eines Q-Learning-Agentenenv = Environment()agent = QLearningAgent(state_space=env.state_space,         action_space=env.action_space,         alpha=0.1, gamma=0.99, epsilon=0.1)for episode in range(1000):  # Anzahl der Episoden     state = env.reset()  # Initialisierungszustand     done = False     while not done:         action = agent.choose_action(state)         next_state, reward, done = env.step(action)         agent.update_q(state, action, reward, next_state)         state = next_state

Beschreibung des Pseudocodes

• Q-Learning-Agent: Initialisiert einen Q-Learning-Agenten mit Lernenrate (alpha), Diskontierungsfaktor (gamma) und Erkunden-gegen-Ausbeuten-Rate (epsilon).
• Aktionen auswählen: Nutzt eine epsilon-gierige Strategie, um entweder zufällig eine Aktion zu wählen (Erkunden) oder die beste bekannte Aktion basierend auf der Q-Tabelle (Ausbeuten).
• Q-Tabelle aktualisieren: Aktualisiert die Q-Tabelle basierend auf dem Belohnungssignal und dem maximal erwarteten Nutzen aus dem nächsten Zustand.
• Training: Führt den Agenten durch eine Reihe von Episoden, in denen der Zustand, die Aktion, die Belohnung und der nächste Zustand beachtet werden, um die Q-Tabelle zu verbessern.

Durch diese Schritte lernt der Q-Learning-Agent, die beste Politik zu finden, um die Bewegungsaufgabe des Roboters effektiv und effizient zu erfüllen.