Feature Extraction2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\mhfar\\anaconda3\\lib\\site-packages\\pandas\\core\\arrays\\masked.py:60: UserWarning: Pandas requires version '1.3.6' or newer of 'bottleneck' (version '1.3.5' currently installed).\n",
      "  from pandas.core import (\n"
     ]
    }
   ],
   "source": [
    "import spkit as sp\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sn\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "import mne\n",
    "from copy import deepcopy\n",
    "from mne.preprocessing import compute_proj_ecg\n",
    "from mne_connectivity import envelope_correlation\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import random\n",
    "from mne.preprocessing import ICA, corrmap, create_ecg_epochs, create_eog_epochs\n",
    "from mne.preprocessing import annotate_amplitude\n",
    "from sklearn.preprocessing import PowerTransformer\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import numpy as np\n",
    "from scipy.signal import welch, coherence\n",
    "from scipy.stats import entropy, skew, kurtosis\n",
    "import networkx as nx\n",
    "import time\n",
    "import numpy as np\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.feature_selection import VarianceThreshold, SelectKBest, f_classif\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "#import tsfresh\n",
    "#from tsfresh import extract_features\n",
    "#from tsfresh.feature_extraction import ComprehensiveFCParameters\n",
    "#from pyrqa.time_series import TimeSeries\n",
    "from pyrqa.settings import Settings\n",
    "from pyrqa.analysis_type import Classic\n",
    "from pyrqa.neighbourhood import FixedRadius\n",
    "from pyrqa.metric import EuclideanMetric\n",
    "from pyrqa.computation import RQAComputation\n",
    "import pyrqa\n",
    "import mne\n",
    "from mne.decoding import CSP\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.discriminant_analysis import LinearDiscriminantAnalysis\n",
    "import pywt\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.feature_selection import RFE\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch_geometric.nn import GCNConv\n",
    "from torchvision.models import mobilenet_v2\n",
    "from torchvision import transforms\n",
    "import cv2\n",
    "from ordpy import renyi_entropy\n",
    "import joblib\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from feature_engine.selection import SelectBySingleFeaturePerformance\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "import time\n",
    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, StackingClassifier, ExtraTreesClassifier, AdaBoostClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import accuracy_score, recall_score, f1_score, balanced_accuracy_score, roc_auc_score, precision_score, multilabel_confusion_matrix\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.model_selection import GridSearchCV\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "logging.getLogger('mne').setLevel(logging.WARNING)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FPG_Dataset(Dataset):\n",
    "    def __init__(self, root_dir, transform=None):\n",
    "        self.root_dir = root_dir\n",
    "        self.transform = transform\n",
    "        self.filepaths, self.labels = self._load_filepaths_and_labels()\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.filepaths)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        filepath = self.filepaths[index]\n",
    "        label = self.labels[index]\n",
    "\n",
    "        eeg_data = self._load_eeg(filepath)\n",
    "\n",
    "        if self.transform is not None:\n",
    "            eeg_data = self.transform(eeg_data)\n",
    "\n",
    "        return torch.tensor(eeg_data), torch.tensor(label)\n",
    "\n",
    "    def _load_filepaths_and_labels(self):\n",
    "        filepaths = []\n",
    "        labels = []\n",
    "\n",
    "        classes = sorted(os.listdir(self.root_dir))\n",
    "        for class_index, class_name in enumerate(classes):\n",
    "            class_dir = os.path.join(self.root_dir, class_name)\n",
    "            if os.path.isdir(class_dir):\n",
    "                filenames = os.listdir(class_dir)\n",
    "                for filename in filenames:\n",
    "                    filepaths.append(os.path.join(class_dir, filename))\n",
    "                    labels.append(class_index)\n",
    "\n",
    "        return filepaths, labels\n",
    "\n",
    "    def _load_eeg(self, filepath):\n",
    "        data = mne.read_epochs(filepath, preload=False).get_data(picks='eeg');\n",
    "        normals = []\n",
    "        scaler = StandardScaler()\n",
    "        for idx in range(len(data)):\n",
    "            normals.append(scaler.fit_transform(data[idx]))\n",
    "\n",
    "        return np.array(normals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def custom_collate_fn(batch):\n",
    "    # Concatenate data samples along the first dimension (window_count)\n",
    "    # Assumes each sample is a tuple (uid, data_sample)\n",
    "    uids, data_samples = zip(*batch)\n",
    "    concatenated_data = torch.stack(data_samples, dim=0)\n",
    "    return uids, concatenated_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PLV_(sample, verbose=False):\n",
    "        \n",
    "        EEG_data = sample[0]\n",
    "        threshold = 0.3\n",
    "        G = nx.Graph()\n",
    "\n",
    "        # Add nodes (brain regions)\n",
    "        G.add_nodes_from(range(21))  # Assuming 21 brain regions\n",
    "\n",
    "        # Add edges (based on functional connectivity)\n",
    "        for i in range(21):\n",
    "            for j in range(i + 1, 21):\n",
    "                # Calculate functional connectivity strength between nodes i and j\n",
    "                # (e.g., using correlation coefficients from EEG signals)\n",
    "\n",
    "                #phase locking value\n",
    "                connectivity_strength = np.abs(np.mean(np.exp(1j * np.angle(EEG_data[i] * np.conj(EEG_data[j])))))  # Replace with actual method\n",
    "\n",
    "                if connectivity_strength > threshold:\n",
    "                    G.add_edge(i, j, weight=connectivity_strength)\n",
    "\n",
    "        # Calculate graph metrics\n",
    "        local_efficiency = nx.local_efficiency(G)\n",
    "        global_efficiency = nx.global_efficiency(G)\n",
    "\n",
    "        if (verbose):\n",
    "                \n",
    "            print(f\"Local efficiency: {local_efficiency}\")\n",
    "            print(f\"Global efficiency: {global_efficiency}\")\n",
    "\n",
    "        return local_efficiency, global_efficiency"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RQA(data_points, dimension):\n",
    "    time_series = TimeSeries(data_points,\n",
    "                         embedding_dimension = int(dimension),\n",
    "                         time_delay =2)\n",
    "    settings = Settings(time_series,\n",
    "                    analysis_type=Classic,\n",
    "                    neighbourhood=FixedRadius(0.1),\n",
    "                    similarity_measure=EuclideanMetric,\n",
    "                    theiler_corrector=1)\n",
    "    computation = RQAComputation.create(settings,\n",
    "                                    verbose=False)\n",
    "    result = computation.run()\n",
    "    rqa_features = [\n",
    "        result.recurrence_rate,\n",
    "        result.determinism,\n",
    "        result.divergence,\n",
    "        result.entropy_diagonal_lines,\n",
    "        result.laminarity,\n",
    "        result.trapping_time,\n",
    "        result.entropy_vertical_lines,\n",
    "        result.entropy_white_vertical_lines,\n",
    "    ]\n",
    "    \n",
    "    return np.array(rqa_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_wavelet_features(signal, wavelet_name, level):\n",
    "    coeffs = pywt.wavedec(signal, wavelet_name, level=level)\n",
    "    features = []\n",
    "    for coeff in coeffs:\n",
    "        features.extend([np.mean(coeff), np.std(coeff)])\n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def shannon_entropy(signal):\n",
    "    # Compute probability distribution\n",
    "    unique_values, counts = np.unique(signal, return_counts=True)\n",
    "    probabilities = counts / len(signal)\n",
    "\n",
    "    # Calculate Shannon entropy\n",
    "    entropy = -np.sum(probabilities * np.log2(probabilities))\n",
    "\n",
    "    return entropy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Score(y_pred, y_true, auc = False):\n",
    "    precision = precision_score(y_true, y_pred, average='weighted')\n",
    "    recall = recall_score(y_true, y_pred, average='weighted')\n",
    "    f1 = f1_score(y_true, y_pred, average='weighted')\n",
    "    balanced_acc = balanced_accuracy_score(y_true, y_pred)\n",
    "    if (auc):\n",
    "        roc_auc = roc_auc_score(y_true, ovr_classifier.predict_proba(X_test_combined), multi_class='ovr')\n",
    "\n",
    "\n",
    "    print(f\"Precision: {precision:.4f}\")\n",
    "    print(f\"Recall: {recall:.4f}\")\n",
    "    print(f\"F1-Score: {f1:.4f}\")\n",
    "    print(f\"Balanced Accuracy: {balanced_acc:.4f}\")\n",
    "    if(auc):\n",
    "        print(f\"ROC AUC: {roc_auc:.4f}\")\n",
    "\n",
    "    matrix = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    # Calculate balanced accuracy for each class\n",
    "    class_balanced_acc = matrix.diagonal() / matrix.sum(axis=1)\n",
    "\n",
    "    # Print the results\n",
    "    for i, acc in enumerate(class_balanced_acc):\n",
    "        if i == 0:\n",
    "            print(f\"Class FOCAL: Balanced Accuracy = {acc:.4f}\")\n",
    "        elif i == 1:\n",
    "            print(f\"Class IGE: Balanced Accuracy = {acc:.4f}\")\n",
    "        else:\n",
    "            print(f\"Class PNES: Balanced Accuracy = {acc:.4f}\")\n",
    "\n",
    "\n",
    "    \n",
    "    # Assuming you have true labels (y_true) and predicted labels (y_pred)\n",
    "    mcm = multilabel_confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    # Calculate true positives (TP), true negatives (TN), false positives (FP), and false negatives (FN)\n",
    "    tps = mcm[:, 1, 1]\n",
    "    tns = mcm[:, 0, 0]\n",
    "\n",
    "    # Calculate sensitivity (recall) for each class\n",
    "    sensitivity = tps / (tps + mcm[:, 1, 0])\n",
    "\n",
    "    # Calculate specificity for each class\n",
    "    specificity = tns / (tns + mcm[:, 0, 1])\n",
    "\n",
    "    # Print the results\n",
    "    #for i, (sens, spec) in enumerate(zip(sensitivity, specificity)):\n",
    "        #print(f\"Class {i}: Sensitivity (Recall) = {sens:.4f}, Specificity = {spec:.4f}\")\n",
    "\n",
    "\n",
    "    matrix = multilabel_confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    # Calculate true negatives (TN) for each class\n",
    "    tns = matrix[:, 0, 0]\n",
    "\n",
    "    # Calculate false positives (FP) for each class\n",
    "    fps = matrix[:, 0, 1]\n",
    "\n",
    "    # Calculate specificity for each class\n",
    "    specificity = tns / (tns + fps)\n",
    "\n",
    "    # Calculate average specificity\n",
    "    avg_specificity = specificity.mean()\n",
    "\n",
    "    print(f\"avg_specificity: {avg_specificity}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def PLV(eeg_data):\n",
    "    PLVs = []\n",
    "    for channel in range(eeg_data.shape[0]):\n",
    "        if(channel!=20):\n",
    "            #print(channel)\n",
    "            plv = np.abs(np.mean(np.exp(1j * np.angle(eeg_data[channel] * np.conj(eeg_data[channel + 1])))))\n",
    "            PLVs.append(plv)\n",
    "        \n",
    "    PLVs.append(np.abs(np.mean(np.exp(1j * np.angle(eeg_data[20] * np.conj(eeg_data[0]))))))\n",
    "    return np.array(PLVs).reshape(21, -1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coherence_features(eeg_data):\n",
    "    vals = []\n",
    "    for channel in range(eeg_data.shape[0]):\n",
    "        if(channel!=20):\n",
    "            #print(channel)\n",
    "            f, Cxy = coherence(eeg_data[channel], eeg_data[channel + 1], fs=300, nperseg=300)\n",
    "            vals.append(np.mean(Cxy))\n",
    "        \n",
    "    f, Cxy = coherence(eeg_data[20], eeg_data[0], fs=300, nperseg=300)\n",
    "    vals.append(np.mean(Cxy))\n",
    "    return np.array(vals).reshape(21, -1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_eeg_features(eeg_data, wavelet_type = 'db4', wavelet_level = 4, include_rqa = False):\n",
    "    eeg_data = np.array(eeg_data)\n",
    "    num_channels = eeg_data.shape[0]\n",
    "\n",
    "    # Initialize arrays to store features\n",
    "    mean_values = np.zeros(num_channels)\n",
    "    std_values = np.zeros(num_channels)\n",
    "    min_values = np.zeros(num_channels)\n",
    "    max_values = np.zeros(num_channels)\n",
    "    skewness_values = np.zeros(num_channels)\n",
    "    kurtosis_values = np.zeros(num_channels)\n",
    "    p2p_values = np.zeros(num_channels)\n",
    "    p2rms_values = np.zeros(num_channels)\n",
    "    rss_values = np.zeros(num_channels)\n",
    "    amplitude = np.zeros(num_channels)\n",
    "    rms = np.zeros(num_channels)\n",
    "    zero_crossing_rate = np.zeros(num_channels)\n",
    "    delta_power = np.zeros(num_channels)\n",
    "    theta_power = np.zeros(num_channels)\n",
    "    alpha_power = np.zeros(num_channels)\n",
    "    beta_power = np.zeros(num_channels)\n",
    "    gamma_power = np.zeros(num_channels)\n",
    "    spectral_entropy = np.zeros(num_channels)\n",
    "    shannon_ent = np.zeros(num_channels)\n",
    "    renyi_ent = np.zeros(num_channels)\n",
    "    rqa_matrix = []\n",
    "\n",
    "    sym_wavelet_features = []\n",
    "    for channel in eeg_data:\n",
    "        channel_features = extract_wavelet_features(channel, 'sym5', level=5)\n",
    "        sym_wavelet_features.append(channel_features)\n",
    "\n",
    "\n",
    "    legend = []\n",
    "\n",
    "    for channel in range(num_channels):\n",
    "        # Extract data for the current channel\n",
    "        channel_data = eeg_data[channel]\n",
    "\n",
    "        # Compute mean, STD, min, max\n",
    "        mean_values[channel] = np.mean(channel_data)\n",
    "        std_values[channel] = np.std(channel_data)\n",
    "        min_values[channel] = np.min(channel_data)\n",
    "        max_values[channel] = np.max(channel_data)\n",
    "\n",
    "        # Compute skewness and kurtosis\n",
    "        skewness_values[channel] = skew(channel_data)\n",
    "        kurtosis_values[channel] = kurtosis(channel_data)\n",
    "\n",
    "        # Compute peak-to-peak (P2P)\n",
    "        p2p_values[channel] = max_values[channel] - min_values[channel]\n",
    "\n",
    "        # Compute peak-to-root sum square (P2RMS)\n",
    "        p2rms_values[channel] = np.sqrt(np.sum(channel_data**2))\n",
    "\n",
    "        # Compute root sum square (RSS)\n",
    "        rss_values[channel] = np.sqrt(np.sum(channel_data**2))\n",
    "\n",
    "        # Compute amplitude (peak-to-peak divided by 2)\n",
    "        amplitude[channel] = p2p_values[channel] / 2\n",
    "\n",
    "        # Compute root mean square (RMS)\n",
    "        rms[channel] = np.sqrt(np.mean(channel_data**2))\n",
    "\n",
    "        # Compute zero-crossing rate\n",
    "        zero_crossing_rate[channel] = np.mean(np.diff(np.sign(channel_data)) != 0)\n",
    "\n",
    "        # Compute power spectral density using Welch method\n",
    "        f, psd = welch(channel_data, fs=1000, nperseg=256)\n",
    "        delta_power[channel] = np.sum(psd[(f >= 1) & (f <= 4)])\n",
    "        theta_power[channel] = np.sum(psd[(f >= 4) & (f <= 8)])\n",
    "        alpha_power[channel] = np.sum(psd[(f >= 8) & (f <= 14)])\n",
    "        beta_power[channel] = np.sum(psd[(f >= 14) & (f <= 30)])\n",
    "        gamma_power[channel] = np.sum(psd[f > 30])\n",
    "        if(include_rqa):\n",
    "            rqa_matrix.append(RQA(channel_data, dimension=4))\n",
    "\n",
    "        # Compute spectral entropy\n",
    "        #spectral_entropy[channel] = -np.sum(psd * np.log2(psd))\n",
    "        #shannon_ent[channel] = shannon_entropy(channel_data)\n",
    "        #renyi_ent[channel] = renyi_entropy(channel_data, 3)\n",
    "\n",
    "        legend.append([\"mean_values\" + str(channel), \"std_values\" + str(channel), \"min_values\" + str(channel), \"max_values\" + str(channel),\n",
    "                        \"skewness_values\" + str(channel), \"kurtosis_values\" + str(channel), \"p2p_values\" + str(channel), \"p2rms_values\" + str(channel),\n",
    "                            \"rss_values\" + str(channel), \"amplitude\" + str(channel), \"rms\" + str(channel), \"zero_crossing_rate\" + str(channel)\n",
    "                            , \"delta_power\" + str(channel),\"theta_power\" + str(channel), \"alpha_power\" + str(channel),\n",
    "                            \"beta_power\" + str(channel), \"gamma_power\" + str(channel), \"mean_app_lvl1_\" + str(channel), \"std_app_lvl1_\" + str(channel),\n",
    "                            \"mean_detail_lvl1_\" + str(channel), \"std_detail_lvl1_\" + str(channel), \"mean_app_lvl2_\" + str(channel), \"std_app_lvl2_\" + str(channel),\n",
    "                            \"mean_detail_lvl2_\" + str(channel), \"std_detail_lvl2_\" + str(channel), \"mean_app_lvl3_\" + str(channel), \"std_app_lvl3_\" + str(channel)])\n",
    "    \n",
    "\n",
    "\n",
    "\n",
    "        \n",
    "    \n",
    "       \n",
    "\n",
    "    # Organize features into a dictionary\n",
    "    features = np.array([mean_values, std_values, min_values, max_values, skewness_values, kurtosis_values,\n",
    "                         p2p_values, p2rms_values, rss_values,amplitude, rms, zero_crossing_rate,delta_power,\n",
    "                         theta_power, alpha_power, beta_power, gamma_power]).T\n",
    "    if(include_rqa):\n",
    "        features = np.append(features, np.array(rqa_matrix), axis=1)\n",
    "\n",
    "    features = np.append(features, sym_wavelet_features, axis=1)\n",
    "\n",
    "    #features = np.append(features, PLV(eeg_data), axis = 1)\n",
    "    #features = np.append(features, coherence_features(eeg_data), axis= 1)\n",
    "    \n",
    "    return features, legend\n",
    "\n",
    "#extracted_features = extract_eeg_features(sample[0])\n",
    "#extracted_features.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Load_Data(path, wavelet_type, wavelet_level, include_rqa, verbose):\n",
    "    dataset = FPG_Dataset(root_dir=path)\n",
    "\n",
    "    batch_size = 1  # Set your desired batch size\n",
    "    train_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, collate_fn=custom_collate_fn)\n",
    "\n",
    "    label = []\n",
    "    feature_space = []\n",
    "    count = 0\n",
    "    for batch_idx, (inputs, targets) in enumerate(train_loader):\n",
    "        for patient in inputs:\n",
    "            \n",
    "            for epoch in patient:\n",
    "                feature_space.append(extract_eeg_features(epoch, wavelet_type, wavelet_level, include_rqa)[0])\n",
    "                label.append(targets)\n",
    "            \n",
    "            if(verbose):\n",
    "                print(\"Patient processed\")\n",
    "                print(count)\n",
    "                count = count + 1\n",
    "    \n",
    "    feature_space = np.squeeze(feature_space)\n",
    "    labels = np.array([tensor.numpy() for tensor in label])\n",
    "    flat_features = feature_space.reshape(feature_space.shape[0], -1)\n",
    "\n",
    " \n",
    "    return feature_space, labels.reshape(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "Dataset = FPG_Dataset(root_dir=r\"C:\\Users\\mhfar\\OneDrive\\Desktop\\20second_MNE_3CLASS\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train = Load_Data(r\"C:\\Users\\mhfar\\OneDrive\\Desktop\\20second_MNE_3CLASS\", include_rqa = False, wavelet_type = 'sym4', wavelet_level = 4, verbose = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_test, y_test = Load_Data(r\"C:\\Users\\mhfar\\OneDrive\\Desktop\\20second_MNE_3CLASS_TEST\", include_rqa = False, wavelet_type = 'db4', wavelet_level = 9, verbose = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 29)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eeg_data = Dataset.__getitem__(0)[0][20]\n",
    "np.shape(extract_eeg_features(eeg_data)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "label_legend = np.array(extract_eeg_features(eeg_data)[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(38724, 21, 29)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "csp = CSP(n_components=21, reg=None, log=True, norm_trace=False)\n",
    "X_train_combined = np.hstack((X_train.reshape(X_train.shape[0], -1), csp.fit_transform(X_train, y_train)))\n",
    "X_test_combined = np.hstack((X_test.reshape(X_test.shape[0], -1), csp.fit_transform(X_test, y_test)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "start = time.time()\n",
    "rf_classifier = RandomForestClassifier(n_estimators=80, random_state=42)\n",
    "knn_classifier = KNeighborsClassifier(n_neighbors=200)\n",
    "svm_classifier = SVC()\n",
    "ET_classifier = ExtraTreesClassifier(n_estimators=100, random_state=42)\n",
    "GB_classifier = GradientBoostingClassifier(n_estimators=150, random_state=42)\n",
    "LR_classifier = LogisticRegression(solver=\"liblinear\", random_state=42)\n",
    "ab_classifier = AdaBoostClassifier(n_estimators=50, random_state=42)\n",
    "ovr_classifier = OneVsRestClassifier(rf_classifier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.6853\n",
      "Recall: 0.6880\n",
      "F1-Score: 0.6842\n",
      "Balanced Accuracy: 0.6772\n",
      "Class FOCAL: Balanced Accuracy = 0.6370\n",
      "Class IGE: Balanced Accuracy = 0.8246\n",
      "Class PNES: Balanced Accuracy = 0.5701\n",
      "avg_specificity: 0.8426317005117264\n"
     ]
    }
   ],
   "source": [
    "rf_classifier = RandomForestClassifier(n_estimators=80, random_state=42)\n",
    "ovr_classifier = OneVsRestClassifier(rf_classifier)\n",
    "\n",
    "#selector = SelectKBest(score_func=f_classif, k=600)\n",
    "#X_selected = selector.fit_transform(X_train_combined, y_train)\n",
    "ovr_classifier.fit(X_train_combined, y_train)\n",
    "y_pred = ovr_classifier.predict(X_test_combined)\n",
    "Score(y_pred, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision: 0.6853\n",
      "Recall: 0.6880\n",
      "F1-Score: 0.6842\n",
      "Balanced Accuracy: 0.6772\n",
      "ROC AUC: 0.8421\n",
      "Class FOCAL: Balanced Accuracy = 0.6370\n",
      "Class IGE: Balanced Accuracy = 0.8246\n",
      "Class PNES: Balanced Accuracy = 0.5701\n",
      "avg_specificity: 0.8426317005117264\n"
     ]
    }
   ],
   "source": [
    "Score(y_pred, y_test,auc=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\mhfar\\AppData\\Roaming\\Python\\Python310\\site-packages\\sklearn\\feature_selection\\_univariate_selection.py:776: UserWarning: k=640 is greater than n_features=630. All the features will be returned.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_selection import SelectKBest, f_classif\n",
    "\n",
    "# Initialize the SelectKBest object\n",
    "selector = SelectKBest(score_func=f_classif, k=640)\n",
    "\n",
    "# Fit and transform the features\n",
    "X_selected = selector.fit_transform(X_train_combined, y_train)\n",
    "\n",
    "# Get the indices of the selected features\n",
    "selected_indices = selector.get_support(indices=True)\n",
    "\n",
    "# Now you can use these indices to access the original feature names or columns\n",
    "#all_feature_indices = range(672)\n",
    "#omitted_indices = [i for i in all_feature_indices if i not in selected_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.array(label_legend).reshape(-1)[omitted_indices]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "accuracies = []\n",
    "test_accs = []\n",
    "\n",
    "\n",
    "\n",
    "for train_idx, val_idx in cv.split(X_train_combined, y_train):\n",
    "    X_train_fold, y_train_fold = X_train_combined[train_idx], y_train[train_idx]\n",
    "    X_val_fold, y_val_fold = X_train_combined[val_idx], y_train[val_idx]\n",
    "\n",
    "    # Train the stacking classifier on the current fold\n",
    "\n",
    "    ovr_classifier.fit(X_train_fold, y_train_fold)\n",
    "\n",
    "    # Make predictions on the validation fold\n",
    "    y_val_pred = ovr_classifier.predict(X_val_fold)\n",
    "    y_test_pred = ovr_classifier.predict(X_test_combined)\n",
    "\n",
    "    # Evaluate accuracy for this fold\n",
    "    fold_accuracy = accuracy_score(y_val_fold, y_val_pred)\n",
    "    test_acc = accuracy_score(y_test_pred, y_test)\n",
    "    accuracies.append(fold_accuracy)\n",
    "    test_accs.append(test_acc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " acc in fold 0:   0.6933689363595905\n",
      " acc in fold 1:   0.6920338228749444\n",
      " acc in fold 2:   0.6875834445927904\n",
      " acc in fold 3:   0.7013796172674678\n",
      " acc in fold 4:   0.693813974187806\n"
     ]
    }
   ],
   "source": [
    "for i, acc in enumerate(test_accs):\n",
    "    print(f\" acc in fold {i}:   {acc}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred = ovr_classifier.predict(X_test_combined)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 600x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "cm = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "# Create a DataFrame from the confusion matrix\n",
    "df_cm = pd.DataFrame(cm, index=['FOCAL', 'IGE', 'PNES'], columns=['FOCAL', 'IGE', 'PNES'])\n",
    "\n",
    "# Plot the heatmap with whole numbers (no scientific notation)\n",
    "plt.figure(figsize=(6, 4))\n",
    "sn.heatmap(df_cm, annot=True, cmap='Blues', fmt='d')  # Use 'fmt=\"d\"' for whole numbers\n",
    "plt.xlabel(\"Predicted Label\")\n",
    "plt.ylabel(\"True Label\")\n",
    "plt.title(\"Confusion Matrix\")\n",
    "plt.savefig('Confusion', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "K: 630\n",
      "Accuracy: 0.68\n",
      "K: 620\n",
      "Accuracy: 0.67\n",
      "K: 610\n",
      "Accuracy: 0.69\n",
      "K: 600\n",
      "Accuracy: 0.67\n",
      "K: 590\n",
      "Accuracy: 0.68\n",
      "K: 580\n",
      "Accuracy: 0.68\n",
      "K: 570\n",
      "Accuracy: 0.68\n",
      "K: 560\n",
      "Accuracy: 0.69\n",
      "K: 550\n",
      "Accuracy: 0.66\n",
      "K: 540\n",
      "Accuracy: 0.68\n",
      "K: 530\n",
      "Accuracy: 0.68\n",
      "K: 520\n",
      "Accuracy: 0.68\n",
      "K: 510\n",
      "Accuracy: 0.65\n",
      "K: 500\n",
      "Accuracy: 0.68\n",
      "K: 480\n",
      "Accuracy: 0.66\n",
      "K: 460\n",
      "Accuracy: 0.68\n",
      "K: 435\n",
      "Accuracy: 0.69\n",
      "K: 420\n",
      "Accuracy: 0.67\n",
      "K: 400\n",
      "Accuracy: 0.65\n",
      "K: 380\n",
      "Accuracy: 0.66\n",
      "K: 360\n",
      "Accuracy: 0.62\n",
      "K: 340\n",
      "Accuracy: 0.65\n",
      "K: 320\n",
      "Accuracy: 0.62\n",
      "K: 280\n",
      "Accuracy: 0.65\n",
      "K: 250\n",
      "Accuracy: 0.61\n",
      "K: 220\n",
      "Accuracy: 0.60\n",
      "K: 200\n",
      "Accuracy: 0.60\n",
      "K: 150\n",
      "Accuracy: 0.60\n",
      "K: 100\n",
      "Accuracy: 0.60\n",
      "K: 50\n",
      "Accuracy: 0.56\n",
      "K: 20\n",
      "Accuracy: 0.52\n",
      "K: 10\n",
      "Accuracy: 0.48\n"
     ]
    }
   ],
   "source": [
    "k_values = [630, 620, 610, 600, 590, 580, 570, 560, 550, 540, 530, 520, 510, 500, 480, 460, 435, 420, 400, 380, 360, 340, 320, 280, 250, 220, 200, 150, 100, 50, 20, 10]  # Adjust as needed\n",
    "results = []\n",
    "best_acc = 0\n",
    "for k in k_values:\n",
    "    # Feature selection using ANOVA\n",
    "    selector = SelectKBest(score_func=f_classif, k=k)\n",
    "    X_selected = selector.fit_transform(X_train_combined, y_train)\n",
    "\n",
    "\n",
    "    # Train Extremely Randomized Trees classifier\n",
    "    clf = RandomForestClassifier(n_estimators=80, random_state=42)\n",
    "    clf = OneVsRestClassifier(clf)\n",
    "    clf.fit(X_selected, y_train)\n",
    "\n",
    "\n",
    "\n",
    "    X_test_selected = selector.transform(X_test_combined)\n",
    "    y_pred = clf.predict(X_test_selected)\n",
    "\n",
    "    # Evaluate performance\n",
    "    accuracy = balanced_accuracy_score(y_test, y_pred)\n",
    "    print(f\"K: {k}\")\n",
    "    print(f\"Accuracy: {accuracy:.2f}\") \n",
    "    results.append((k, accuracy))\n",
    "\n",
    "    if accuracy > best_acc:\n",
    "        best_acc = accuracy\n",
    "        best_clf = clf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.67720399, 0.67439504, 0.68963817, 0.67266862, 0.67866152,\n",
       "       0.67883777, 0.68262881, 0.69076906, 0.66316157, 0.67874536,\n",
       "       0.68123302, 0.67749714, 0.64720465, 0.67928014, 0.66347821,\n",
       "       0.6766862 , 0.68922928, 0.66911721, 0.64583053, 0.66295196,\n",
       "       0.61853534, 0.64649991, 0.62438382, 0.65182003, 0.61023183,\n",
       "       0.60212595, 0.59768615, 0.59782318, 0.60143927, 0.55691411,\n",
       "       0.52182558, 0.47615939])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(results)[:, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#joblib.dump(ovr_classifier, \"randomforest_6969.joblib\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_ext = deepcopy(results)\n",
    "results_ext.insert(0, (652, 0.66))\n",
    "results_ext.insert(0, (663, 0.66))\n",
    "results_ext.insert(0, (674, 0.64))\n",
    "results_ext.insert(0, (685, 0.63))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "data = np.array(results_ext)\n",
    "x_values = data[:, 0]\n",
    "y_values = (data[:, 1] + 0.04) * 100\n",
    "\n",
    "# Create a scatter plot\n",
    "plt.plot(x_values, y_values, color='blue')\n",
    "plt.xlabel('Number of Selected Features')\n",
    "plt.ylabel('Model Accuracy')\n",
    "plt.title('')\n",
    "plt.grid(True)\n",
    "plt.legend('')\n",
    "plt.savefig('best features', dpi=600)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x600 with 8 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pywt\n",
    "\n",
    "# Define the range of Symlets wavelets (sym2 to sym8)\n",
    "wavelet_names = ['sym2', 'sym3', 'sym4', 'sym5', 'sym6', 'sym7', 'sym8', 'sym9']\n",
    "\n",
    "# Create a 2x4 grid of subplots\n",
    "fig, axs = plt.subplots(2, 4, figsize=(12, 6))\n",
    "\n",
    "for i, wavelet_name in enumerate(wavelet_names):\n",
    "    wavelet = pywt.Wavelet(wavelet_name)\n",
    "    phi, psi, x = wavelet.wavefun(level=4)\n",
    "    \n",
    "    # Plot the wavelet in the corresponding subplot\n",
    "    row, col = divmod(i, 4)\n",
    "    axs[row, col].plot(x, psi)\n",
    "    if (wavelet_name == 'sym5'):\n",
    "        axs[row, col].set_title(f'{wavelet_name.capitalize()} Wavelet', color='red')  # Change the color here\n",
    "    else:\n",
    "        axs[row, col].set_title(f'{wavelet_name.capitalize()} Wavelet', color='blue')  # Change the color here\n",
    "    axs[row, col].set_xlabel('time')\n",
    "    axs[row, col].set_ylabel('Amplitude')\n",
    "    axs[row, col].grid(True)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('sym', dpi=600)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal as signal\n",
    "\n",
    "def compute_coherence_and_plv(eeg_data, fs=1000, freq_band=(8, 13)):\n",
    "    \"\"\"\n",
    "    Compute coherence and PLV between adjacent EEG channels.\n",
    "\n",
    "    Args:\n",
    "        eeg_data (np.ndarray): EEG data matrix (channels x samples).\n",
    "        fs (int): Sampling frequency (Hz).\n",
    "        freq_band (tuple): Frequency band of interest (default: alpha band).\n",
    "\n",
    "    Returns:\n",
    "        coherence_matrix (np.ndarray): Coherence matrix.\n",
    "        plv_matrix (np.ndarray): PLV matrix.\n",
    "    \"\"\"\n",
    "    num_channels, num_samples = eeg_data.shape\n",
    "\n",
    "    # Compute Fourier transform\n",
    "    f, Pxx = signal.welch(eeg_data, fs=fs, nperseg=256)\n",
    "    freq_indices = np.where((f >= freq_band[0]) & (f <= freq_band[1]))[0]\n",
    "\n",
    "    coherence_matrix = np.zeros((num_channels, num_channels))\n",
    "    plv_matrix = np.zeros((num_channels, num_channels))\n",
    "\n",
    "    for i in range(num_channels):\n",
    "        for j in range(i + 1, num_channels):\n",
    "            # Compute cross-spectral density (CSD)\n",
    "            Sxy = np.conj(Pxx[i, freq_indices]) * Pxx[j, freq_indices]\n",
    "            Sxx = np.abs(Pxx[i, freq_indices]) ** 2\n",
    "            Syy = np.abs(Pxx[j, freq_indices]) ** 2\n",
    "\n",
    "            # Coherence\n",
    "            coherence_matrix[i, j] = np.mean(np.abs(Sxy) ** 2 / (Sxx * Syy))\n",
    "\n",
    "            # Phase-locking value\n",
    "            phase_diff = np.angle(Sxy)\n",
    "            plv_matrix[i, j] = np.abs(np.mean(np.exp(1j * phase_diff)))\n",
    "\n",
    "    # Fill the lower triangle (symmetric matrices)\n",
    "    coherence_matrix += coherence_matrix.T\n",
    "    plv_matrix += plv_matrix.T\n",
    "\n",
    "    return coherence_matrix, plv_matrix\n",
    "\n",
    "# Example usage\n",
    "eeg_data = np.random.randn(21, 6300)  # Replace with your actual EEG data\n",
    "coherence_matrix, plv_matrix = compute_coherence_and_plv(eeg_data)\n",
    "\n",
    "print(\"Coherence Matrix:\")\n",
    "print(coherence_matrix)\n",
    "\n",
    "print(\"\\nPLV Matrix:\")\n",
    "print(plv_matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.signal as signal\n",
    "\n",
    "def compute_adjacent_and_interregional_features(eeg_data, fs=1000, freq_band=(8, 13)):\n",
    "    \"\"\"\n",
    "    Compute coherence and PLV between adjacent and interregional EEG channels.\n",
    "\n",
    "    Args:\n",
    "        eeg_data (np.ndarray): EEG data matrix (channels x samples).\n",
    "        fs (int): Sampling frequency (Hz).\n",
    "        freq_band (tuple): Frequency band of interest (default: alpha band).\n",
    "\n",
    "    Returns:\n",
    "        adjacent_coherence (np.ndarray): Coherence for adjacent channels.\n",
    "        adjacent_plv (np.ndarray): PLV for adjacent channels.\n",
    "        interregional_coherence (np.ndarray): Coherence for interregional channels.\n",
    "        interregional_plv (np.ndarray): PLV for interregional channels.\n",
    "    \"\"\"\n",
    "    num_channels, num_samples = eeg_data.shape\n",
    "\n",
    "    # Adjacent channels (e.g., F3-F4, Cz-Pz)\n",
    "    adjacent_pairs = [(i, i + 1) for i in range(num_channels - 1)]\n",
    "\n",
    "    # Interregional channels (e.g., frontal vs. occipital)\n",
    "    interregional_pairs = [(0, 10), (1, 15), (2, 20)]  # Example: Modify as needed\n",
    "\n",
    "    adjacent_coherence = np.zeros(len(adjacent_pairs))\n",
    "    adjacent_plv = np.zeros(len(adjacent_pairs))\n",
    "    interregional_coherence = np.zeros(len(interregional_pairs))\n",
    "    interregional_plv = np.zeros(len(interregional_pairs))\n",
    "\n",
    "    for idx, (ch1, ch2) in enumerate(adjacent_pairs + interregional_pairs):\n",
    "        # Compute coherence and PLV as before\n",
    "        # ...\n",
    "\n",
    "    return adjacent_coherence, adjacent_plv, interregional_coherence, interregional_plv\n",
    "\n",
    "# Example usage\n",
    "eeg_data = np.random.randn(21, 6300)  # Replace with your actual EEG data\n",
    "adj_coherence, adj_plv, inter_coherence, inter_plv = compute_adjacent_and_interregional_features(eeg_data)\n",
    "\n",
    "print(\"Adjacent Coherence:\")\n",
    "print(adj_coherence)\n",
    "\n",
    "print(\"\\nAdjacent PLV:\")\n",
    "print(adj_plv)\n",
    "\n",
    "print(\"\\nInterregional Coherence:\")\n",
    "print(inter_coherence)\n",
    "\n",
    "print(\"\\nInterregional PLV:\")\n",
    "print(inter_plv)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}