From 270072410ae86d9d1bfe40269cf9e65dcfc7d866 Mon Sep 17 00:00:00 2001 From: VoKisnaHai1102 Date: Fri, 6 Jun 2025 19:50:22 +0000 Subject: [PATCH 1/2] Created using Colab --- 240563_KrishnaAg_week2fft.ipynb | 362 ++++++++++++++++++++++++++++++++ 1 file changed, 362 insertions(+) create mode 100644 240563_KrishnaAg_week2fft.ipynb diff --git a/240563_KrishnaAg_week2fft.ipynb b/240563_KrishnaAg_week2fft.ipynb new file mode 100644 index 0000000..58a2c30 --- /dev/null +++ b/240563_KrishnaAg_week2fft.ipynb @@ -0,0 +1,362 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "mount_file_id": "12zndUPY50ozGHCX5pl2G1NJlk4vVdvRu", + "authorship_tag": "ABX9TyMfu0pP+85J8UC8YGYcP3HL", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "reN94RuIpuP6", + "outputId": "536aa602-6649-42b8-b5e6-def23ba2dd9d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: mne in /usr/local/lib/python3.11/dist-packages (1.9.0)\n", + "Requirement already satisfied: decorator in /usr/local/lib/python3.11/dist-packages (from mne) (4.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from mne) (3.1.6)\n", + "Requirement already satisfied: lazy-loader>=0.3 in /usr/local/lib/python3.11/dist-packages (from mne) (0.4)\n", + "Requirement already satisfied: matplotlib>=3.6 in /usr/local/lib/python3.11/dist-packages (from mne) (3.10.0)\n", + "Requirement already satisfied: numpy<3,>=1.23 in /usr/local/lib/python3.11/dist-packages (from mne) (2.0.2)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from mne) (24.2)\n", + "Requirement already satisfied: pooch>=1.5 in /usr/local/lib/python3.11/dist-packages (from mne) (1.8.2)\n", + "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.11/dist-packages (from mne) (1.15.3)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (from mne) (4.67.1)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (1.3.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (4.58.1)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (1.4.8)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (11.2.1)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (3.2.3)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=3.6->mne) (2.9.0.post0)\n", + "Requirement already satisfied: platformdirs>=2.5.0 in /usr/local/lib/python3.11/dist-packages (from pooch>=1.5->mne) (4.3.8)\n", + "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.11/dist-packages (from pooch>=1.5->mne) (2.32.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->mne) (3.0.2)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib>=3.6->mne) (1.17.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (3.4.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (2.4.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch>=1.5->mne) (2025.4.26)\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "!pip install mne\n", + "import mne\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "import torch.nn as nn\n", + "from scipy.fft import rfft, rfftfreq" + ] + }, + { + "cell_type": "code", + "source": [ + "def create_mne_raw_object(signal_tensor, sampling_rate=128):\n", + " signal_array = signal_tensor.numpy().astype(np.float32)\n", + " if signal_array.shape[0] > signal_array.shape[1]:\n", + " signal_array = signal_array.T\n", + "\n", + " channel_labels = [f\"EEG {idx}\" for idx in range(signal_array.shape[0])]\n", + " channel_categories = [\"eeg\"] * len(channel_labels)\n", + " mne_info = mne.create_info(ch_names=channel_labels, sfreq=sampling_rate, ch_types=channel_categories)\n", + "\n", + " raw_object = mne.io.RawArray(signal_array, mne_info, verbose=False)\n", + " raw_object.filter(5, 45, fir_design='firwin', verbose=False)\n", + " raw_object.set_eeg_reference('average', verbose=False)\n", + " return raw_object\n", + "\n", + "def create_normalized_epochs(raw_object):\n", + " \"\"\"Segment data into epochs and apply normalization\"\"\"\n", + " epoch_data = mne.make_fixed_length_epochs(raw_object, duration=1.0, preload=True, verbose=False)\n", + " extracted_data = epoch_data.get_data()\n", + "\n", + " normalized_data = (extracted_data - extracted_data.mean(axis=2, keepdims=True)) / extracted_data.std(axis=2, keepdims=True)\n", + " return normalized_data\n" + ], + "metadata": { + "id": "eSEbiywWn-UV" + }, + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def expand_channels_to_target(signal_data, target_channels=128):\n", + " \"\"\"Expand or truncate channels to target number\"\"\"\n", + " num_epochs, current_channels, time_points = signal_data.shape\n", + "\n", + " if current_channels < target_channels:\n", + "\n", + " repetition_count = int(np.ceil(target_channels / current_channels))\n", + " expanded_data = np.tile(signal_data, (1, repetition_count, 1))[:, :target_channels, :]\n", + " else:\n", + " expanded_data = signal_data[:, :target_channels, :]\n", + "\n", + " return expanded_data\n", + "\n", + "def create_temporal_tokens(signal_data, token_length=4):\n", + " num_epochs, num_channels, time_samples = signal_data.shape\n", + " assert time_samples % token_length == 0\n", + "\n", + " new_time_dim = time_samples // token_length\n", + " reshaped_data = signal_data.reshape(num_epochs, num_channels, new_time_dim, token_length)\n", + " token_data = reshaped_data.transpose(0, 2, 1, 3).reshape(num_epochs, new_time_dim, -1)\n", + " return token_data" + ], + "metadata": { + "id": "xAb82-o1xcDn" + }, + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "class SignalEmbeddingLayer(nn.Module):\n", + " \"\"\"Neural network layer for embedding EEG tokens\"\"\"\n", + " def __init__(self, input_features, embedding_size=1024):\n", + " super().__init__()\n", + " self.projection_layer = nn.Linear(input_features, embedding_size)\n", + "\n", + " def forward(self, input_tokens):\n", + "\n", + " return self.projection_layer(input_tokens)" + ], + "metadata": { + "id": "McyeDU7zxhkb" + }, + "execution_count": 19, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def compute_power_spectrum(signal_data, sampling_rate=128):\n", + " \"\"\"Compute FFT power spectrum\"\"\"\n", + " fft_coefficients = np.fft.rfft(signal_data, axis=-1)\n", + " power_spectrum = np.abs(fft_coefficients) ** 2\n", + " frequency_bins = np.fft.rfftfreq(signal_data.shape[-1], d=1/sampling_rate)\n", + " return power_spectrum, frequency_bins\n", + "\n", + "def visualize_power_spectrum(power_data, freq_bins, epoch_idx=1, channel_idx=1):\n", + " \"\"\"Plot power spectrum for specific epoch and channel\"\"\"\n", + " plt.figure(figsize=(10, 6))\n", + " plt.plot(freq_bins, power_data[epoch_idx, channel_idx])\n", + " plt.title(f\"Power Spectrum (Epoch {epoch_idx}, Channel {channel_idx})\")\n", + " plt.xlabel(\"Frequency (Hz)\")\n", + " plt.ylabel(\"Power\")\n", + " plt.grid(True)\n", + " plt.show()\n", + "\n", + "def create_spectrogram_plot(signal_data, sampling_rate=128, selected_channel=0):\n", + " \"\"\"Generate spectrogram visualization\"\"\"\n", + " channel_signal = signal_data[selected_channel]\n", + "\n", + " plt.figure(figsize=(10, 4))\n", + " plt.specgram(channel_signal, NFFT=256, Fs=sampling_rate, noverlap=128, cmap='magma')\n", + " plt.title(\"Spectrogram Visualization\")\n", + " plt.xlabel(\"Time [s]\")\n", + " plt.ylabel(\"Frequency [Hz]\")\n", + " plt.colorbar(label='Intensity [dB]')\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "def analyze_frequency_evolution(signal_data, sampling_rate=128, selected_channel=0):\n", + " \"\"\"Plot frequency evolution over time\"\"\"\n", + " num_epochs = signal_data.shape[0]\n", + " time_points = np.arange(num_epochs)\n", + "\n", + " frequency_evolution = []\n", + " for epoch_data in signal_data:\n", + " channel_signal = epoch_data[selected_channel]\n", + " freq_bins = rfftfreq(len(channel_signal), d=1/sampling_rate)\n", + " fft_amplitudes = np.abs(rfft(channel_signal))\n", + "\n", + " mean_frequency = np.sum(freq_bins * fft_amplitudes) / np.sum(fft_amplitudes)\n", + " frequency_evolution.append(mean_frequency)\n", + "\n", + " plt.figure(figsize=(10, 4))\n", + " plt.plot(time_points, frequency_evolution, marker='o')\n", + " plt.title(\"Frequency Evolution Over Time\")\n", + " plt.xlabel(\"Time [s]\")\n", + " plt.ylabel(\"Frequency [Hz]\")\n", + " plt.grid(True)\n", + " plt.tight_layout()\n", + " plt.show()" + ], + "metadata": { + "id": "aWqD-0mTxnSX" + }, + "execution_count": 20, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "dataset_path = '/content/drive/MyDrive/EEG DATA/eeg_signals_raw_with_mean_std.pth'\n", + "loaded_data = torch.load(dataset_path)\n", + "\n", + "print(type(loaded_data['dataset'][0]))\n", + "print(loaded_data['dataset'][0])\n", + "\n", + "data = loaded_data['dataset']" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5XUR-6wExs68", + "outputId": "d4431206-82e4-45a6-c0f7-317896ce62f8" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "{'eeg': tensor([[ 0, 0, 2, ..., -37, -39, -38],\n", + " [ -12, -11, -8, ..., -26, -30, -33],\n", + " [ 35, 29, 21, ..., -17, -12, -9],\n", + " ...,\n", + " [ -830, -826, -838, ..., -935, -956, -1028],\n", + " [ -782, -848, -840, ..., -951, -987, -994],\n", + " [-2656, -2643, -2616, ..., -2747, -2779, -2786]], dtype=torch.int16), 'image': 0, 'label': 10, 'subject': 4}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(type(data_dict['dataset'][0]))\n", + "print(data_dict['dataset'][0])\n", + "data= data_dict['dataset']\n", + "for sample in data:\n", + " eeg_tensor = sample['eeg']\n", + " raw = preprocess_with_mne(eeg_tensor)\n", + " epochs = segment_and_normalize(raw)\n", + " padded = pad_channels_to_128(epochs)\n", + " tokens = temporal_tokenize(padded)\n", + "\n", + " embedder = EEGEmbedder(input_dim=tokens.shape[-1])\n", + " embedded_tokens = embedder(torch.tensor(tokens).float())\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1paQ4oo0oliv", + "outputId": "dbcff274-7f74-4c2c-bafe-67bad06575b5" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "{'eeg': tensor([[ 0, 0, 2, ..., -37, -39, -38],\n", + " [ -12, -11, -8, ..., -26, -30, -33],\n", + " [ 35, 29, 21, ..., -17, -12, -9],\n", + " ...,\n", + " [ -830, -826, -838, ..., -935, -956, -1028],\n", + " [ -782, -848, -840, ..., -951, -987, -994],\n", + " [-2656, -2643, -2616, ..., -2747, -2779, -2786]], dtype=torch.int16), 'image': 0, 'label': 10, 'subject': 4}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "create_spectrogram_plot(padded[0], selected_channel=0)\n", + "power_data, freq_bins = compute_power_spectrum(padded)\n", + "visualize_power_spectrum(power_data, freq_bins)\n", + "analyze_frequency_evolution(padded)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "eqRfKKoSoTpZ", + "outputId": "e49e2438-41e9-4ad1-b4a7-0126b6bd400f" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":23: UserWarning: Only one segment is calculated since parameter NFFT (=256) >= signal length (=128).\n", + " plt.specgram(channel_signal, NFFT=256, Fs=sampling_rate, noverlap=128, cmap='magma')\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file From 49ebb335400a19c0a55325c293fdd24d1a6e6f47 Mon Sep 17 00:00:00 2001 From: VoKisnaHai1102 Date: Sat, 7 Jun 2025 01:21:49 +0530 Subject: [PATCH 2/2] Created via Colab --- .../240563_KrishnaAg_week2fft.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename 240563_KrishnaAg_week2fft.ipynb => Week 2 FFT and tokenization/240563_KrishnaAg_week2fft.ipynb (99%) diff --git a/240563_KrishnaAg_week2fft.ipynb b/Week 2 FFT and tokenization/240563_KrishnaAg_week2fft.ipynb similarity index 99% rename from 240563_KrishnaAg_week2fft.ipynb rename to Week 2 FFT and tokenization/240563_KrishnaAg_week2fft.ipynb index 58a2c30..0609eac 100644 --- a/240563_KrishnaAg_week2fft.ipynb +++ b/Week 2 FFT and tokenization/240563_KrishnaAg_week2fft.ipynb @@ -359,4 +359,4 @@ ] } ] -} \ No newline at end of file +}