{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":3641,"databundleVersionId":44547,"sourceType":"competition"}],"dockerImageVersionId":30761,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-10-06T09:53:26.576627Z","iopub.execute_input":"2024-10-06T09:53:26.577131Z","iopub.status.idle":"2024-10-06T09:53:26.986703Z","shell.execute_reply.started":"2024-10-06T09:53:26.577090Z","shell.execute_reply":"2024-10-06T09:53:26.985491Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"!unzip \"/kaggle/input/decoding-the-human-brain/train_01_06.zip\"  -d ./train\n!unzip \"/kaggle/input/decoding-the-human-brain/train_07_12.zip\"  -d ./train\n!unzip \"/kaggle/input/decoding-the-human-brain/train_13_16.zip\"  -d ./train\n!unzip \"/kaggle/input/decoding-the-human-brain/test_17_23.zip\"  -d ./test","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:53:26.988795Z","iopub.execute_input":"2024-10-06T09:53:26.989438Z","iopub.status.idle":"2024-10-06T09:55:17.080375Z","shell.execute_reply.started":"2024-10-06T09:53:26.989389Z","shell.execute_reply":"2024-10-06T09:55:17.078057Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from scipy.io import loadmat \n\nmat_file1 = '/kaggle/working/train/data/train_subject11.mat'\nmat_data = loadmat(mat_file1)\n\nmat_data.keys() ","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:17.085439Z","iopub.execute_input":"2024-10-06T09:55:17.086023Z","iopub.status.idle":"2024-10-06T09:55:17.922068Z","shell.execute_reply.started":"2024-10-06T09:55:17.085963Z","shell.execute_reply":"2024-10-06T09:55:17.920269Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Wir haben mat_data X als 592 Trials, 306 Sensoren, 375 Zeitpunkte pro Trial ","metadata":{}},{"cell_type":"code","source":"import matplotlib.pyplot as plt\n \nX = mat_data['X']\ny = mat_data['y'].flatten()\n\nplt.plot(X[0, :, 0])   \nplt.title('Erstes Signal für Sensor 0')\nplt.xlabel('Zeitpunkt')\nplt.ylabel('Amplitude')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:17.924725Z","iopub.execute_input":"2024-10-06T09:55:17.926176Z","iopub.status.idle":"2024-10-06T09:55:18.352718Z","shell.execute_reply.started":"2024-10-06T09:55:17.926112Z","shell.execute_reply":"2024-10-06T09:55:18.351463Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# Berechnung der Autokorrelation für n = 30 Zeitpunkte\ndef autocorrelation(signal, lag):\n    n = len(signal)\n    mean = np.mean(signal)\n    autocorr = np.correlate(signal - mean, signal - mean, mode='full')[-n:]\n    autocorr /= autocorr[0]  # Normierung auf Autokorrelation bei Lag 0\n    return autocorr[:lag]\n\n# Definiere n = 30\nn = 30\n\n# Signal für den ersten Sensor extrahieren\nsignal_sensor_0 = X[0, :, 0]\n\n# Autokorrelation für n Zeitpunkte berechnen\nautocorr_values = autocorrelation(signal_sensor_0, n)\n\n# Autokorrelation visualisieren\nplt.stem(range(n), autocorr_values, use_line_collection=True)\nplt.title(f'Autokorrelation für Sensor 0 (n={n})')\nplt.xlabel('Verzögerung (lag)')\nplt.ylabel('Autokorrelation')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:18.355073Z","iopub.execute_input":"2024-10-06T09:55:18.355449Z","iopub.status.idle":"2024-10-06T09:55:18.632076Z","shell.execute_reply.started":"2024-10-06T09:55:18.355411Z","shell.execute_reply":"2024-10-06T09:55:18.630892Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# Berechnung der Autokorrelation für n = 30 Zeitpunkte\ndef autocorrelation(signal, lag):\n    n = len(signal)\n    mean = np.mean(signal)\n    autocorr = np.correlate(signal - mean, signal - mean, mode='full')[-n:]\n    autocorr /= autocorr[0]  # Normierung auf Autokorrelation bei Lag 0\n    return autocorr[:lag]\n\n# Definiere n = 30\nn = 300\n\n# Signal für den ersten Sensor extrahieren\nsignal_sensor_0 = X[0, :, 0]\n\n# Autokorrelation für n Zeitpunkte berechnen\nautocorr_values = autocorrelation(signal_sensor_0, n)\n\n# Autokorrelation visualisieren\nplt.stem(range(n), autocorr_values, use_line_collection=True)\nplt.title(f'Autokorrelation für Sensor 0 (n={n})')\nplt.xlabel('Verzögerung (lag)')\nplt.ylabel('Autokorrelation')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:18.633335Z","iopub.execute_input":"2024-10-06T09:55:18.633708Z","iopub.status.idle":"2024-10-06T09:55:18.927251Z","shell.execute_reply.started":"2024-10-06T09:55:18.633668Z","shell.execute_reply":"2024-10-06T09:55:18.925810Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# Berechnung der Autokorrelation für n = 30 Zeitpunkte\ndef autocorrelation(signal, lag):\n    n = len(signal)\n    mean = np.mean(signal)\n    autocorr = np.correlate(signal - mean, signal - mean, mode='full')[-n:]\n    autocorr /= autocorr[0]  # Normierung auf Autokorrelation bei Lag 0\n    return autocorr[:lag]\n\n# Definiere n = 30\nn = 300\n\n# Signal für den ersten Sensor extrahieren\nsignal_sensor_0 = X[1, :, 1]\n\n# Autokorrelation für n Zeitpunkte berechnen\nautocorr_values = autocorrelation(signal_sensor_0, n)\n\n# Autokorrelation visualisieren\nplt.stem(range(n), autocorr_values, use_line_collection=True)\nplt.title(f'Autokorrelation für Sensor 0 (n={n})')\nplt.xlabel('Verzögerung (lag)')\nplt.ylabel('Autokorrelation')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:18.928976Z","iopub.execute_input":"2024-10-06T09:55:18.929406Z","iopub.status.idle":"2024-10-06T09:55:19.230561Z","shell.execute_reply.started":"2024-10-06T09:55:18.929366Z","shell.execute_reply":"2024-10-06T09:55:19.229086Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.gaussian_process import GaussianProcessRegressor\nfrom sklearn.gaussian_process.kernels import RBF, ConstantKernel as C\n\n# Normalisiere das Signal (z.B. für Sensor 0)\nsignal_sensor_0 = (X[0, :, 0] - np.mean(X[0, :, 0])) / np.std(X[0, :, 0])\ntime_points = np.arange(len(signal_sensor_0))  # Zeitpunkte\n\n# Definiere einen Gaußschen Prozess mit einem kleineren Längenskalenparameter im RBF-Kernel\nkernel = C(1.0, (1e-4, 1e1)) * RBF(10, (1e-2, 1e2))\n\n# GP-Modell initialisieren\ngp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)\n\n# Fitte den Gaußschen Prozess auf die Daten\ngp.fit(time_points.reshape(-1, 1), signal_sensor_0)\n\n# Vorhersage der geglätteten Kurve\ny_pred, sigma = gp.predict(time_points.reshape(-1, 1), return_std=True)\n\n# Plot der Originaldaten und der geglätteten Kurve\nplt.figure(figsize=(10, 6))\nplt.plot(time_points, signal_sensor_0, label='Originales verrauschtes Signal', color='gray', alpha=0.5)\nplt.plot(time_points, y_pred, label='Geglättetes Signal (GP)', color='blue', linewidth=2)\nplt.fill_between(time_points, y_pred - 1.96 * sigma, y_pred + 1.96 * sigma, color='blue', alpha=0.2)\nplt.title('Geglättetes Signal für Sensor 0 mittels Gaußschem Prozess (angepasste Parameter)')\nplt.xlabel('Zeitpunkt')\nplt.ylabel('Amplitude')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:19.233152Z","iopub.execute_input":"2024-10-06T09:55:19.234139Z","iopub.status.idle":"2024-10-06T09:55:26.711403Z","shell.execute_reply.started":"2024-10-06T09:55:19.234070Z","shell.execute_reply":"2024-10-06T09:55:26.710079Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# Berechnung der Autokorrelation für n = 30 Zeitpunkte\ndef autocorrelation(signal, lag):\n    n = len(signal)\n    mean = np.mean(signal)\n    autocorr = np.correlate(signal - mean, signal - mean, mode='full')[-n:]\n    autocorr /= autocorr[0]  # Normierung auf Autokorrelation bei Lag 0\n    return autocorr[:lag]\n\n# Definiere n = 30\nn = 300\n\n# Signal für den ersten Sensor extrahieren\nsignal_sensor_0 = gp.predict(time_points.reshape(-1, 1), return_std=True)\n\n# Autokorrelation für n Zeitpunkte berechnen\nautocorr_values = autocorrelation(y_pred, n)\n\n# Autokorrelation visualisieren\nplt.stem(range(n), autocorr_values, use_line_collection=True)\nplt.title(f'Autokorrelation für Sensor 0 (n={n})')\nplt.xlabel('Verzögerung (lag)')\nplt.ylabel('Autokorrelation')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2024-10-06T09:55:26.713145Z","iopub.execute_input":"2024-10-06T09:55:26.713811Z","iopub.status.idle":"2024-10-06T09:55:27.093150Z","shell.execute_reply.started":"2024-10-06T09:55:26.713734Z","shell.execute_reply":"2024-10-06T09:55:27.092021Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"TOdo: autokorellation mit der geglätten Zeitreihe berechnen;","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\n\n# Schritt 1: Extrahiere das ursprüngliche verrauschte Signal und das geglättete Signal\nsignal_sensor_0 = X[0, :, 0]  # Original verrauschtes Signal\ny_pred, _ = gp.predict(time_points.reshape(-1, 1), return_std=True)  # Geglättetes Signal (vom Gaußschen Prozess)\n\n# Schritt 2: Berechne den Rauschanteil als Differenz zwischen originalem Signal und geglättetem Signal\nnoise_estimation = signal_sensor_0 - y_pred\n\n# Schritt 3: Schätze die Varianz des Rauschens\nsigma_estimated = np.var(noise_estimation)\n\n# Schritt 4: Erzeuge weißes Rauschen (Normalverteilung mit E=0, Varianz=sigma_estimated)\nwhite_noise = np.random.normal(0, np.sqrt(sigma_estimated), len(time_points))\n\n# Plot des originalen Rauschens und des modellierten weißen Rauschens\nplt.figure(figsize=(12, 6))\n\nplt.subplot(2, 1, 1)\nplt.plot(time_points, noise_estimation, label='Geschätztes Rauschen (original)')\nplt.title('Geschätztes Rauschen (Originalsignal - geglättetes Signal)')\nplt.legend()\n\nplt.subplot(2, 1, 2)\nplt.plot(time_points, white_noise, label='Modelliertes weißes Rauschen', color='red')\nplt.title('Modelliertes Weißes Rauschen (WN)')\nplt.legend()\n\nplt.tight_layout()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:06:21.392384Z","iopub.execute_input":"2024-10-06T10:06:21.393008Z","iopub.status.idle":"2024-10-06T10:06:22.072574Z","shell.execute_reply.started":"2024-10-06T10:06:21.392947Z","shell.execute_reply":"2024-10-06T10:06:22.071132Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.gaussian_process import GaussianProcessRegressor\nfrom sklearn.gaussian_process.kernels import RBF, ConstantKernel as C\n\n# Daten laden (falls noch nicht geschehen)\n# Beispielhafte Verwendung, abhängig davon, wie die Daten ursprünglich geladen wurden\n# signal_sensor_0 = X[0, :, 0]  # Verwende hier das original Signal von deinem ersten Sensor\n\n# Zeitpunkte und Daten\ntime_points = np.arange(len(signal_sensor_0))\n\n# Schritt 1: Gaußschen Prozess mit RBF-Kernel definieren\nkernel = C(1.0, (1e-4, 1e1)) * RBF(10, (1e-2, 1e2))\ngp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)\n\n# Gaußschen Prozess auf die Daten fitten\ngp.fit(time_points.reshape(-1, 1), signal_sensor_0)\n\n# Geglättetes Signal vorhersagen\ny_pred, _ = gp.predict(time_points.reshape(-1, 1), return_std=True)\n\n# Schritt 2: Rauschanteil als Differenz zwischen dem verrauschten und dem geglätteten Signal\nnoise_estimation = signal_sensor_0 - y_pred\n\n# Varianz des Rauschens schätzen\nsigma_estimated = np.var(noise_estimation)\n\n# Modelliertes weißes Rauschen erzeugen\nwhite_noise = np.random.normal(0, np.sqrt(sigma_estimated), len(time_points))\n\n# Schritt 3: Rekonstruiertes Signal erzeugen (Geglättetes Signal + Weißes Rauschen)\nreconstructed_signal = y_pred + white_noise\n\n# Schritt 4: Autokorrelation des rekonstruierten Signals berechnen\ndef autocorrelation(signal, lag):\n    n = len(signal)\n    mean = np.mean(signal)\n    autocorr = np.correlate(signal - mean, signal - mean, mode='full')[-n:]\n    autocorr /= autocorr[0]  # Normierung auf Autokorrelation bei Lag 0\n    return autocorr[:lag]\n\n# Definiere n = 300 für die Autokorrelation\nn = 300\nautocorr_values = autocorrelation(reconstructed_signal, n)\n\n# Visualisieren des rekonstruierten Signals und der Autokorrelation\nplt.figure(figsize=(12, 6))\n\n# Plot des rekonstruierten Signals\nplt.subplot(2, 1, 1)\nplt.plot(time_points, reconstructed_signal, label='Rekonstruiertes Signal (Geglättetes Signal + WN)', color='green')\nplt.title('Rekonstruiertes Signal (Geglättetes Signal + Modelliertes Weißes Rauschen)')\nplt.legend()\n\n# Plot der Autokorrelation\nplt.subplot(2, 1, 2)\nplt.stem(range(n), autocorr_values, use_line_collection=True)\nplt.title(f'Autokorrelation des rekonstruierten Signals (n={n})')\nplt.xlabel('Verzögerung (lag)')\nplt.ylabel('Autokorrelation')\n\nplt.tight_layout()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:27:28.391704Z","iopub.execute_input":"2024-10-06T10:27:28.393149Z","iopub.status.idle":"2024-10-06T10:27:29.574620Z","shell.execute_reply.started":"2024-10-06T10:27:28.393081Z","shell.execute_reply":"2024-10-06T10:27:29.573423Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"plt.plot(signal_sensor_0, label='Original Signal')\nplt.plot(pd.Series(signal_sensor_0).rolling(window=50).mean(), label='Gleitender Mittelwert', color='red')\nplt.title('Gleitender Mittelwert des Signals')\nplt.legend()\nplt.show()","metadata":{}},{"cell_type":"code","source":"plt.plot(reconstructed_signal, label='Original Signal')\nplt.plot(pd.Series(signal_sensor_0).rolling(window=50).mean(), label='Gleitender Mittelwert', color='red')\nplt.title('Gleitender Mittelwert des Signals')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:51:53.688077Z","iopub.execute_input":"2024-10-06T10:51:53.688607Z","iopub.status.idle":"2024-10-06T10:51:54.029407Z","shell.execute_reply.started":"2024-10-06T10:51:53.688557Z","shell.execute_reply":"2024-10-06T10:51:54.028154Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.plot(pd.Series(reconstructed_signal).rolling(window=50).var(), label='Gleitende Varianz', color='green')\nplt.title('Gleitende Varianz des Signals')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:51:48.988853Z","iopub.execute_input":"2024-10-06T10:51:48.990918Z","iopub.status.idle":"2024-10-06T10:51:49.250443Z","shell.execute_reply.started":"2024-10-06T10:51:48.990843Z","shell.execute_reply":"2024-10-06T10:51:49.249176Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from statsmodels.graphics.tsaplots import plot_acf\nplot_acf(reconstructed_signal, lags=30)\nplt.title('Autokorrelation des Signals')\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:52:00.384011Z","iopub.execute_input":"2024-10-06T10:52:00.384469Z","iopub.status.idle":"2024-10-06T10:52:00.620538Z","shell.execute_reply.started":"2024-10-06T10:52:00.384427Z","shell.execute_reply":"2024-10-06T10:52:00.619296Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from statsmodels.tsa.stattools import adfuller\n\nresult = adfuller(reconstructed_signal)\nprint(f'ADF Statistic: {result[0]}')\nprint(f'p-value: {result[1]}')\nif result[1] < 0.05:\n    print(\"Zeitreihe ist schwach stationär (Nullhypothese verworfen)\")\nelse:\n    print(\"Zeitreihe ist nicht schwach stationär (Nullhypothese nicht verworfen)\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:52:15.124626Z","iopub.execute_input":"2024-10-06T10:52:15.125178Z","iopub.status.idle":"2024-10-06T10:52:15.146233Z","shell.execute_reply.started":"2024-10-06T10:52:15.125130Z","shell.execute_reply":"2024-10-06T10:52:15.144900Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from statsmodels.tsa.stattools import kpss\n\nresult = kpss(reconstructed_signal, regression='c')\nprint(f'KPSS Statistic: {result[0]}')\nprint(f'p-value: {result[1]}')\nif result[1] < 0.05:\n    print(\"Zeitreihe ist nicht schwach stationär (Nullhypothese verworfen)\")\nelse:\n    print(\"Zeitreihe ist schwach stationär (Nullhypothese nicht verworfen)\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:52:20.230236Z","iopub.execute_input":"2024-10-06T10:52:20.230690Z","iopub.status.idle":"2024-10-06T10:52:20.238408Z","shell.execute_reply.started":"2024-10-06T10:52:20.230648Z","shell.execute_reply":"2024-10-06T10:52:20.237105Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport matplotlib.pyplot as plt\nfrom statsmodels.tsa.arima.model import ARIMA\nfrom statsmodels.graphics.tsaplots import plot_acf, plot_pacf\nfrom statsmodels.tsa.stattools import adfuller\n\n# Schritt 1: ACF und PACF analysieren, um Modellordnung zu wählen\n# Autokorrelationsfunktion (ACF) plotten\nplot_acf(reconstructed_signal, lags=30)\nplt.title('ACF - Autokorrelationsfunktion')\nplt.show()\n\n# Partielle Autokorrelationsfunktion (PACF) plotten\nplot_pacf(reconstructed_signal, lags=30)\nplt.title('PACF - Partielle Autokorrelationsfunktion')\nplt.show()\n\n# Basierend auf ACF und PACF können wir p und q wählen\n# Zum Beispiel: p=2, q=1\n\n# Schritt 2: ARMA-Modell schätzen\n# ARMA-Modell fitten (p=2, q=1)\np, q = 10, 3  # Werte für AR (p) und MA (q) aus ACF und PACF ablesen\nmodel = ARIMA(reconstructed_signal, order=(p, 0, q))\nmodel_fit = model.fit()\n\n# Modellzusammenfassung anzeigen\nprint(model_fit.summary())\n\n# Schritt 3: Restfehler analysieren, um Modellgüte zu prüfen\n# Plot der Restfehler\nresiduals = model_fit.resid\nplt.plot(residuals)\nplt.title('Restfehler des ARMA-Modells')\nplt.show()\n\n# Schritt 4: Modellvorhersage\n# Vorhersagen auf zukünftige Werte der Zeitreihe\nforecast = model_fit.forecast(steps=10)\nprint('Vorhersage für die nächsten 10 Zeitpunkte:')\nprint(forecast)\n\n# Plot der Vorhersagen\nplt.plot(np.arange(len(reconstructed_signal)), reconstructed_signal, label='Originales Signal')\nplt.plot(np.arange(len(reconstructed_signal), len(reconstructed_signal) + 10), forecast, label='Vorhersage', color='red')\nplt.title('ARMA-Modell: Originales Signal und Vorhersage')\nplt.legend()\nplt.show()\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T10:53:59.565384Z","iopub.execute_input":"2024-10-06T10:53:59.565883Z","iopub.status.idle":"2024-10-06T10:54:05.224125Z","shell.execute_reply.started":"2024-10-06T10:53:59.565832Z","shell.execute_reply":"2024-10-06T10:54:05.222616Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\n\neps = 0.000000000000000000000000000000000000000000000000000001\n\n# Berechne die Kovarianzmatrix für die Gehirndaten (zum Beispiel über alle Sensoren)\ncov_matrix = np.cov(X[0, :, :], rowvar=False)  # Kovarianzmatrix der Gehirndaten\n\n# Berechne die Eigenwerte der Kovarianzmatrix\neigenvalues = np.linalg.eigvals(cov_matrix)\n\n# Teste, ob alle Eigenwerte positiv sind\nif np.all(eigenvalues > eps):\n    print(\"Die Kovarianzmatrix ist positiv definit.\")\nelse:\n    print(\"Die Kovarianzmatrix ist nicht positiv definit.\")\n","metadata":{"execution":{"iopub.status.busy":"2024-10-06T11:07:03.569901Z","iopub.execute_input":"2024-10-06T11:07:03.570370Z","iopub.status.idle":"2024-10-06T11:07:03.657454Z","shell.execute_reply.started":"2024-10-06T11:07:03.570327Z","shell.execute_reply":"2024-10-06T11:07:03.656082Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Haben ja verschiedene Testpersonen, welche wir in unserer Vorhersagen alle einbeziehen sollten und evtl. auch unterschiedlich gewichten. Außerdem haben wir 306 Sensoren die voraussichtlich sehr verrauscht sind. Hier können wir auch gewisse Sensoren im Training priorisieren. ","metadata":{}},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn.feature_selection import mutual_info_classif\n\nX_reshaped = X.reshape(X.shape[0], -1)\n\nmi_scores = mutual_info_classif(X_reshaped, y)\nmi_scores = mi_scores.reshape(306, 375)\n\nsensor_mi_scores = np.sum(mi_scores, axis=1)\nsorted_indices = np.argsort(sensor_mi_scores)[::-1]\nsorted_mi_scores = sensor_mi_scores[sorted_indices]\n\nsorted_sensors_mi = [(sensor, score) for sensor, score in zip(sorted_indices, sorted_mi_scores)]\nfor sensor, score in sorted_sensors_mi:\n    print(f\"Sensor {sensor}: MI Score = {score}\")","metadata":{"execution":{"iopub.status.busy":"2024-08-25T18:23:23.703656Z","iopub.execute_input":"2024-08-25T18:23:23.704125Z","iopub.status.idle":"2024-08-25T18:30:33.345186Z","shell.execute_reply.started":"2024-08-25T18:23:23.704087Z","shell.execute_reply":"2024-08-25T18:30:33.343783Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Eventuell Sliding Window einbauen: damit wäre die mutual information Berechnung effizienter und wir erfassen auch kontextinformationen statt einzelne \"Zeitaufnahmen\" und reduzieren die Auswirkung vom Rauschen. \n\nDie Idee wäre dann die einzelnen Sensoren uniform zu den 5 Random Forests zuzuteilen, falls sie ähnliche mutual information scores haben. Falls bestimmte Sensoren sehr viel besser sind, könnte man sie clownen. Hier wäre die Gefahr, wenn man zu viele clownt, dass die später beim Ensemble nicht unabhängig sind und die Gesamtheitsentscheidung nicht besser ist, als die Einzelentscheidug eines Random Forests. ","metadata":{}},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}