HAR-combined-freq-Feat. (1).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import cross_val_score\n",
    "import math\n",
    "from scipy.stats import iqr\n",
    "from numpy import linalg\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy import stats\n",
    "from scipy.signal import butter, lfilter, freqz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "## Features\n",
    "\n",
    "def mean(x, y, z):\n",
    "    \"\"\"Calculates mean\"\"\"\n",
    "    mean_x = np.mean(x)\n",
    "    mean_y = np.mean(y)\n",
    "    mean_z = np.mean(z)\n",
    "    return mean_x, mean_y, mean_z\n",
    "\n",
    "def std_dev(x, y, z):\n",
    "    \"\"\"Calculates standard deviation\"\"\"\n",
    "    std_x = np.std(x)\n",
    "    std_y = np.std(y)\n",
    "    std_z = np.std(z)\n",
    "    return std_x, std_y, std_z  \n",
    "    \n",
    "def mad(x, y, z):\n",
    "    \"\"\"Calculates median absolute deviation\"\"\"\n",
    "    mad_x = np.median(np.abs(x - np.median(x)))\n",
    "    mad_y = np.median(np.abs(y - np.median(y)))\n",
    "    mad_z = np.median(np.abs(z - np.median(z)))\n",
    "    return mad_x, mad_y, mad_z\n",
    "\n",
    "def minimum(x, y, z):\n",
    "    \"\"\"Calculates minimum\"\"\"\n",
    "    return min(x), min(y), min(z)\n",
    "\n",
    "def maximum(x, y, z):\n",
    "    \"\"\"Calculates maximum\"\"\"\n",
    "    return max(x), max(y), max(z)\n",
    "\n",
    "def energy_measure(x, y, z):\n",
    "    \"\"\"Calculates energy measures\"\"\"\n",
    "    em_x = np.mean(np.square(x))\n",
    "    em_y = np.mean(np.square(y))\n",
    "    em_z = np.mean(np.square(z))\n",
    "    return em_x, em_y, em_z\n",
    "\n",
    "def inter_quartile_range(x, y, z):\n",
    "    \"\"\"Calculates inter-quartile range\"\"\"\n",
    "    iqr_x = np.subtract(*np.percentile(x, [75, 25]))\n",
    "    iqr_y = np.subtract(*np.percentile(y, [75, 25]))\n",
    "    iqr_z = np.subtract(*np.percentile(z, [75, 25]))\n",
    "    return iqr_x, iqr_y, iqr_z\n",
    "\n",
    "def sma(x, y, z):\n",
    "    \"\"\"Calculates signal magnitude area\"\"\"   \n",
    "    abs_x = np.absolute(x)\n",
    "    abs_y = np.absolute(y)\n",
    "    abs_z = np.absolute(z)\n",
    "    return np.mean(abs_x+abs_y+abs_z)\n",
    "\n",
    "def skewness(x, y, z):\n",
    "    \"\"\"Calculates skewness\"\"\"\n",
    "    skew_x=stats.skew(x)\n",
    "    skew_y=stats.skew(y)\n",
    "    skew_z=stats.skew(z)\n",
    "    return skew_x, skew_y, skew_z\n",
    "\n",
    "def kurt(x, y, z):\n",
    "    \"\"\"Calculates kurtosis\"\"\"\n",
    "    kurt_x = stats.kurtosis(x,fisher=False)\n",
    "    kurt_y = stats.kurtosis(y,fisher=False)\n",
    "    kurt_z = stats.kurtosis(z,fisher=False)\n",
    "    return kurt_x, kurt_y, kurt_z\n",
    "    \n",
    "def max_index(x, y, z):\n",
    "    \"\"\"Calculates index of maximum\"\"\"\n",
    "  #  [val_x, idx_x] = max(x)\n",
    "    idx_x = np.argmax(x)\n",
    "   # [val_y, idx_y] = max(y)\n",
    "    idx_y = np.argmax(y)\n",
    "    #[val_z, idx_z] = max(z)\n",
    "    idx_z = np.argmax(z)\n",
    "    return idx_x, idx_y, idx_z\n",
    "    \n",
    "def butter_bandpass(lowcut, highcut, fs, order=5):\n",
    "    nyq = 0.5 * fs\n",
    "    low = lowcut / nyq\n",
    "    high = highcut / nyq\n",
    "    b, a = butter(order, [low, high], btype='band')\n",
    "    return b, a\n",
    "\n",
    "\n",
    "def butter_bandpass_filter(data, lowcut, highcut, fs, order=5):\n",
    "    b, a = butter_bandpass(lowcut, highcut, fs, order=order)\n",
    "    y = lfilter(b, a, data)\n",
    "    return y\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def process_acc(input_df, columns, output_df, freq_flag):\n",
    "    i = 0\n",
    "  \n",
    "    while i < len(input_df[0]):\n",
    "        max_window = input_df[0][i] + 5000\n",
    "        min_window = input_df[0][i]\n",
    "        if i != 0:                                  #handling overlap\n",
    "            min_window -= 2500\n",
    "            max_window -= 2500\n",
    "            i -= int(count/2)\n",
    "        x = [input_df[1][i]]\n",
    "        y = [input_df[2][i]]\n",
    "        z = [input_df[3][i]]\n",
    "       \n",
    "        \n",
    "        count = 0\n",
    "        while min_window < max_window:\n",
    "            i += 1\n",
    "            count += 1\n",
    "            try:\n",
    "                x.append(input_df[1][i])\n",
    "                y.append(input_df[2][i])\n",
    "                z.append(input_df[3][i])\n",
    "                min_window = input_df[0][i]\n",
    "            except KeyError:\n",
    "                break\n",
    "        \n",
    "        sma_val = (sma(x,y,z), )\n",
    "      \n",
    "        \n",
    "        if freq_flag == 0:\n",
    "            acc_data = list(mean(x, y, z)+std_dev(x, y, z)+mad(x, y, z)+minimum(x, y, z)+maximum(x, y, z)+energy_measure(x, y, z)+inter_quartile_range(x, y, z)+sma_val)\n",
    "        \n",
    "        \n",
    "        else:\n",
    "            acc_data = list(mean(x, y, z)+std_dev(x, y, z)+mad(x, y, z)+minimum(x, y, z)+maximum(x, y, z)+energy_measure(x, y, z)+inter_quartile_range(x, y, z)+sma_val+\n",
    "                            skewness(x, y, z)+kurt(x, y, z)+max_index(x, y, z))\n",
    "        \n",
    "        \n",
    "        \n",
    "        output_df = output_df.append(pd.Series(acc_data, index=columns), ignore_index=True)\n",
    "    return output_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def process_gyr(input_df, columns, output_df, freq_flag):\n",
    "\n",
    "    i = 0\n",
    "    while i < len(input_df[0]):\n",
    "        max_window = input_df[0][i] + 5000\n",
    "        min_window = input_df[0][i]\n",
    "        if i != 0:                                                                 #handling overlap\n",
    "            min_window -= 2500\n",
    "            max_window -= 2500\n",
    "            i -= int(count/2)\n",
    "        x = [input_df[1][i]]\n",
    "        y = [input_df[2][i]]\n",
    "        z = [input_df[3][i]]\n",
    "        count = 0\n",
    "        while min_window < max_window:\n",
    "            i += 1\n",
    "            count += 1\n",
    "            try:\n",
    "                x.append(input_df[1][i])\n",
    "                y.append(input_df[2][i])\n",
    "                z.append(input_df[3][i])\n",
    "                min_window = input_df[0][i]\n",
    "            except KeyError:\n",
    "                break\n",
    "        \n",
    "        \n",
    "        label = (input_df[5][1], )\n",
    "        sma_val = (sma(x,y,z), )\n",
    "\n",
    "       # gy_data = list(mean(x, y, z)+std_dev(x, y, z)+mad(x, y, z)+minimum(x, y, z)+maximum(x, y, z)+energy_measure(x, y, z)+inter_quartile_range(x, y, z)+sma_val+label) \n",
    "        #output_df = output_df.append(pd.Series(gy_data, index=columns), ignore_index=True)\n",
    "        \n",
    "        \n",
    "        if freq_flag == 0:\n",
    "            gy_data = list(mean(x, y, z)+std_dev(x, y, z)+mad(x, y, z)+minimum(x, y, z)+maximum(x, y, z)+energy_measure(x, y, z)+inter_quartile_range(x, y, z)+sma_val+label)\n",
    "        \n",
    "        \n",
    "        else:\n",
    "            gy_data = list(mean(x, y, z)+std_dev(x, y, z)+mad(x, y, z)+minimum(x, y, z)+maximum(x, y, z)+energy_measure(x, y, z)+inter_quartile_range(x, y, z)+sma_val+\n",
    "                            skewness(x, y, z)+kurt(x, y, z)+max_index(x, y, z))\n",
    "        \n",
    "        \n",
    "        \n",
    "        output_df = output_df.append(pd.Series(gy_data, index=columns), ignore_index=True)\n",
    "        \n",
    "        \n",
    "    return output_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def process_mag(input_df, columns, output_df, freq_flag):\n",
    "    mag = np.linalg.norm(input_df.iloc[:,1:4], axis = 1)\n",
    "    input_df[6] = mag.tolist()\n",
    "    \n",
    "    i = 0\n",
    "    while i < len(input_df[0]):\n",
    "        max_window = input_df[0][i] + 5000\n",
    "        min_window = input_df[0][i]\n",
    "        if i != 0:                                  #handling overlap\n",
    "            min_window -= 2500\n",
    "            max_window -= 2500\n",
    "            i -= int(count/2)\n",
    "        x = [input_df[6][i]]\n",
    "        \n",
    "        \n",
    "        count = 0\n",
    "        while min_window < max_window:\n",
    "            i += 1\n",
    "            count += 1\n",
    "            try:\n",
    "                x.append(input_df[6][i])\n",
    "                min_window = input_df[0][i]\n",
    "            except KeyError:\n",
    "                break\n",
    "        \n",
    "        mean = (np.mean(x),)\n",
    "        std_dev = (np.std(x),)\n",
    "        mad = (np.median(np.abs(x - np.median(x))),)\n",
    "        minimum = (np.min(x),)\n",
    "        maximum = (np.max(x),)\n",
    "        energy_measure = (np.mean(np.square(x)),)\n",
    "        inter_quartile_range = (np.subtract(*np.percentile(x, [75, 25])),)\n",
    "        sma_val = (np.mean(np.absolute(x)),)\n",
    "        \n",
    "        \n",
    "        \n",
    "        if freq_flag == 0:\n",
    "            acc_data = list(mean+std_dev+mad+minimum+maximum+energy_measure+inter_quartile_range+sma_val)\n",
    "        else:\n",
    "            skew = (stats.skew(x),)\n",
    "            kur = (stats.kurtosis(x,fisher=False),)\n",
    "            m_idx = (np.argmax(x),)\n",
    "            acc_data = list(mean+std_dev+mad+minimum+maximum+energy_measure+inter_quartile_range+sma_val+skew+kur+m_idx)\n",
    "        \n",
    "        output_df = output_df.append(pd.Series(acc_data, index=columns), ignore_index=True)\n",
    "\n",
    "    return output_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hist_activities(df):\n",
    "    df['label'].value_counts().plot(kind='bar', title='Training examples by activity type')\n",
    "    plt.show()\n",
    "    \n",
    "def plot_activity(activity, df):\n",
    "    data = df[df.iloc[:, 5] == activity][[1, 2, 3]][:2000]\n",
    "    axis = data.plot(subplots=True, figsize=(16, 12), \n",
    "                     title=activity)\n",
    "    for ax in axis:\n",
    "        ax.legend(loc='lower left', bbox_to_anchor=(1.0, 0.5))\n",
    "        \n",
    "def plot_act_signals(df):\n",
    "    plot_activity(\"sitting\", df)\n",
    "    plt.ylabel('sitting')\n",
    "    plt.show()\n",
    "    plot_activity(\"walking\", df)\n",
    "    plt.ylabel('walking')\n",
    "    plt.show()\n",
    "    plot_activity(\"standing\", df)\n",
    "    plt.ylabel('standing')\n",
    "    plt.show()\n",
    "    plot_activity(\"laying_down\", df)\n",
    "    plt.ylabel('laying_down')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calc_jerk(acc, ts):\n",
    "    jk = [0]* len(acc)\n",
    "    for i in range(1,len(acc)):\n",
    "        jk[i-1] = 1000*(acc[i] - acc[i-1])/(ts[i] - ts[i-1])\n",
    "    return jk\n",
    "\n",
    "def fmagnitude(num):\n",
    "    return math.sqrt(num.real**2 + num.imag**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_session_dirs(path):\n",
    "    path = path\n",
    "    dirs = []\n",
    "    dir_list = [x[0] for x in os.walk(path)]\n",
    "    last_dirs = [\"1_android.sensor.accelerometer.data.csv.gz\",\"4_android.sensor.gyroscope.data.csv.gz\"]\n",
    "    dirs = []\n",
    "    for each_dir in dir_list[2:]:\n",
    "\n",
    "        if \"data\" in each_dir:\n",
    "            dirs.append(each_dir)\n",
    "\n",
    "    dirs.sort(key=lambda x:x[-22:])\n",
    "    return dirs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_jerk(df):\n",
    "    df[1] = calc_jerk(df[1],df[0])\n",
    "    df[2] = calc_jerk(df[2],df[0])\n",
    "    df[3] = calc_jerk(df[3],df[0])\n",
    "    return df\n",
    "\n",
    "def get_fft(df):\n",
    "    df[1] = np.fft.fft(df[1])\n",
    "    df[2] = np.fft.fft(df[2])\n",
    "    df[3] = np.fft.fft(df[3])\n",
    "    df[1] = [fmagnitude(j) for j in df[1]]\n",
    "    df[2] = [fmagnitude(j) for j in df[2]]\n",
    "    df[3] = [fmagnitude(j) for j in df[3]]\n",
    "    return df\n",
    "\n",
    "def five_point_smoothing(df):\n",
    "    m=np.array(df[1])\n",
    "    m_smooth = np.zeros(len(m))\n",
    "    m_smooth = m;\n",
    "    for i ,val in enumerate(m_smooth[2 : (len(m_smooth) -2)]):\n",
    "        m_smooth[i] = (m_smooth[i-2] + m_smooth[i-1] + m_smooth[i] + m_smooth[i+1] + m_smooth[i+2])/5\n",
    "    df[1] = m_smooth\n",
    "        \n",
    "    m=np.array(df[2])\n",
    "    m_smooth = np.zeros(len(m))\n",
    "    m_smooth = m;\n",
    "    for i ,val in enumerate(m_smooth[2 : (len(m_smooth) -2)]):\n",
    "        m_smooth[i] = (m_smooth[i-2] + m_smooth[i-1] + m_smooth[i] + m_smooth[i+1] + m_smooth[i+2])/5\n",
    "    df[2] = m_smooth\n",
    "    \n",
    "    m = np.array(df[3])\n",
    "    m_smooth = np.zeros(len(m))\n",
    "    m_smooth = m;\n",
    "    for i ,val in enumerate(m_smooth[2 : (len(m_smooth) -2)]):\n",
    "        m_smooth[i] = (m_smooth[i-2] + m_smooth[i-1] + m_smooth[i] + m_smooth[i+1] + m_smooth[i+2])/5\n",
    "    df[3] = m_smooth\n",
    "    \n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "processing acceleration: Sessions/14442D57F7E1B88_Thu_Feb_08_00-16_2018_PST/data/1_android.sensor.accelerometer.data.csv.gz\n",
      "processing gyroscope: Sessions/14442D57F7E1B88_Thu_Feb_08_00-16_2018_PST/data/4_android.sensor.gyroscope.data.csv.gz\n",
      "processing acceleration: Sessions/14442D57F7E1B88_Thu_Feb_08_07-43_2018_PST/data/1_android.sensor.accelerometer.data.csv.gz\n",
      "processing gyroscope: Sessions/14442D57F7E1B88_Thu_Feb_08_07-43_2018_PST/data/4_android.sensor.gyroscope.data.csv.gz\n",
      "processing acceleration: Sessions/14442D57F7E1B88_Thu_Feb_08_07-54_2018_PST/data/1_android.sensor.accelerometer.data.csv.gz\n"
     ]
    }
   ],
   "source": [
    "dirs = get_session_dirs(\"Sessions/\")\n",
    "\n",
    "tacc_cols = ['mean_acc_x', 'mean_acc_y', 'mean_acc_z', \n",
    "           'std_acc_x', 'std_acc_y', 'std_acc_z', \n",
    "           'mad_acc_x', 'mad_acc_y', 'mad_acc_z',\n",
    "           'min_acc_x', 'min_acc_y', 'min_acc_z', \n",
    "           'max_acc_x', 'max_acc_y', 'max_acc_z', \n",
    "           'em_acc_x', 'em_acc_y', 'em_acc_z', \n",
    "           'iqr_acc_x', 'iqr_acc_y', 'iqr_acc_z', \n",
    "           'sma_acc']\n",
    "out_acc_df = pd.DataFrame(columns = tacc_cols)\n",
    "\n",
    "tacc_jerk_cols = ['mean_accj_x', 'mean_accj_y', 'mean_accj_z', \n",
    "               'std_accj_x', 'std_accj_y', 'std_accj_z', \n",
    "               'mad_accj_x', 'mad_accj_y', 'mad_accj_z',\n",
    "               'min_accj_x', 'min_accj_y', 'min_accj_z', \n",
    "               'max_accj_x', 'max_accj_y', 'max_accj_z', \n",
    "               'em_accj_x', 'em_accj_y', 'em_accj_z', \n",
    "               'iqr_accj_x', 'iqr_accj_y', 'iqr_accj_z', \n",
    "               'sma_accj']\n",
    "out_acc_jerk_df = pd.DataFrame(columns = tacc_jerk_cols)\n",
    "\n",
    "tacc_mag_cols = ['mean_macc', 'std_macc', 'mad_macc', 'min_macc', 'max_macc', 'em_macc', 'iqr_macc', 'sma_macc']\n",
    "acc_mag = pd.DataFrame(columns = tacc_mag_cols)\n",
    "\n",
    "tacc_jmag_cols = ['mean_macc_jerk', 'std_macc_jerk', 'mad_macc_jerk', 'min_macc_jerk', 'max_macc_jerk', \n",
    "                 'em_macc_jerk', 'iqr_macc_jerk', 'sma_macc_jerk']\n",
    "acc_jerk_mag = pd.DataFrame(columns = tacc_jmag_cols)\n",
    "\n",
    "facc_cols = ['mean_facc_x', 'mean_facc_y', 'mean_facc_z', \n",
    "           'std_facc_x', 'std_facc_y', 'std_facc_z', \n",
    "           'mad_facc_x', 'mad_facc_y', 'mad_facc_z',\n",
    "           'min_facc_x', 'min_facc_y', 'min_facc_z', \n",
    "           'max_facc_x', 'max_facc_y', 'max_facc_z', \n",
    "           'em_facc_x', 'em_facc_y', 'em_facc_z', \n",
    "           'iqr_facc_x', 'iqr_facc_y', 'iqr_facc_z', \n",
    "           'sma_facc', \n",
    "           'skew_facc_x', 'skew_facc_y', 'skew_facc_z', \n",
    "           'kurt_facc_x', 'kurt_facc_y', 'kurt_facc_z', \n",
    "           'idx_facc_x', 'idx_facc_y', 'idx_facc_z']\n",
    "out_facc_df = pd.DataFrame(columns = facc_cols)\n",
    "\n",
    "facc_jerk_cols = ['mean_faccj_x', 'mean_faccj_y', 'mean_faccj_z', \n",
    "               'std_faccj_x', 'std_faccj_y', 'std_faccj_z', \n",
    "               'mad_faccj_x', 'mad_faccj_y', 'mad_faccj_z',\n",
    "               'min_faccj_x', 'min_faccj_y', 'min_faccj_z', \n",
    "               'max_faccj_x', 'max_faccj_y', 'max_faccj_z', \n",
    "               'em_faccj_x', 'em_faccj_y', 'em_faccj_z', \n",
    "               'iqr_faccj_x', 'iqr_faccj_y', 'iqr_faccj_z', \n",
    "               'sma_faccj', \n",
    "               'skew_faccj_x', 'skew_faccj_y', 'skew_faccj_z', \n",
    "               'kurt_faccj_x', 'kurt_faccj_y', 'kurt_faccj_z', \n",
    "               'idx_faccj_x', 'idx_faccj_y', 'idx_faccj_z']\n",
    "out_facc_jerk_df = pd.DataFrame(columns = facc_jerk_cols)\n",
    "\n",
    "facc_mag_cols = ['mean_mfacc', 'std_mfacc', 'mad_mfacc', 'min_mfacc', 'max_mfacc', 'em_mfacc', 'iqr_mfacc', 'sma_mfacc',\n",
    "                'skew_mfacc', 'kurt_mfacc',  'idx_mfacc']\n",
    "facc_mag = pd.DataFrame(columns = facc_mag_cols)\n",
    "\n",
    "facc_jmag_cols = ['mean_mfacc_jerk', 'std_mfacc_jerk', 'mad_mfacc_jerk', 'min_mfacc_jerk', 'max_mfacc_jerk', \n",
    "                 'em_mfacc_jerk', 'iqr_mfacc_jerk', 'sma_mfacc_jerk', 'skew_mfacc_jerk', 'kurt_mfacc_jerk',  \n",
    "                  'idx_mfacc_jerk']\n",
    "facc_jerk_mag = pd.DataFrame(columns = facc_jmag_cols)\n",
    "\n",
    "tgy_cols = ['mean_gy_x', 'mean_gy_y', 'mean_gy_z', \n",
    "           'std_gy_x', 'std_gy_y', 'std_gy_z', \n",
    "           'mad_gy_x', 'mad_gy_y', 'mad_gy_z',\n",
    "           'min_gy_x', 'min_gy_y', 'min_gy_z', \n",
    "           'max_gy_x', 'max_gy_y', 'max_gy_z', \n",
    "           'em_gy_x', 'em_gy_y', 'em_gy_z', \n",
    "           'iqr_gy_x', 'iqr_gy_y', 'iqr_gy_z', \n",
    "           'sma_gy', 'label']\n",
    "out_gy_df = pd.DataFrame(columns = tgy_cols)\n",
    "\n",
    "tgy_jerk_cols = ['mean_gyj_x', 'mean_gyj_y', 'mean_gyj_z', \n",
    "               'std_gyj_x', 'std_gyj_y', 'std_gyj_z', \n",
    "               'mad_gyj_x', 'mad_gyj_y', 'mad_gyj_z',\n",
    "               'min_gyj_x', 'min_gyj_y', 'min_gyj_z', \n",
    "               'max_gyj_x', 'max_gyj_y', 'max_gyj_z', \n",
    "               'em_gyj_x', 'em_gyj_y', 'em_gyj_z', \n",
    "               'iqr_gyj_x', 'iqr_gyj_y', 'iqr_gyj_z', \n",
    "               'sma_gyj']\n",
    "out_gy_jerk_df = pd.DataFrame(columns = tgy_jerk_cols)\n",
    "\n",
    "tgy_mag_cols = ['mean_mgy', 'std_mgy', 'mad_mgy', 'min_mgy', 'max_mgy', 'em_mgy', 'iqr_mgy', 'sma_mgy']\n",
    "gy_mag = pd.DataFrame(columns = tgy_mag_cols)\n",
    "\n",
    "tgy_jmag_cols = ['mean_mgy_jerk', 'std_mgy_jerk', 'mad_mgy_jerk', 'min_mgy_jerk', 'max_mgy_jerk', \n",
    "                 'em_mgy_jerk', 'iqr_mgy_jerk', 'sma_mgy_jerk']\n",
    "gy_jerk_mag = pd.DataFrame(columns = tgy_jmag_cols)\n",
    "\n",
    "fgy_cols = ['mean_fgy_x', 'mean_fgy_y', 'mean_fgy_z', \n",
    "           'std_fgy_x', 'std_fgy_y', 'std_fgy_z', \n",
    "           'mad_fgy_x', 'mad_fgy_y', 'mad_fgy_z',\n",
    "           'min_fgy_x', 'min_fgy_y', 'min_fgy_z', \n",
    "           'max_fgy_x', 'max_fgy_y', 'max_fgy_z', \n",
    "           'em_fgy_x', 'em_fgy_y', 'em_fgy_z', \n",
    "           'iqr_fgy_x', 'iqr_fgy_y', 'iqr_fgy_z', \n",
    "           'sma_fgy', \n",
    "           'skew_fgy_x', 'skew_fgy_y', 'skew_fgy_z', \n",
    "           'kurt_fgy_x', 'kurt_fgy_y', 'kurt_fgy_z', \n",
    "           'idx_fgy_x', 'idx_fgy_y', 'idx_fgy_z']\n",
    "out_fgy_df = pd.DataFrame(columns = fgy_cols)\n",
    "\n",
    "fgy_jerk_cols = ['mean_fgyj_x', 'mean_fgyj_y', 'mean_fgyj_z', \n",
    "               'std_fgyj_x', 'std_fgyj_y', 'std_fgyj_z', \n",
    "               'mad_fgyj_x', 'mad_fgyj_y', 'mad_fgyj_z',\n",
    "               'min_fgyj_x', 'min_fgyj_y', 'min_fgyj_z', \n",
    "               'max_fgyj_x', 'max_fgyj_y', 'max_fgyj_z', \n",
    "               'em_fgyj_x', 'em_fgyj_y', 'em_fgyj_z', \n",
    "               'iqr_fgyj_x', 'iqr_fgyj_y', 'iqr_fgyj_z', \n",
    "               'sma_fgyj', \n",
    "               'skew_fgyj_x', 'skew_fgyj_y', 'skew_fgyj_z', \n",
    "               'kurt_fgyj_x', 'kurt_fgyj_y', 'kurt_fgyj_z', \n",
    "               'idx_fgyj_x', 'idx_fgyj_y', 'idx_fgyj_z']\n",
    "out_fgy_jerk_df = pd.DataFrame(columns = fgy_jerk_cols)\n",
    "\n",
    "fgy_mag_cols = ['mean_mfgy', 'std_mfgy', 'mad_mfgy', 'min_mfgy', 'max_mfgy', 'em_mfgy', 'iqr_mfgy', 'sma_mfgy',\n",
    "                'skew_mfgy', 'kurt_mfgy',  'idx_mfgy']\n",
    "fgy_mag = pd.DataFrame(columns = fgy_mag_cols)\n",
    "\n",
    "fgy_jmag_cols = ['mean_mfgy_jerk', 'std_mfgy_jerk', 'mad_mfgy_jerk', 'min_mfgy_jerk', 'max_mfgy_jerk', \n",
    "                 'em_mfgy_jerk', 'iqr_mfgy_jerk', 'sma_mfgy_jerk',\n",
    "                'skew_mfgy_jerk', 'kurt_mfgy_jerk',  'idx_mfgy_jerk']\n",
    "fgy_jerk_mag = pd.DataFrame(columns = fgy_jmag_cols)\n",
    "\n",
    "\n",
    "acc_gy_df = pd.DataFrame()\n",
    "\n",
    "for i in dirs: \n",
    "    full_path_acc = os.path.normpath(i + \"/\" + \"1_android.sensor.accelerometer.data.csv.gz\")\n",
    "    full_path_gy = os.path.normpath(i + \"/\" + \"4_android.sensor.gyroscope.data.csv.gz\")\n",
    "    \n",
    "    print(\"processing acceleration: \" + full_path_acc)\n",
    "    in_df_ac = pd.read_csv(full_path_acc, compression='gzip', sep=',', header=None)\n",
    "    \n",
    "    in_df_ac = five_point_smoothing(in_df_ac)\n",
    "    \n",
    "    in_df_ac_jerk = in_df_ac.copy()\n",
    "    in_df_ac_jerk = get_jerk(in_df_ac_jerk)\n",
    "    \n",
    "    in_df_fac = in_df_ac.copy()\n",
    "    in_df_fac = get_fft(in_df_fac)\n",
    "    \n",
    "    in_df_fac_jerk = in_df_ac_jerk.copy()\n",
    "    in_df_fac_jerk = get_fft(in_df_fac_jerk)\n",
    "    \n",
    "    out_acc_df = process_acc(in_df_ac, tacc_cols, out_acc_df, 0)\n",
    "    out_acc_jerk_df = process_acc(in_df_ac_jerk, tacc_jerk_cols, out_acc_jerk_df, 0)\n",
    "    out_facc_df = process_acc(in_df_fac, facc_cols, out_facc_df, 1)\n",
    "    out_facc_jerk_df = process_acc(in_df_fac_jerk, facc_jerk_cols, out_facc_jerk_df, 1)\n",
    "    \n",
    "    acc_mag = process_mag(in_df_ac, tacc_mag_cols, acc_mag, 0)\n",
    "    acc_jerk_mag = process_mag(in_df_ac_jerk, tacc_jmag_cols, acc_jerk_mag, 0)\n",
    "    facc_mag = process_mag(in_df_fac, facc_mag_cols, facc_mag, 1)\n",
    "    facc_jerk_mag = process_mag(in_df_fac_jerk, facc_jmag_cols, facc_jerk_mag, 1)\n",
    "    \n",
    "    print(\"processing gyroscope: \" + full_path_gy)\n",
    "    in_df_gy = pd.read_csv(full_path_gy, compression='gzip', sep=',', header=None)\n",
    "    \n",
    "    in_df_gy_jerk = in_df_gy.copy()\n",
    "    in_df_gy_jerk = get_jerk(in_df_gy_jerk)\n",
    "    \n",
    "    in_df_fgy = in_df_gy.copy()\n",
    "    in_df_fgy = get_fft(in_df_fgy)\n",
    "    \n",
    "    in_df_fgy_jerk = in_df_gy_jerk.copy()\n",
    "    in_df_fgy_jerk = get_fft(in_df_fgy_jerk)\n",
    "    \n",
    "    out_gy_df = process_gyr(in_df_gy, tgy_cols, out_gy_df, 0)\n",
    "    out_gy_jerk_df = process_acc(in_df_gy_jerk, tgy_jerk_cols, out_gy_jerk_df, 0)\n",
    "    out_fgy_df = process_acc(in_df_fgy, fgy_cols, out_fgy_df, 1)\n",
    "    out_fgy_jerk_df = process_acc(in_df_fgy_jerk, fgy_jerk_cols, out_fgy_jerk_df, 1)\n",
    "    \n",
    "    gy_mag = process_mag(in_df_gy, tgy_mag_cols, gy_mag, 0)\n",
    "    gy_jerk_mag = process_mag(in_df_gy_jerk, tgy_jmag_cols, gy_jerk_mag, 0)\n",
    "    fgy_mag = process_mag(in_df_fgy, fgy_mag_cols, fgy_mag, 1)\n",
    "    fgy_jerk_mag = process_mag(in_df_fgy_jerk, fgy_jmag_cols, fgy_jerk_mag, 1)\n",
    "    \n",
    "    \n",
    "    #handling mismatch in rows\n",
    "    if out_gy_df.shape[0] < out_acc_df.shape[0]:\n",
    "        out_acc_df = out_acc_df[:out_gy_df.shape[0]]\n",
    "        out_acc_jerk_df = out_acc_jerk_df[:out_gy_df.shape[0]]\n",
    "        out_facc_df = out_facc_df[:out_gy_df.shape[0]]\n",
    "        out_facc_jerk_df = out_facc_jerk_df[:out_gy_df.shape[0]]\n",
    "        acc_mag = acc_mag[:out_gy_df.shape[0]]\n",
    "        acc_jerk_mag = acc_jerk_mag[:out_gy_df.shape[0]]\n",
    "        facc_mag = facc_mag[:out_gy_df.shape[0]]\n",
    "        facc_jerk_mag = facc_jerk_mag[:out_gy_df.shape[0]]\n",
    "    \n",
    "    acc_gy_df = pd.concat([out_acc_df, acc_mag, out_acc_jerk_df, acc_jerk_mag, \n",
    "                           out_facc_df, facc_mag, out_facc_jerk_df, facc_jerk_mag,\n",
    "                           out_gy_df, gy_mag, out_gy_jerk_df, gy_jerk_mag, \n",
    "                           out_fgy_df, fgy_mag, out_fgy_jerk_df, fgy_jerk_mag], axis=1)\n",
    "    \n",
    "print(acc_gy_df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAE9CAYAAADtUd4qAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x111d70fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAALMCAYAAAAW8boyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSilVCXTBrZRSSimllFJKVYL/D1b139ReKHmOAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1a23d5ee50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "ename": "TypeError",
     "evalue": "Empty 'DataFrame': no numeric data to plot",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-40-8d8b1b1de448>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mhist_activities\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0macc_gy_df\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mplot_act_signals\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0min_df_ac\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mcombined_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0macc_gy_df\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mcombined_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcombined_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrandom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpermutation\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcombined_df\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-35-64c372d6ebee>\u001b[0m in \u001b[0;36mplot_act_signals\u001b[0;34m(df)\u001b[0m\n\u001b[1;32m     14\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'sitting'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m     \u001b[0mplot_activity\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"walking\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mylabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'walking'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-35-64c372d6ebee>\u001b[0m in \u001b[0;36mplot_activity\u001b[0;34m(activity, df)\u001b[0m\n\u001b[1;32m      6\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mactivity\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2000\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     axis = data.plot(subplots=True, figsize=(16, 12), \n\u001b[0;32m----> 8\u001b[0;31m                      title=activity)\n\u001b[0m\u001b[1;32m      9\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0max\u001b[0m \u001b[0;32min\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m         \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'lower left'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbbox_to_anchor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Users/aashna/anaconda2/lib/python2.7/site-packages/pandas/plotting/_core.pyc\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, x, y, kind, ax, subplots, sharex, sharey, layout, figsize, use_index, title, grid, legend, style, logx, logy, loglog, xticks, yticks, xlim, ylim, rot, fontsize, colormap, table, yerr, xerr, secondary_y, sort_columns, **kwds)\u001b[0m\n\u001b[1;32m   2625\u001b[0m                           \u001b[0mfontsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfontsize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolormap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcolormap\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtable\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2626\u001b[0m                           \u001b[0myerr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myerr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxerr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mxerr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msecondary_y\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msecondary_y\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2627\u001b[0;31m                           sort_columns=sort_columns, **kwds)\n\u001b[0m\u001b[1;32m   2628\u001b[0m     \u001b[0m__call__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplot_frame\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2629\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Users/aashna/anaconda2/lib/python2.7/site-packages/pandas/plotting/_core.pyc\u001b[0m in \u001b[0;36mplot_frame\u001b[0;34m(data, x, y, kind, ax, subplots, sharex, sharey, layout, figsize, use_index, title, grid, legend, style, logx, logy, loglog, xticks, yticks, xlim, ylim, rot, fontsize, colormap, table, yerr, xerr, secondary_y, sort_columns, **kwds)\u001b[0m\n\u001b[1;32m   1867\u001b[0m                  \u001b[0myerr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0myerr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mxerr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mxerr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1868\u001b[0m                  \u001b[0msecondary_y\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msecondary_y\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msort_columns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msort_columns\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1869\u001b[0;31m                  **kwds)\n\u001b[0m\u001b[1;32m   1870\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1871\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Users/aashna/anaconda2/lib/python2.7/site-packages/pandas/plotting/_core.pyc\u001b[0m in \u001b[0;36m_plot\u001b[0;34m(data, x, y, subplots, ax, kind, **kwds)\u001b[0m\n\u001b[1;32m   1692\u001b[0m         \u001b[0mplot_obj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mklass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msubplots\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkind\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkind\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1693\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1694\u001b[0;31m     \u001b[0mplot_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1695\u001b[0m     \u001b[0mplot_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1696\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mplot_obj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Users/aashna/anaconda2/lib/python2.7/site-packages/pandas/plotting/_core.pyc\u001b[0m in \u001b[0;36mgenerate\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    241\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mgenerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    242\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_args_adjust\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 243\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_compute_plot_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    244\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setup_subplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    245\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_plot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/Users/aashna/anaconda2/lib/python2.7/site-packages/pandas/plotting/_core.pyc\u001b[0m in \u001b[0;36m_compute_plot_data\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    350\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mis_empty\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    351\u001b[0m             raise TypeError('Empty {0!r}: no numeric data to '\n\u001b[0;32m--> 352\u001b[0;31m                             'plot'.format(numeric_data.__class__.__name__))\n\u001b[0m\u001b[1;32m    353\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    354\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnumeric_data\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Empty 'DataFrame': no numeric data to plot"
     ]
    }
   ],
   "source": [
    "hist_activities(acc_gy_df)\n",
    "plot_act_signals(in_df_ac)\n",
    "\n",
    "combined_df = acc_gy_df\n",
    "combined_df = combined_df.iloc[np.random.permutation(len(combined_df))]\n",
    "combined_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'combined_df' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-8b5f648c7a93>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcombined_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0macc_columns\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mgy_columns\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mtargets\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mstd_scale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpreprocessing\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mStandardScaler\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'combined_df' is not defined"
     ]
    }
   ],
   "source": [
    "data = combined_df[acc_columns + gy_columns].as_matrix()\n",
    "targets = data[:, -1]\n",
    "data = data[:, :-1]\n",
    "\n",
    "std_scale = preprocessing.StandardScaler().fit(data)\n",
    "data_std = std_scale.transform(data)\n",
    "\n",
    "print(len(data_std), len(data_std[0]))\n",
    "print(len(targets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "cache = {'laying_down' : 0, 'sitting' : 1, 'walking' : 2, 'standing' : 3}\n",
    "targets.reshape(len(targets))\n",
    "print(targets)\n",
    "print(targets.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bin_targets = []\n",
    "for i in targets:\n",
    "    bin_targets.append(cache[i])\n",
    "print(len(bin_targets))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bin_targets[: 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "clf = DecisionTreeClassifier(random_state=0)\n",
    "        \n",
    "acc = cross_val_score(clf, data_std, bin_targets, cv=10)\n",
    "print acc\n",
    "print \"Score:\",np.mean(acc)*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}