result_all.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "from scipy import io, signal\n",
    "import matplotlib.pyplot as plt\n",
    "import dtcwt\n",
    "import numpy as np\n",
    "import itertools\n",
    "import pywt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\statsmodels\\compat\\pandas.py:56: FutureWarning: The pandas.core.datetools module is deprecated and will be removed in a future version. Please use the pandas.tseries module instead.\n",
      "  from pandas.core import datetools\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from numpy.linalg import LinAlgError\n",
    "from statsmodels.tsa.stattools import adfuller\n",
    "#1\n",
    "def AE(x): # Absolute Energy\n",
    "    x = np.asarray(x)\n",
    "    return sum(x * x)\n",
    "\n",
    "#2\n",
    "def SM2(y):\n",
    "    #t1 = time.time()\n",
    "    f, Pxx_den = signal.welch(y)\n",
    "    sm2 = 0\n",
    "    n = len(f)\n",
    "    for i in range(0,n):\n",
    "        sm2 += Pxx_den[i]*(f[i]**2)\n",
    "    \n",
    "    #t2 = time.time()\n",
    "    #print('time: ', t2-t2)\n",
    "    return sm2\n",
    "\n",
    "\n",
    "#3\n",
    "def LOG(y):\n",
    "    n = len(y)\n",
    "    return np.exp(np.sum(np.log(np.abs(y)))/n)\n",
    "\n",
    "#4\n",
    "def WL(x): # WL in primary manuscript\n",
    "    return np.sum(abs(np.diff(x)))\n",
    "\n",
    "#5\n",
    "def ADF(x): # teststat, pvalue, usedlag\n",
    "    # augmented dickey fuller\n",
    "    # returns a tuple\n",
    "    res = None\n",
    "    try:\n",
    "        res = adfuller(x)\n",
    "    except LinAlgError:\n",
    "        res = np.NaN, np.NaN, np.NaN\n",
    "    except ValueError:  # occurs if sample size is too small\n",
    "        #print('Length Error')\n",
    "        res = np.NaN, np.NaN, np.NaN\n",
    "\n",
    "    return res[0], res[1], res[2]\n",
    "\n",
    "\n",
    "#6\n",
    "def AC(x, lag=5): # autocorrelation\n",
    "\n",
    "    \"\"\"\n",
    "     [1] https://en.wikipedia.org/wiki/Autocorrelation#Estimation\n",
    "\n",
    "    \"\"\"\n",
    "    # This is important: If a series is passed, the product below is calculated\n",
    "    # based on the index, which corresponds to squaring the series.\n",
    "    if type(x) is pd.Series:\n",
    "        x = x.values\n",
    "    if len(x) < lag:\n",
    "        return np.nan\n",
    "    # Slice the relevant subseries based on the lag\n",
    "    y1 = x[:(len(x)-lag)]\n",
    "    y2 = x[lag:]\n",
    "    # Subtract the mean of the whole series x\n",
    "    x_mean = np.mean(x)\n",
    "    # The result is sometimes referred to as \"covariation\"\n",
    "    sum_product = np.sum((y1-x_mean)*(y2-x_mean))\n",
    "    # Return the normalized unbiased covariance\n",
    "    return sum_product / ((len(x) - lag) * np.var(x))\n",
    "\n",
    "#7\n",
    "def BE(x, max_bins=30): # binned entropy\n",
    "    hist, bin_edges = np.histogram(x, bins=max_bins)\n",
    "    probs = hist / len(x)\n",
    "    return - np.sum(p * np.math.log(p) for p in probs if p != 0)\n",
    "\n",
    "#8\n",
    "def C3(x, lag = 5): # c3 feature\n",
    "    n = len(x)\n",
    "    x = np.asarray(x)\n",
    "    if 2 * lag >= n:\n",
    "        return 0\n",
    "    else:\n",
    "        return np.mean((np.roll(x, 2 * -lag) * np.roll(x, -lag) * x)[0:(n - 2 * lag)])\n",
    "    \n",
    "    \n",
    "#9\n",
    "def CC(x, normalize=True): # cid ce\n",
    "    x = np.asarray(x)\n",
    "    if normalize:\n",
    "        s = np.std(x)\n",
    "        if s!=0:\n",
    "            x = (x - np.mean(x))/s\n",
    "        else:\n",
    "            return 0.0\n",
    "\n",
    "    x = np.diff(x)\n",
    "    return np.sqrt(np.sum((x * x)))\n",
    "\n",
    "\n",
    "#10\n",
    "def CAM(x): # count above mean\n",
    "    x = np.asarray(x)\n",
    "    m = np.mean(x)\n",
    "    return np.where(x > m)[0].shape[0]\n",
    "\n",
    "#11\n",
    "def CBM(x): # count below mean\n",
    "    x = np.asarray(x)\n",
    "    m = np.mean(x)\n",
    "    return np.where(x < m)[0].shape[0]\n",
    "\n",
    "\n",
    "#12\n",
    "def AAC(x): #AAC in primary manuscript\n",
    "    return np.mean(abs(np.diff(x)))\n",
    "\n",
    "#13\n",
    "def MSDC(x): # mean second derivative central\n",
    "    diff = (np.roll(x, 1) - 2 * np.array(x) + np.roll(x, -1)) / 2.0\n",
    "    return np.mean(diff[1:-1])\n",
    "\n",
    "#14\n",
    "def ZC(x, m = 0): # zero/mean crossing\n",
    "    # m = np.mean(x)\n",
    "    x = np.asarray(x)\n",
    "    x = x[x != m]\n",
    "    return sum(np.abs(np.diff(np.sign(x - m))))/2\n",
    "\n",
    "\n",
    "#15\n",
    "def SE(x): # sample entropy\n",
    "    \"\"\"\n",
    "    [1] http://en.wikipedia.org/wiki/Sample_Entropy\n",
    "    [2] https://www.ncbi.nlm.nih.gov/pubmed/10843903?dopt=Abstract\n",
    "    \"\"\"\n",
    "    x = np.array(x)\n",
    "\n",
    "    sample_length = 1 # number of sequential points of the time series\n",
    "    tolerance = 0.2 * np.std(x) # 0.2 is a common value for r - why?\n",
    "\n",
    "    n = len(x)\n",
    "    prev = np.zeros(n)\n",
    "    curr = np.zeros(n)\n",
    "    A = np.zeros((1, 1))  # number of matches for m = [1,...,template_length - 1]\n",
    "    B = np.zeros((1, 1))  # number of matches for m = [1,...,template_length]\n",
    "\n",
    "    for i in range(n - 1):\n",
    "        nj = n - i - 1\n",
    "        ts1 = x[i]\n",
    "        for jj in range(nj):\n",
    "            j = jj + i + 1\n",
    "            if abs(x[j] - ts1) < tolerance:  # distance between two vectors\n",
    "                curr[jj] = prev[jj] + 1\n",
    "                temp_ts_length = min(sample_length, curr[jj])\n",
    "                for m in range(int(temp_ts_length)):\n",
    "                    A[m] += 1\n",
    "                    if j < n - 1:\n",
    "                        B[m] += 1\n",
    "            else:\n",
    "                curr[jj] = 0\n",
    "        for j in range(nj):\n",
    "            prev[j] = curr[j]\n",
    "\n",
    "    N = n * (n - 1) / 2\n",
    "    B = np.vstack(([N], B[0]))\n",
    "\n",
    "    # sample entropy = -1 * (log (A/B))\n",
    "    similarity_ratio = A / B\n",
    "    se = -1 * np.log(similarity_ratio)\n",
    "    se = np.reshape(se, -1)\n",
    "    return se[0]\n",
    "\n",
    "#16\n",
    "def TRAS(x, lag=5):\n",
    "    # time reversal asymmetry statistic\n",
    "    \"\"\"\n",
    "    |  [1] Fulcher, B.D., Jones, N.S. (2014).\n",
    "    |  Highly comparative feature-based time-series classification.\n",
    "    |  Knowledge and Data Engineering, IEEE Transactions on 26, 3026–3037.\n",
    "    \"\"\"\n",
    "    n = len(x)\n",
    "    x = np.asarray(x)\n",
    "    if 2 * lag >= n:\n",
    "        return 0\n",
    "    else:\n",
    "        return np.mean((np.roll(x, 2 * -lag) * np.roll(x, 2 * -lag) * np.roll(x, -lag) -\n",
    "                        np.roll(x, -lag) * x * x)[0:(n - 2 * lag)])\n",
    "    \n",
    "    \n",
    "#17    \n",
    "def VAR(x): # variance \n",
    "    return np.var(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from sklearn.feature_selection import SelectKBest\n",
    "from sklearn.feature_selection import mutual_info_classif\n",
    "import time\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "def load_features(sub):\n",
    "    # Load DWT-denoised time-series data\n",
    "    # SubA\n",
    "    SubA = io.loadmat(str('DWT_' + sub + '.mat'))\n",
    "    A_sig = SubA[str('DWT_' + sub)]\n",
    "    A_lab = SubA[str(sub + '_LAB')]\n",
    "\n",
    "    print(A_sig.shape)\n",
    "    print(A_lab.shape)\n",
    "\n",
    "    n_ch, tp, sp = A_sig.shape\n",
    "    A_sig_dtcwt = np.zeros((sp,(int)(tp/8),n_ch), dtype=np.float32)\n",
    "    transform = dtcwt.Transform1d()\n",
    "    for cs in range(sp):\n",
    "        for ch in range(n_ch):\n",
    "            vecs_t = transform.forward(A_sig[ch,:,cs], nlevels=3)\n",
    "            A_sig_dtcwt[cs,:,ch] = np.abs(vecs_t.highpasses[2]).reshape(int(tp/8))\n",
    "            # Took absoulute value\n",
    "            # May change\n",
    "\n",
    "    print(A_sig_dtcwt.shape)\n",
    "\n",
    "    print(len(vecs_t.highpasses[0]))\n",
    "    print(len(vecs_t.highpasses[1]))\n",
    "    print(len(vecs_t.highpasses[2]))\n",
    "\n",
    "    n_features = 17\n",
    "    n_features += 2 # ADF\n",
    "    featuresAll = np.zeros((sp,n_ch*n_features), dtype = np.float32)\n",
    "\n",
    "    t1 = time.time()\n",
    "    # To-do: Optimize {PyPy didn't help}\n",
    "    for cs in range(sp):\n",
    "        c_f = []\n",
    "        for ch in range(n_ch):\n",
    "            y = A_sig_dtcwt[cs,:,ch]\n",
    "            c_f.append(AE(y))\n",
    "            c_f.append(SM2(y))\n",
    "            c_f.append(LOG(y))\n",
    "            c_f.append(WL(y))\n",
    "            f1, f2, f3 = ADF(y)\n",
    "            c_f.append(f1)\n",
    "            c_f.append(f2)\n",
    "            c_f.append(f3)\n",
    "            c_f.append(AC(y))\n",
    "            c_f.append(BE(y))\n",
    "            c_f.append(C3(y))\n",
    "            c_f.append(CC(y))\n",
    "            c_f.append(CAM(y))\n",
    "            c_f.append(CBM(y))\n",
    "            c_f.append(AAC(y))\n",
    "            c_f.append(MSDC(y))\n",
    "            c_f.append(ZC(y))\n",
    "            c_f.append(SE(y))\n",
    "            c_f.append(TRAS(y))\n",
    "            c_f.append(VAR(y))\n",
    "        #c_f = np.array(c_f)\n",
    "        #c_f = c_f.reshape(n_ch*n_features)\n",
    "        featuresAll[cs,:] = c_f  \n",
    "\n",
    "    t2 = time.time()\n",
    "    print('\\ntime: ',t2-t1,'s')\n",
    "\n",
    "\n",
    "    X_all = featuresAll\n",
    "    y = A_lab.reshape(len(A_lab),)\n",
    "    print(np.mean(X_all))\n",
    "    print(np.var(X_all))\n",
    "\n",
    "    \n",
    "\n",
    "    scaler = StandardScaler()\n",
    "    scaler.fit(X_all)\n",
    "    #print(scaler.mean_)\n",
    "    X_all = scaler.transform(X_all)\n",
    "\n",
    "    print(np.mean(X_all))\n",
    "    print(np.std(X_all))\n",
    "\n",
    "    print(X_all.shape)\n",
    "    X_fs_o = SelectKBest(mutual_info_classif, k=30)\n",
    "    X_fs = X_fs_o.fit_transform(X_all, y)\n",
    "    feature_ids = X_fs_o.get_support(indices=True)\n",
    "\n",
    "    mi = mutual_info_classif(X_fs,y)\n",
    "\n",
    "    print(X_fs.shape)\n",
    "    print(y.shape)\n",
    "\n",
    "    np.save(str('features_' + sub + '.npy'),X_fs)\n",
    "    np.save(str('y_' + sub + '.npy'),y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 1024, 270)\n",
      "(270, 1)\n",
      "(270, 128, 5)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  81.09680819511414 s\n",
      "7.4900603\n",
      "397.74893\n",
      "2.082096e-09\n",
      "0.9733286\n",
      "(270, 95)\n",
      "(270, 30)\n",
      "(270,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 1000, 174)\n",
      "(174, 1)\n",
      "(174, 125, 5)\n",
      "500\n",
      "250\n",
      "125\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 125, using nperseg = 125\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  41.90011191368103 s\n",
      "127.06293\n",
      "263355.3\n",
      "-3.7039257e-08\n",
      "0.9733286\n",
      "(174, 95)\n",
      "(174, 30)\n",
      "(174,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('B')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 1024, 180)\n",
      "(180, 1)\n",
      "(180, 128, 5)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  42.46362495422363 s\n",
      "7.514137\n",
      "398.84607\n",
      "-7.027074e-08\n",
      "0.97332853\n",
      "(180, 95)\n",
      "(180, 30)\n",
      "(180,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 1024, 80)\n",
      "(80, 1)\n",
      "(80, 128, 5)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  20.486637592315674 s\n",
      "7.399624\n",
      "401.22025\n",
      "4.015471e-08\n",
      "0.97332853\n",
      "(80, 95)\n",
      "(80, 30)\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('D')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 1024, 48)\n",
      "(48, 1)\n",
      "(48, 128, 5)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  11.718890905380249 s\n",
      "7.4992857\n",
      "416.83585\n",
      "-6.6924515e-09\n",
      "0.97332853\n",
      "(48, 95)\n",
      "(48, 30)\n",
      "(48,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('E')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 1024, 80)\n",
      "(80, 1)\n",
      "(80, 128, 6)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  26.196662425994873 s\n",
      "7.461227\n",
      "397.40985\n",
      "2.0411977e-07\n",
      "0.97332853\n",
      "(80, 114)\n",
      "(80, 30)\n",
      "(80,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 1024, 120)\n",
      "(120, 1)\n",
      "(120, 128, 6)\n",
      "512\n",
      "256\n",
      "128\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 128, using nperseg = 128\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  34.575576066970825 s\n",
      "7.4959965\n",
      "397.2147\n",
      "6.6924514e-08\n",
      "0.97332853\n",
      "(120, 114)\n",
      "(120, 30)\n",
      "(120,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('G')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, 768, 150)\n",
      "(150, 1)\n",
      "(150, 96, 6)\n",
      "384\n",
      "192\n",
      "96\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\scipy\\signal\\spectral.py:1637: UserWarning: nperseg = 256 is greater than input length  = 96, using nperseg = 96\n",
      "  .format(nperseg, input_length))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "time:  27.342111110687256 s\n",
      "5.6762156\n",
      "224.77808\n",
      "8.120174e-08\n",
      "0.97332853\n",
      "(150, 114)\n",
      "(150, 30)\n",
      "(150,)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\__init__.py:54: FutureWarning: Conversion of the second argument of issubdtype from `int` to `np.signedinteger` is deprecated. In future, it will be treated as `np.int32 == np.dtype(int).type`.\n",
      "  if np.issubdtype(mask.dtype, np.int):\n"
     ]
    }
   ],
   "source": [
    "load_features('H')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classification with all selected features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(270, 30)\n",
      "(270,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_A.npy')\n",
    "y = np.load('y_A.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 10-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.8555555555555555 0.09629629629629631\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn import svm\n",
    "\n",
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)                                             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7962962962962963 0.09514987095307503\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.725925925925926 0.12035612451312537\n"
     ]
    }
   ],
   "source": [
    "from sklearn import tree\n",
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7925925925925925 0.15608375930152205\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.762962962962963 0.17276894503245335\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(174, 30)\n",
      "(174,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_B.npy')\n",
    "y = np.load('y_B.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7666666666666667 0.22244433344430575\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6788888888888889 0.24271102565666158\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6633333333333333 0.23286725938574354\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6777777777777778 0.22355157937705405\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6588888888888889 0.25820845249191904\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(180, 30)\n",
      "(180,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_C.npy')\n",
    "y = np.load('y_C.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.8944444444444446 0.15275252316519464\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.861111111111111 0.2063797291222967\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7833333333333333 0.20757268546966\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.861111111111111 0.15112745009706047\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.7777777777777777 0.2484519974999766\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(80, 30)\n",
      "(80,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_D.npy')\n",
    "y = np.load('y_D.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5125 0.3051638903933426\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5625 0.20155644370746376\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.55 0.27838821814150105\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.625 0.27386127875258304\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.675 0.406201920231798\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(48, 30)\n",
      "(48,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_E.npy')\n",
    "y = np.load('y_E.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.8916666666666668 0.23629078131263043\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.8 0.30912061651652345\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.875 0.3435921354681384\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.875 0.30956959368344517\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.85 0.33993463423951903\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(80, 30)\n",
      "(80,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_F.npy')\n",
    "y = np.load('y_F.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.775 0.29154759474226505\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.625 0.31622776601683794\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.675 0.2549509756796392\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6375 0.361420807370024\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.575 0.4213074886588179\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject G"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(120, 30)\n",
      "(120,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_G.npy')\n",
    "y = np.load('y_G.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6916666666666667 0.23629078131263043\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.675 0.21666666666666665\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6583333333333333 0.2629955639676584\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.6416666666666667 0.2891558595482912\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.625 0.3270236145058097\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Subject H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 30)\n",
      "(150,)\n"
     ]
    }
   ],
   "source": [
    "X = np.load('features_H.npy')\n",
    "y = np.load('y_H.npy')\n",
    "print(X.shape)\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5767857142857143 0.2242049445102787\n"
     ]
    }
   ],
   "source": [
    "clf = svm.SVC(kernel='linear', C=1)\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5375000000000001 0.23915241489690298\n"
     ]
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_neighbors=10)\n",
    "\n",
    "scores = cross_val_score(knn, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5035714285714287 0.23134478201002354\n"
     ]
    }
   ],
   "source": [
    "clf = tree.DecisionTreeClassifier()\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5928571428571427 0.2847304489713536\n"
     ]
    }
   ],
   "source": [
    "clf = RandomForestClassifier(n_estimators=10, max_depth=None,\n",
    "    min_samples_split=2, random_state=0)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy:  0.5821428571428571 0.21455340422679417\n"
     ]
    }
   ],
   "source": [
    "clf = AdaBoostClassifier(n_estimators=100)\n",
    "\n",
    "scores = cross_val_score(clf, X, y, cv=10)\n",
    "print('Accuracy: ', scores.mean(), scores.std() * 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### References:\n",
    "* https://tsfresh.readthedocs.io/en/latest/api/tsfresh.feature_extraction.html\n",
    "* B. C. Ross “Mutual Information between Discrete and Continuous Data Sets”. PLoS ONE 9(2), 2014.\n",
    "* https://en.wikipedia.org/wiki/Autocorrelation#Estimation\n",
    "* http://scikit-learn.org/stable/auto_examples/ensemble/plot_forest_importances.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}