Preprocessing-Data.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "uD4Wv4azQDIZ"
   },
   "outputs": [],
   "source": [
    "#################\n",
    "#### IMPORTS ####\n",
    "#################\n",
    "import json, urllib.request\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from pandas.io.json import json_normalize\n",
    "from pandas import concat\n",
    "from scipy import stats\n",
    "import datetime\n",
    "from scipy.ndimage import gaussian_filter\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "from ipywidgets import interact, fixed\n",
    "from scipy.signal import argrelmin, argrelmax, butter, lfilter, freqz\n",
    "from sklearn import preprocessing\n",
    "from sklearn.model_selection import train_test_split\n",
    "%matplotlib inline\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "bS1m-ZjYQDIk",
    "outputId": "3d56c7ba-3409-4310-cdc1-1724a50034eb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading ACC data from DB --> DONE\n",
      "Loading GYR data from DB --> DONE\n",
      "Loading MAG data from DB --> DONE\n",
      "Loading GPS data from DB --> DONE\n",
      "Loading Activity data from DB --> DONE\n",
      "   activity_id activity_list\n",
      "0            0         DUMMY\n",
      "1            1          Bike\n",
      "2            2           Car\n",
      "3            3       Jogging\n",
      "4            4         Metro\n",
      "5            5          Tram\n",
      "6            6         Train\n",
      "7            7       Walking\n"
     ]
    }
   ],
   "source": [
    "#######################\n",
    "#### LOAD DATASETS ####\n",
    "#######################\n",
    "\n",
    "API_URL = 'https://api.mlab.com/api/1/databases/prototype/collections/'\n",
    "API_KEY = 'XXX'\n",
    "\n",
    "with urllib.request.urlopen(API_URL + 'Accelerometer?apiKey='+ API_KEY) as url:\n",
    "    data_acc = json.loads(url.read().decode())\n",
    "print(\"Loading ACC data from DB --> DONE\")\n",
    "with urllib.request.urlopen(API_URL + 'Gyroscope?apiKey=' + API_KEY) as url:\n",
    "    data_gyr = json.loads(url.read().decode())\n",
    "print(\"Loading GYR data from DB --> DONE\")\n",
    "with urllib.request.urlopen(API_URL + 'Magnetometer?apiKey=' + API_KEY) as url:\n",
    "    data_mag = json.loads(url.read().decode())\n",
    "print(\"Loading MAG data from DB --> DONE\")\n",
    "with urllib.request.urlopen(API_URL + 'GPS?apiKey=' + API_KEY) as url:\n",
    "    data_gps = json.loads(url.read().decode())\n",
    "print(\"Loading GPS data from DB --> DONE\")\n",
    "with urllib.request.urlopen(API_URL + 'activities?apiKey=' + API_KEY) as url:\n",
    "    data_act = json.loads(url.read().decode())\n",
    "print(\"Loading Activity data from DB --> DONE\")\n",
    "\n",
    "def createBackup():\n",
    "    curDate = datetime.datetime.today().strftime('%Y-%m-%d')\n",
    "    backupFolder = 'backup/'\n",
    "    with open(backupFolder+curDate+'_acc.txt', 'w') as outfile:  \n",
    "        json.dump(data_acc, outfile)\n",
    "    with open(backupFolder+curDate+'_gyr.txt', 'w') as outfile:  \n",
    "        json.dump(data_gyr, outfile)\n",
    "    with open(backupFolder+curDate+'_mag.txt', 'w') as outfile:  \n",
    "        json.dump(data_mag, outfile)\n",
    "    with open(backupFolder+curDate+'_gps.txt', 'w') as outfile:  \n",
    "        json.dump(data_gps, outfile)\n",
    "    with open(backupFolder+curDate+'_act.txt', 'w') as outfile:  \n",
    "        json.dump(data_act, outfile)\n",
    "    \n",
    "\n",
    "#createBackup()\n",
    "act_id = [0, 1, 2, 3, 4, 5, 6, 7]\n",
    "act_list = ['DUMMY', 'Bike', 'Car', 'Jogging', 'Metro', 'Tram', 'Train', 'Walking']\n",
    "df_actList = pd.DataFrame({'activity_id':act_id, 'activity_list':act_list})\n",
    "print(df_actList)\n",
    "    \n",
    "df_acc = pd.DataFrame(data_acc)\n",
    "df_gyr = pd.DataFrame(data_gyr)\n",
    "df_mag = pd.DataFrame(data_mag)\n",
    "df_gps = pd.DataFrame(data_gps)\n",
    "\n",
    "# Basic info about activities (id, start, stop, activityType)\n",
    "# will get mapped with other sensor data at a later point\n",
    "df_actBasic = pd.DataFrame(data_act) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "KHMm0fptQDIu"
   },
   "outputs": [],
   "source": [
    "### FOR COSMETIC REASONS ###\n",
    "df_actBasic = df_actBasic.drop(['model', 'serialNumber', 'systemVersion'], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-KMvoAy9QDI2"
   },
   "outputs": [],
   "source": [
    "print(df_acc.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wkjG-1dWQDJB",
    "outputId": "ad4516fe-40d7-45a7-fdd7-3623752f5370"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alhirz/anaconda3/envs/analysis/lib/python3.6/site-packages/ipykernel_launcher.py:9: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  if __name__ == '__main__':\n"
     ]
    }
   ],
   "source": [
    "#########################\n",
    "#### Rename ID field ####\n",
    "#########################\n",
    "\n",
    "def renameIdField(newDataFrame):\n",
    "    for key, value in newDataFrame['_id'].iteritems():\n",
    "        value_new = value.get('$oid')\n",
    "        newDataFrame['_id'][key] = value_new\n",
    "    return newDataFrame\n",
    "\n",
    "df_acc = renameIdField(df_acc)\n",
    "df_gyr = renameIdField(df_gyr)\n",
    "df_mag = renameIdField(df_mag)\n",
    "df_gps = renameIdField(df_gps)\n",
    "df_actBasic = renameIdField(df_actBasic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QgekyWLAQDJT"
   },
   "outputs": [],
   "source": [
    "#######################\n",
    "#### SET temp VARs ####\n",
    "#######################\n",
    "\n",
    "\n",
    "# Defining temp arrays for filling with necessary data\n",
    "# temp vars for Acc, Gyro, Magn\n",
    "temp_x = []\n",
    "temp_y = []\n",
    "temp_z = []\n",
    "temp_ts = []\n",
    "\n",
    "\n",
    "# temp vars for gps data\n",
    "temp_accuracy = []\n",
    "temp_heading = []\n",
    "temp_lat = []\n",
    "temp_long = []\n",
    "temp_speed = []\n",
    "temp_timestamp = []\n",
    "\n",
    "# temp var for mapping sensor data to defined Activity\n",
    "temp_id = []\n",
    "dict_act_id = dict(df_actBasic[['_id','definedActivity']].values)\n",
    "dict_act_start = dict(df_actBasic[['_id','startTime']].values)\n",
    "dict_act_end = dict(df_actBasic[['_id','endTime']].values)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oiIiGO1mQDJa"
   },
   "outputs": [],
   "source": [
    "##############################################\n",
    "#### RESET temp data after each assigning ####\n",
    "##############################################\n",
    "\n",
    "def resetTempData():\n",
    "    global temp_id, temp_x, temp_y, temp_z, temp_ts\n",
    "    temp_id.clear(), temp_x.clear(), temp_y.clear(), temp_z.clear(), temp_ts.clear()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pnRxGTj6QDJh"
   },
   "outputs": [],
   "source": [
    "#####################################################\n",
    "#### EXTRACT from DF, SAVE it in temporary lists ####\n",
    "#####################################################\n",
    "\n",
    "def extractSensorData(dataFrame, isGpsData):\n",
    "    for key, value in dataFrame['data'].iteritems():\n",
    "        for idx, val in enumerate(value):\n",
    "            for s, x in val.items():\n",
    "                temp_id.append(dataFrame['_id'][key])\n",
    "                if not (isGpsData):\n",
    "                    temp_x.append(x.get('x'))\n",
    "                    temp_y.append(x.get('y'))\n",
    "                    temp_z.append(x.get('z'))\n",
    "                    temp_ts.append(x.get('timestamp'))\n",
    "\n",
    "                if (isGpsData):\n",
    "                    temp_lat.append(x.get('latitude'))\n",
    "                    temp_long.append(x.get('longitude'))\n",
    "                    temp_timestamp.append(x.get('timestamp'))\n",
    "                    temp_accuracy.append(x.get('accuracy'))\n",
    "                    temp_heading.append(x.get('heading'))\n",
    "                    temp_speed.append(x.get('speed'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "WAk1pfYfQDJm"
   },
   "outputs": [],
   "source": [
    "########################################\n",
    "#### ADD temp data to new DataFrame ####\n",
    "########################################\n",
    "\n",
    "def addToDf(newDataFrame, isGpsData):   \n",
    "    newDataFrame = pd.DataFrame(temp_id, columns=['activityId']) \n",
    "    if not (isGpsData):\n",
    "        newDataFrame['timestamp'] = pd.Series(temp_ts)\n",
    "        newDataFrame['x'] = pd.Series(temp_x)\n",
    "        newDataFrame['y'] = pd.Series(temp_y)\n",
    "        newDataFrame['z'] = pd.Series(temp_z)\n",
    "    if (isGpsData):\n",
    "        newDataFrame['lat'] = pd.Series(temp_lat)\n",
    "        newDataFrame['long'] = pd.Series(temp_long)\n",
    "        newDataFrame['timestamp'] = pd.Series(temp_timestamp)\n",
    "        newDataFrame['accuracy'] = pd.Series(temp_accuracy)\n",
    "        newDataFrame['heading'] = pd.Series(temp_heading)\n",
    "        newDataFrame['speed'] = pd.Series(temp_speed)\n",
    "           \n",
    "    newDataFrame['definedActivity'] = newDataFrame.activityId.replace(dict_act_id)\n",
    "    return newDataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XV1WPfXMQDJq",
    "outputId": "1d0a4177-87d1-43a2-9c2c-df5710e71083"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ACC done\n",
      "GYR done\n",
      "MAG done\n",
      "GPS done\n"
     ]
    }
   ],
   "source": [
    "#################################\n",
    "#### GENERATE new DataFrames ####\n",
    "#################################\n",
    "\n",
    "# Building Accelerometer Data\n",
    "extractSensorData(df_acc)\n",
    "df_acc_new = addToDf(df_acc, False).sort_values('timestamp')\n",
    "resetTempData()\n",
    "print('ACC done')\n",
    "\n",
    "# Building Gyroscope Data\n",
    "extractSensorData(df_gyr, False)\n",
    "df_gyr_new = addToDf(df_gyr, False).sort_values('timestamp')\n",
    "resetTempData()\n",
    "print('GYR done')\n",
    "\n",
    "# Building Magnetometer Data\n",
    "extractSensorData(df_mag, False)\n",
    "df_mag_new = addToDf(df_mag, False).sort_values('timestamp')\n",
    "resetTempData()\n",
    "print('MAG done')\n",
    "\n",
    "# Building GPS Data\n",
    "extractSensorData(df_gps, True)\n",
    "df_gps_new = addToDf(df_gps, True).sort_values('timestamp')\n",
    "resetTempData()\n",
    "print('GPS done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Yr0EC1WTQDJw",
    "outputId": "6bca968e-11c7-494d-882e-9c792f233772"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length  657990  |  633390  ->  24600\n",
      "Length  662671  |  638071  ->  24600\n",
      "Length  357616  |  333016  ->  24600\n",
      "Amount of activities:  82\n"
     ]
    }
   ],
   "source": [
    "#######################################################################\n",
    "###################### DROP 5s from Start & End #######################\n",
    "#######################################################################\n",
    "\n",
    "list_activities = df_acc_new['activityId'].unique()\n",
    "\n",
    "def cropStartEnd(df_toCrop):\n",
    "    df_cut = pd.DataFrame()\n",
    "    for activity in list_activities:\n",
    "        act_in_df = df_toCrop['activityId'] == activity\n",
    "        df_cur_act = df_toCrop[act_in_df]\n",
    "        \n",
    "        crop_start = df_cur_act.index[:150]\n",
    "        df_cur_act = df_cur_act.drop(crop_start)\n",
    "        \n",
    "        crop_end = df_cur_act.iloc[:-150]\n",
    "        df_cur_act = crop_end\n",
    "        \n",
    "        df_cut = df_cut.append(df_cur_act)\n",
    "    df_cut = df_cut.reset_index().drop('index', axis=1)\n",
    "    print(\"Length \", len(df_toCrop), \" | \", len(df_cut), \" -> \", int(len(df_toCrop)-len(df_cut)))\n",
    "    return df_cut\n",
    "    \n",
    "df_acc_cut = cropStartEnd(df_acc_new)\n",
    "df_gyr_cut = cropStartEnd(df_gyr_new)\n",
    "df_mag_cut = cropStartEnd(df_mag_new)\n",
    "\n",
    "print(\"Amount of activities: \",len(list_activities))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q6od00J7QDJz"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G-VgLip3QDJ3"
   },
   "outputs": [],
   "source": [
    "def overview_plot(activity):\n",
    "    if activity==0:\n",
    "        for c in range(1,8):\n",
    "            plt.plot(df_acc_new[df_acc_new['definedActivity'] == int(c)]['magnitude'])\n",
    "    else:\n",
    "        plt.plot(df_acc_new[df_acc_new['definedActivity'] == int(activity)]['magnitude'])\n",
    "    plt.title('magnitude of acc by activities')\n",
    "    plt.ticklabel_format(axis='definedActivities', scilimit=(0,0))\n",
    "    plt.legend(range(1,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6QZOoaIRQDJ7"
   },
   "outputs": [],
   "source": [
    "#columns_to_drop = ['timestamp', 'activityId','index']\n",
    "columns_to_drop = ['timestamp','index', 'definedActivity']\n",
    "\n",
    "\n",
    "def plotActivity(df, act):\n",
    "    act_in_df = df['activityId'] == act\n",
    "    df_cur_act = df[act_in_df]\n",
    "    df_cur_act = df_cur_act.reset_index().drop(columns_to_drop, axis=1)\n",
    "    df_cur_act.plot(subplots = True,\n",
    "                    figsize = (14,12)#,\n",
    "                    #ylim = (min(df['x']), max(df['x']))\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "rVaMDZQhQDKJ"
   },
   "outputs": [],
   "source": [
    "def butter_lowpass(cutoff, fs, order):\n",
    "    nyq = 0.5 * fs\n",
    "    normal_cutoff = cutoff / nyq\n",
    "    b, a = butter(order, normal_cutoff, btype='low', analog=False)\n",
    "    return b, a\n",
    "\n",
    "def butter_lowpass_filter(data, cutoff, fs, order=5):\n",
    "    b, a = butter_lowpass(cutoff, fs, order=order)\n",
    "    y = lfilter(b, a, data)\n",
    "    return y\n",
    "\n",
    "\n",
    "order = 6\n",
    "fs = 20\n",
    "cutoff = 1\n",
    "\n",
    "b, a = butter_lowpass(cutoff, fs, order)\n",
    "\n",
    "def denoiseSensor(sensorDataFrame,outputFile):\n",
    "    newDataFrame = sensorDataFrame\n",
    "    #newDataFrame = pd.DataFrame()\n",
    "    for q in ['x', 'y', 'z']:   \n",
    "        filter_data = sensorDataFrame[q]\n",
    "        \n",
    "        filter_test_x = range(len(filter_data))\n",
    "        filter_test_yL = butter_lowpass_filter(filter_data, cutoff, fs, order)\n",
    "        \n",
    "        f, (ax1, ax2) = plt.subplots(2, sharex=True, sharey=False, figsize=(12,12))\n",
    "        ax1.set_title('FFT Data transform: ' + q)\n",
    "        ax1.plot(filter_test_x, filter_data, label='Original data')\n",
    "        ax1.set_ylim([min(filter_data), max(filter_data)])\n",
    "        \n",
    "        ax2.plot(filter_test_x, filter_test_yL, label='Low Pass filter')\n",
    "        plt.savefig(\"plots/\"+outputFile+str(q)+\"_noise.png\")\n",
    "        ax2.set_ylim([min(filter_data), max(filter_data)])\n",
    "\n",
    "        plt.xlim(0, len(filter_data))\n",
    "        f.subplots_adjust(hspace=0.1)\n",
    "        \n",
    "        newDataFrame[q] = filter_test_yL\n",
    "\n",
    "    return newDataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9Uv4YeB9QDKO"
   },
   "outputs": [],
   "source": [
    "def testDenoise():\n",
    "    w, h = freqz(b, a, worN=8000)\n",
    "    plt.subplot(2, 1, 1)\n",
    "    plt.plot(0.5*fs*w/np.pi, np.abs(h), 'b')\n",
    "    plt.plot(cutoff, 0.5*np.sqrt(2), 'ko')\n",
    "    plt.axvline(cutoff, color='k')\n",
    "    plt.xlim(0, 2)\n",
    "    plt.title(\"Lowpass Filter Frequency Response\")\n",
    "    plt.xlabel('Frequency [Hz]')\n",
    "    plt.grid()\n",
    "    \n",
    "testDenoise()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pMc1yReEQDKc"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x864 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_acc_denoise = denoiseSensor(df_acc_cut, 'ACC_')\n",
    "df_gyr_denoise = df_gyr_cut\n",
    "df_mag_denoise = df_mag_cut"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xQuGqSZiQDKu"
   },
   "outputs": [],
   "source": [
    "def removeDuplicates(dfToCheck):\n",
    "    duplicates_removed = dfToCheck.reset_index().drop_duplicates(subset='timestamp', keep='last')\n",
    "    duplicated_removed = duplicates_removed.sort_values('timestamp')\n",
    "    return duplicates_removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "wDrRVZy6QDKw",
    "outputId": "836dba0e-207b-46c8-957d-d33d04dc1507"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "475829    1535574734633\n",
      "Name: timestamp, dtype: int64 488148    1535575227405\n",
      "Name: timestamp, dtype: int64\n",
      "1535574849877 1535575227454\n"
     ]
    }
   ],
   "source": [
    "############################################\n",
    "######## SHOW Start/End timestamp ##########\n",
    "############################################\n",
    "\n",
    "actId = '5b8703421f6e4f79c187170e'\n",
    "\n",
    "is_in_acc = df_acc_new['activityId'] == actId\n",
    "filter_acc = df_acc_new[is_in_acc].sort_values('timestamp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "329RdZtsQDK5"
   },
   "outputs": [],
   "source": [
    "####################################################\n",
    "####### SHOW DATA of specific activity ID  #########\n",
    "####################################################\n",
    "\n",
    "dataFrame = df_acc_cut\n",
    "activity = '5b738e905d0e657bff269e7c'\n",
    "\n",
    "df_act_in_sensor = dataFrame['activityId']==activity\n",
    "df_filtered = dataFrame[df_act_in_sensor]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "UNlxCoL1QDK7"
   },
   "outputs": [],
   "source": [
    "###############################\n",
    "##### CALCULATE magnitude #####\n",
    "###############################\n",
    "\n",
    "def calcMagnitude(df):\n",
    "    x2 = df['x']**2\n",
    "    y2 = df['y']**2\n",
    "    z2 = df['z']**2\n",
    "    m2 = x2 + y2 + z2\n",
    "    df['magnitude']=m2.apply(lambda x: np.sqrt(x))\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8OZxJZblQDLA"
   },
   "outputs": [],
   "source": [
    "df_acc_denoise = calcMagnitude(df_acc_denoise)\n",
    "df_gyr_denoise = calcMagnitude(df_gyr_denoise)\n",
    "df_mag_denoise = calcMagnitude(df_mag_denoise)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "h_-xTOzlQDLG"
   },
   "outputs": [],
   "source": [
    "df_gyr_denoise.head(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  activityId      timestamp     heading      speed  \\\n",
      "0   5b65588f1f6e4f7b6b2accf5  1533368466000  211.399994  37.119999   \n",
      "1   5b65588f1f6e4f7b6b2accf5  1533368467000  210.899994  37.220001   \n",
      "2   5b65588f1f6e4f7b6b2accf5  1533368468000  210.500000  37.529999   \n",
      "3   5b65588f1f6e4f7b6b2accf5  1533368469000  210.199997  37.740002   \n",
      "42  5b66e3811f6e4f7b6b31435d  1533469570082  273.899994  11.130000   \n",
      "43  5b66e3811f6e4f7b6b31435d  1533469572000  278.700012  11.310000   \n",
      "44  5b66e3811f6e4f7b6b31435d  1533469573000  267.100006  11.190000   \n",
      "45  5b66e3811f6e4f7b6b31435d  1533469574000  264.200012  11.030000   \n",
      "46  5b66e3811f6e4f7b6b31435d  1533469576000  252.000000  11.000000   \n",
      "47  5b66e3811f6e4f7b6b31435d  1533469577000  246.699997  11.200000   \n",
      "\n",
      "    definedActivity  \n",
      "0                 2  \n",
      "1                 2  \n",
      "2                 2  \n",
      "3                 2  \n",
      "42                2  \n",
      "43                2  \n",
      "44                2  \n",
      "45                2  \n",
      "46                2  \n",
      "47                2  \n"
     ]
    }
   ],
   "source": [
    "##########################################\n",
    "############## GPS Handling ##############\n",
    "##########################################\n",
    "\n",
    "df_gps_new = df_gps_new.drop(['lat', 'long', 'accuracy'], axis=1)\n",
    "\n",
    "print(df_gps_new.head(10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "HGlB54lLQDLJ"
   },
   "outputs": [],
   "source": [
    "################################\n",
    "#### RESAMPLE & INTERPOLATE #### \n",
    "################################\n",
    "\n",
    "def resampleData(dataFrame, isGPS, sensorType):\n",
    "    if isGPS:\n",
    "        sampleRate='5000L'\n",
    "    else: sampleRate = '50L'\n",
    "    \n",
    "    debug = False\n",
    "    list_activities = dataFrame['activityId'].unique()\n",
    "    dataFrame_to_resample = pd.DataFrame()\n",
    "    \n",
    "    for activity in list_activities:\n",
    "        df_act_in_sensor = dataFrame['activityId']==activity\n",
    "        df_filtered = dataFrame[df_act_in_sensor]\n",
    "        \n",
    "        ## set start/end time from main activity (df_actBasic)\n",
    "        ## necessary for consistency and further calculation\n",
    "        df_filtered.head(1).timestamp = dict_act_start[activity]\n",
    "        df_filtered.tail(1).timestamp = dict_act_end[activity]\n",
    "        \n",
    "        df_filtered = removeDuplicates(df_filtered)\n",
    "        \n",
    "        ## convert timestamp to DateTime and set it as an index\n",
    "        df_filtered['timestamp'] = pd.to_datetime(df_filtered['timestamp'], unit='ms')\n",
    "        df_filtered = df_filtered.set_index(['timestamp'])\n",
    "        \n",
    "        ## resample the data to 50ms/10s\n",
    "        dataFrame_resampled = df_filtered\\\n",
    "            .select_dtypes(include=['float64', 'int64'])\\\n",
    "            .resample(sampleRate)\\\n",
    "            .bfill()\\\n",
    "            .interpolate(method='linear')\n",
    "        dataFrame_to_resample = dataFrame_to_resample.append(dataFrame_resampled)\n",
    "        \n",
    "        if (debug):\n",
    "            ##### KEEP FOR DEBUGGING PURPOSES #####\n",
    "            #print(df_acc_resampled.plot(title = activity, figsize=(12,12)))\n",
    "            #print(dataFrame_to_resample.head(1).index.values)\n",
    "            #print(dataFrame_to_resample.tail(1).index.values)\n",
    "            print(activity, \" --> \",len(df_filtered), \"|\", len(dataFrame_resampled))\n",
    "            #print(\"_________________________\")\n",
    "            ########################################\n",
    "      \n",
    "    print(len(dataFrame), \" | \", len(dataFrame_to_resample), \" (\",(len(dataFrame_to_resample)-len(dataFrame)),\")\")\n",
    "    dataFrame_to_resample.to_csv('datasets/'+sensorType+'_resampled.csv', sep='\\t', encoding='utf-8')\n",
    "    return dataFrame_to_resample"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "64W4XBdtQDLS",
    "outputId": "089482b9-5351-4b4e-ff37-5305c04df0ab"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/alhirz/anaconda3/envs/analysis/lib/python3.6/site-packages/pandas/core/generic.py:4405: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  self[name] = value\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1518  |  5863  ( 4345 )\n"
     ]
    }
   ],
   "source": [
    "#df_acc_resampled = resampleData(df_acc_denoise, False, 'Accelerometer')\n",
    "#df_gyr_resampled = resampleData(df_gyr_denoise, False, 'Gyroscope')\n",
    "#df_mag_resampled = resampleData(df_mag_denoise, False, 'Magnetometer')\n",
    "\n",
    "df_gps_resampled = resampleData(df_gps_new, True, 'GPS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "vEH1_m_5QDLe"
   },
   "outputs": [],
   "source": [
    "#df_acc_resampled = df_acc_resampled.drop('index', axis=1)\n",
    "#df_gyr_resampled = df_gyr_resampled.drop('index', axis=1)\n",
    "#df_mag_resampled = df_mag_resampled.drop('index', axis=1)\n",
    "df_gps_resampled = df_gps_resampled.drop('index', axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OBzpYon-QDLk"
   },
   "outputs": [],
   "source": [
    "df_acc_resampled.definedActivity = df_acc_resampled.definedActivity.astype(int)\n",
    "df_gyr_resampled.definedActivity = df_gyr_resampled.definedActivity.astype(int)\n",
    "df_mag_resampled.definedActivity = df_mag_resampled.definedActivity.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "t5nkiUtTQDLs"
   },
   "outputs": [],
   "source": [
    "#############################\n",
    "#### FEATURE ENGINEERING ####\n",
    "#############################\n",
    "\n",
    "\n",
    "def slidingWindow(data, window_size, step_size):\n",
    "    segments = []\n",
    "    labels = []\n",
    "    for i in range(0, len(data) - window_size, step_size):\n",
    "        x_s = data['x'].values[i: i + window_size]\n",
    "        y_s = data['y'].values[i: i + window_size]\n",
    "        z_s = data['z'].values[i: i + window_size]\n",
    "        m_s = data['magnitude'].values[i: i + window_size]\n",
    "        label = stats.mode(data['definedActivity'][i: i + window_size])[0][0]\n",
    "        segments.append([x_s, y_s, z_s, m_s, label])\n",
    "    return segments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "BNu_gs9QQDLv"
   },
   "outputs": [],
   "source": [
    "################################\n",
    "####### REORDER COLUMNS# #######\n",
    "################################\n",
    "\n",
    "df_acc_resampled = df_acc_resampled[['x','y','z','magnitude','definedActivity']]\n",
    "df_gyr_resampled = df_gyr_resampled[['x','y','z','magnitude','definedActivity']]\n",
    "df_mag_resampled = df_mag_resampled[['x','y','z','magnitude','definedActivity']]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e6qKHpAKQDLz",
    "outputId": "87238925-ad8e-43e1-c3d0-847904149b98"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['acc_x', 'acc_y', 'acc_z', 'acc_m', 'gyr_x', 'gyr_y', 'gyr_z', 'gyr_m',\n",
      "       'mag_x', 'mag_y', 'mag_z', 'mag_m', 'activity'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "##########################################\n",
    "##### PREPARE DATA FOR DEEP LEARNING #####\n",
    "##########################################\n",
    "\n",
    "df_deep = pd.concat([df_acc_resampled, df_gyr_resampled, df_mag_resampled], axis=1)\n",
    "\n",
    "df_deep.columns = ['acc_x', 'acc_y', 'acc_z', 'acc_m', 'acc_Act', \n",
    "                  'gyr_x', 'gyr_y', 'gyr_z', 'gyr_m', 'gyr_Act', \n",
    "                  'mag_x', 'mag_y', 'mag_z', 'mag_m', 'activity']\n",
    "df_deep = df_deep.drop(['acc_Act', 'gyr_Act'], axis=1)\n",
    "\n",
    "print(df_deep.columns)\n",
    "\n",
    "df_deep.to_csv('datasets/deep/dataset_resampled.csv', sep='\\t', decimal=',', encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-ovgGlqHQDL5",
    "outputId": "e8b4f05e-9d15-4fd9-d7df-5d2da8a79c11"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "589724\n",
      "589724\n",
      "589724\n",
      "------\n",
      "29485\n",
      "29485\n",
      "29485\n"
     ]
    }
   ],
   "source": [
    "##########################################\n",
    "####### generating SLIDING WINDOWs #######\n",
    "##########################################\n",
    "\n",
    "\n",
    "df_acc_metrics = df_acc_resampled\n",
    "df_gyr_metrics = df_gyr_resampled\n",
    "df_mag_metrics = df_mag_resampled\n",
    "\n",
    "\n",
    "print(len(df_acc_metrics))\n",
    "print(len(df_gyr_metrics))\n",
    "print(len(df_mag_metrics))\n",
    "\n",
    "win_acc = slidingWindow(df_acc_resampled, 40, 20)\n",
    "win_gyr = slidingWindow(df_gyr_resampled, 40, 20)\n",
    "win_mag = slidingWindow(df_mag_resampled, 40, 20)\n",
    "\n",
    "df_window_acc = pd.DataFrame(win_acc, columns=['x','y','z','magnitude', 'activityType'])\n",
    "df_window_gyr = pd.DataFrame(win_gyr, columns=['x','y','z','magnitude', 'activityType'])\n",
    "df_window_mag = pd.DataFrame(win_mag, columns=['x','y','z','magnitude', 'activityType'])\n",
    "\n",
    "print(\"------\")\n",
    "print(len(df_window_acc))\n",
    "print(len(df_window_gyr))\n",
    "print(len(df_window_mag))\n",
    "\n",
    "df_window_acc_y = df_window_acc['activityType']\n",
    "df_window_gyr_y = df_window_gyr['activityType']\n",
    "df_window_mag_y = df_window_mag['activityType']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jKRo_7QoQDL9"
   },
   "outputs": [],
   "source": [
    "list_sensors = ['acc', 'gyr', 'mag']\n",
    "list_xyz = ['x', 'y', 'z', 'magnitude']\n",
    "list_agg = ['min', 'max', 'mean','std','var']\n",
    "\n",
    "acc_feature = []\n",
    "gyr_feature = []\n",
    "mag_feature = []\n",
    "\n",
    "list_fts_sensor = []\n",
    "list_fts_all = []\n",
    "\n",
    "\n",
    "for b in list_xyz:\n",
    "    for c in list_agg:\n",
    "        list_fts_sensor.append(b +\"_\" + c)\n",
    "\n",
    "for a in list_sensors:\n",
    "    for b in list_xyz:\n",
    "        for c in list_agg:\n",
    "            list_fts_all.append(a + \"_\"+ b +\"_\" + c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "H7sWALthQDL-"
   },
   "outputs": [],
   "source": [
    "def generateFeatures(dataFrame, sensor_feature):\n",
    "    for row in dataFrame.itertuples():\n",
    "        sensor_feature.append([\n",
    "            row.x.min(),row.x.max(),row.x.mean(), row.x.std(), row.x.var(),\n",
    "            row.y.min(),row.y.max(),row.y.mean(), row.y.std(), row.y.var(),\n",
    "            row.z.min(),row.z.max(),row.z.mean(), row.z.std(), row.z.var(),\n",
    "            row.magnitude.min(),row.magnitude.max(),row.magnitude.mean(), row.magnitude.std(),row.magnitude.var()\n",
    "            ])    \n",
    "    return dataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CgeJBRRDQDMC"
   },
   "outputs": [],
   "source": [
    "#########################################\n",
    "########## FEATURE ENGINEERING ##########\n",
    "#########################################\n",
    "\n",
    "generateFeatures(df_window_acc, acc_feature)\n",
    "generateFeatures(df_window_gyr, gyr_feature)\n",
    "generateFeatures(df_window_mag, mag_feature)\n",
    "\n",
    "df_window_acc_ft = pd.DataFrame.from_records(acc_feature, columns=list_fts_sensor)\n",
    "df_window_gyr_ft = pd.DataFrame.from_records(gyr_feature, columns=list_fts_sensor)\n",
    "df_window_mag_ft = pd.DataFrame.from_records(mag_feature, columns=list_fts_sensor)\n",
    "\n",
    "df_window_all = pd.concat([df_window_acc_ft, df_window_gyr_ft, df_window_mag_ft], axis=1)\n",
    "df_window_all.columns = list_fts_all\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "MW-0EXi_QDMF",
    "outputId": "5269cd89-bdd9-4a78-acb1-c80617e72114"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0        2\n",
      "1        2\n",
      "2        2\n",
      "3        2\n",
      "4        2\n",
      "5        2\n",
      "6        2\n",
      "7        2\n",
      "8        2\n",
      "9        2\n",
      "10       2\n",
      "11       2\n",
      "12       2\n",
      "13       2\n",
      "14       2\n",
      "15       2\n",
      "16       2\n",
      "17       2\n",
      "18       2\n",
      "19       2\n",
      "20       2\n",
      "21       2\n",
      "22       2\n",
      "23       2\n",
      "24       2\n",
      "25       2\n",
      "26       2\n",
      "27       2\n",
      "28       2\n",
      "29       2\n",
      "        ..\n",
      "29455    7\n",
      "29456    7\n",
      "29457    7\n",
      "29458    7\n",
      "29459    7\n",
      "29460    7\n",
      "29461    7\n",
      "29462    7\n",
      "29463    7\n",
      "29464    7\n",
      "29465    7\n",
      "29466    7\n",
      "29467    7\n",
      "29468    7\n",
      "29469    7\n",
      "29470    7\n",
      "29471    7\n",
      "29472    7\n",
      "29473    7\n",
      "29474    7\n",
      "29475    7\n",
      "29476    7\n",
      "29477    7\n",
      "29478    7\n",
      "29479    7\n",
      "29480    7\n",
      "29481    7\n",
      "29482    7\n",
      "29483    7\n",
      "29484    7\n",
      "Name: activityType, Length: 29485, dtype: int64\n",
      "60 7\n"
     ]
    }
   ],
   "source": [
    "########################################\n",
    "########### NORMALIZING data ###########\n",
    "########################################\n",
    "\n",
    "min_max_scaler = preprocessing.MinMaxScaler()\n",
    "np_scaled = min_max_scaler.fit_transform(df_window_all)\n",
    "df_X_normalized = pd.DataFrame(np_scaled)\n",
    "df_X_normalized = pd.get_dummies(df_X_normalized)\n",
    "\n",
    "parameters1 = len(df_X_normalized.columns)\n",
    "\n",
    "print(df_window_acc_y)\n",
    "print(parameters1, parameters2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jNQeITRbQDMM",
    "outputId": "c568de6f-52c5-48e3-cbdd-525e93a195a9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['acc_x_min', 'acc_x_max', 'acc_x_mean', 'acc_x_std', 'acc_x_var',\n",
      "       'acc_y_min', 'acc_y_max', 'acc_y_mean', 'acc_y_std', 'acc_y_var',\n",
      "       'acc_z_min', 'acc_z_max', 'acc_z_mean', 'acc_z_std', 'acc_z_var',\n",
      "       'acc_magnitude_min', 'acc_magnitude_max', 'acc_magnitude_mean',\n",
      "       'acc_magnitude_std', 'acc_magnitude_var', 'gyr_x_min', 'gyr_x_max',\n",
      "       'gyr_x_mean', 'gyr_x_std', 'gyr_x_var', 'gyr_y_min', 'gyr_y_max',\n",
      "       'gyr_y_mean', 'gyr_y_std', 'gyr_y_var', 'gyr_z_min', 'gyr_z_max',\n",
      "       'gyr_z_mean', 'gyr_z_std', 'gyr_z_var', 'gyr_magnitude_min',\n",
      "       'gyr_magnitude_max', 'gyr_magnitude_mean', 'gyr_magnitude_std',\n",
      "       'gyr_magnitude_var', 'mag_x_min', 'mag_x_max', 'mag_x_mean',\n",
      "       'mag_x_std', 'mag_x_var', 'mag_y_min', 'mag_y_max', 'mag_y_mean',\n",
      "       'mag_y_std', 'mag_y_var', 'mag_z_min', 'mag_z_max', 'mag_z_mean',\n",
      "       'mag_z_std', 'mag_z_var', 'mag_magnitude_min', 'mag_magnitude_max',\n",
      "       'mag_magnitude_mean', 'mag_magnitude_std', 'mag_magnitude_var'],\n",
      "      dtype='object')\n",
      "Index(['activityType'], dtype='object')\n"
     ]
    }
   ],
   "source": [
    "#######################################\n",
    "######### SETTING THE COLUMNS #########\n",
    "#######################################\n",
    "\n",
    "df_X_normalized.columns = list_fts_all\n",
    "df_y = pd.DataFrame(df_window_acc_y)\n",
    "df_X = df_X_normalized\n",
    "print(df_X.columns)\n",
    "print(df_y.columns)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3H0izdQZQDMR",
    "outputId": "48d21201-c84e-4cd3-fb31-c52231b95cbe"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29485\n",
      "29485\n"
     ]
    }
   ],
   "source": [
    "#######################################\n",
    "######### EXPORTING main data #########\n",
    "#######################################\n",
    "\n",
    "\n",
    "print(len(df_X))\n",
    "print(len(df_y))\n",
    "\n",
    "df_X.to_csv('datasets/X.csv', sep='\\t', decimal=',', encoding='utf-8')\n",
    "df_y.to_csv('datasets/y.csv', sep='\\t', encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "oFrtNlnCQDMU",
    "outputId": "12f13e0b-906b-45a8-c461-50732a96b731"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29485\n"
     ]
    }
   ],
   "source": [
    "#print(df_X_normalized.head(1))\n",
    "print(len(df_X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "8HFGBQEpQDMX",
    "outputId": "c77cb183-47b9-44a0-bef0-e7e872874599"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23588\n",
      "5897\n"
     ]
    }
   ],
   "source": [
    "######################################\n",
    "######### SPLITTING the data #########\n",
    "######################################\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(df_X, df_y, test_size=0.2, random_state=42)\n",
    "\n",
    "X_train.to_csv('datasets/X_train.csv', sep='\\t', decimal=',', encoding='utf-8')\n",
    "X_test.to_csv('datasets/X_test.csv', sep='\\t', decimal=',', encoding='utf-8')\n",
    "y_train.to_csv('datasets/y_train.csv', sep='\\t', encoding='utf-8')\n",
    "y_test.to_csv('datasets/y_test.csv', sep='\\t', encoding='utf-8')\n",
    "\n",
    "print(len(X_train))\n",
    "print(len(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tdznAEhrQDMa",
    "outputId": "19aa4be9-b924-4236-d768-68b15de7f502"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                    acc_x_min  acc_x_max  acc_x_mean  acc_x_std  acc_x_var  \\\n",
      "acc_x_min            1.000000  -0.300312    0.308473  -0.687721  -0.623398   \n",
      "acc_x_max           -0.300312   1.000000    0.760530   0.861929   0.749529   \n",
      "acc_x_mean           0.308473   0.760530    1.000000   0.427294   0.378086   \n",
      "acc_x_std           -0.687721   0.861929    0.427294   1.000000   0.935804   \n",
      "acc_x_var           -0.623398   0.749529    0.378086   0.935804   1.000000   \n",
      "acc_y_min            0.337607  -0.646795   -0.383480  -0.542794  -0.313959   \n",
      "acc_y_max           -0.435500   0.440824    0.209966   0.624594   0.685411   \n",
      "acc_y_mean           0.006614  -0.227455   -0.154346  -0.048353   0.157534   \n",
      "acc_y_std           -0.617595   0.879664    0.490477   0.954231   0.835386   \n",
      "acc_y_var           -0.593486   0.835000    0.479691   0.945249   0.899491   \n",
      "acc_z_min            0.566781  -0.803598   -0.427208  -0.818172  -0.649632   \n",
      "acc_z_max           -0.217489   0.639182    0.465929   0.493036   0.300515   \n",
      "acc_z_mean           0.548505  -0.695821   -0.330950  -0.746488  -0.610674   \n",
      "acc_z_std           -0.477580   0.844039    0.512929   0.790598   0.588695   \n",
      "acc_z_var           -0.398446   0.772271    0.478992   0.686818   0.494267   \n",
      "acc_magnitude_min    0.590269  -0.755715   -0.345740  -0.798980  -0.596820   \n",
      "acc_magnitude_max   -0.534926   0.877656    0.495952   0.848806   0.670283   \n",
      "acc_magnitude_mean  -0.396281   0.697686    0.445255   0.706407   0.638108   \n",
      "acc_magnitude_std   -0.606948   0.882137    0.472513   0.913694   0.741752   \n",
      "acc_magnitude_var   -0.565325   0.882819    0.494230   0.899155   0.758690   \n",
      "gyr_x_min            0.316085  -0.715354   -0.438155  -0.590773  -0.358867   \n",
      "gyr_x_max           -0.448230   0.756477    0.422983   0.697591   0.481113   \n",
      "gyr_x_mean          -0.108314   0.086827    0.032715   0.147489   0.183688   \n",
      "gyr_x_std           -0.387315   0.731113    0.415803   0.636549   0.398967   \n",
      "gyr_x_var           -0.258981   0.672026    0.420197   0.519201   0.287277   \n",
      "gyr_y_min            0.592770  -0.785517   -0.425870  -0.916573  -0.896304   \n",
      "gyr_y_max           -0.594010   0.822519    0.426840   0.876440   0.747868   \n",
      "gyr_y_mean          -0.013388   0.019689    0.005730   0.018428   0.012407   \n",
      "gyr_y_std           -0.620951   0.829257    0.443433   0.943099   0.877873   \n",
      "gyr_y_var           -0.549427   0.720867    0.402566   0.875158   0.918661   \n",
      "gyr_z_min            0.627285  -0.721369   -0.354252  -0.896745  -0.883552   \n",
      "gyr_z_max           -0.665199   0.730142    0.324720   0.902734   0.858836   \n",
      "gyr_z_mean          -0.059204   0.119806    0.079834   0.098846   0.064045   \n",
      "gyr_z_std           -0.679062   0.725376    0.313381   0.913606   0.875104   \n",
      "gyr_z_var           -0.569577   0.562642    0.244887   0.786318   0.868329   \n",
      "gyr_magnitude_min   -0.316937   0.558556    0.353668   0.566051   0.497294   \n",
      "gyr_magnitude_max   -0.599438   0.848519    0.468567   0.939305   0.865410   \n",
      "gyr_magnitude_mean  -0.578824   0.843484    0.459426   0.899689   0.775505   \n",
      "gyr_magnitude_std   -0.613710   0.831085    0.440955   0.936130   0.856745   \n",
      "gyr_magnitude_var   -0.542807   0.733347    0.408831   0.874667   0.905005   \n",
      "mag_x_min            0.250749  -0.186969   -0.011978  -0.249967  -0.225659   \n",
      "mag_x_max            0.198725  -0.146603   -0.002007  -0.192440  -0.171645   \n",
      "mag_x_mean           0.225811  -0.168978   -0.008547  -0.223122  -0.200530   \n",
      "mag_x_std           -0.264385   0.205414    0.049421   0.296663   0.283061   \n",
      "mag_x_var           -0.036573   0.005902   -0.012083   0.033249   0.039217   \n",
      "mag_y_min            0.274030  -0.016701    0.160220  -0.164475  -0.194458   \n",
      "mag_y_max            0.247403   0.007592    0.165293  -0.135419  -0.175915   \n",
      "mag_y_mean           0.260871  -0.003989    0.162971  -0.149985  -0.186173   \n",
      "mag_y_std           -0.199964   0.193564    0.045580   0.230483   0.150024   \n",
      "mag_y_var           -0.003648   0.007265    0.005398   0.015544   0.008506   \n",
      "mag_z_min            0.260928  -0.156333    0.025132  -0.233268  -0.197624   \n",
      "mag_z_max            0.172626  -0.031365    0.083852  -0.116035  -0.126480   \n",
      "mag_z_mean           0.220335  -0.102820    0.049373  -0.180430  -0.163196   \n",
      "mag_z_std           -0.278981   0.387228    0.176392   0.367738   0.224847   \n",
      "mag_z_var           -0.065295   0.079085    0.026472   0.076716   0.038394   \n",
      "mag_magnitude_min    0.289833  -0.073629    0.133018  -0.181099  -0.154278   \n",
      "mag_magnitude_max    0.288555  -0.084633    0.121893  -0.188716  -0.161526   \n",
      "mag_magnitude_mean   0.289644  -0.079137    0.127778  -0.185009  -0.157860   \n",
      "mag_magnitude_std    0.005234  -0.068688   -0.060060  -0.050557  -0.048251   \n",
      "mag_magnitude_var    0.009554  -0.019174   -0.010913  -0.009740  -0.008598   \n",
      "\n",
      "                    acc_y_min  acc_y_max  acc_y_mean  acc_y_std  acc_y_var  \\\n",
      "acc_x_min            0.337607  -0.435500    0.006614  -0.617595  -0.593486   \n",
      "acc_x_max           -0.646795   0.440824   -0.227455   0.879664   0.835000   \n",
      "acc_x_mean          -0.383480   0.209966   -0.154346   0.490477   0.479691   \n",
      "acc_x_std           -0.542794   0.624594   -0.048353   0.954231   0.945249   \n",
      "acc_x_var           -0.313959   0.685411    0.157534   0.835386   0.899491   \n",
      "acc_y_min            1.000000   0.221752    0.844243  -0.651894  -0.499296   \n",
      "acc_y_max            0.221752   1.000000    0.695394   0.571216   0.658305   \n",
      "acc_y_mean           0.844243   0.695394    1.000000  -0.161169   0.000634   \n",
      "acc_y_std           -0.651894   0.571216   -0.161169   1.000000   0.966470   \n",
      "acc_y_var           -0.499296   0.658305    0.000634   0.966470   1.000000   \n",
      "acc_z_min            0.753708  -0.342798    0.364922  -0.876819  -0.791511   \n",
      "acc_z_max           -0.638748   0.146662   -0.391975   0.602606   0.484730   \n",
      "acc_z_mean           0.675093  -0.285626    0.331618  -0.784733  -0.724889   \n",
      "acc_z_std           -0.803151   0.305024   -0.423792   0.881725   0.772473   \n",
      "acc_z_var           -0.787190   0.199430   -0.474000   0.792216   0.690257   \n",
      "acc_magnitude_min    0.685920  -0.396629    0.288029  -0.848901  -0.733192   \n",
      "acc_magnitude_max   -0.782186   0.358682   -0.373991   0.909519   0.817885   \n",
      "acc_magnitude_mean  -0.575731   0.291808   -0.260314   0.729732   0.712719   \n",
      "acc_magnitude_std   -0.742875   0.456942   -0.292803   0.967434   0.889511   \n",
      "acc_magnitude_var   -0.708603   0.456408   -0.268043   0.954539   0.907700   \n",
      "gyr_x_min            0.805018  -0.088599    0.547113  -0.704981  -0.558309   \n",
      "gyr_x_max           -0.834151   0.171027   -0.521329   0.797627   0.660499   \n",
      "gyr_x_mean           0.046690   0.191517    0.138652   0.119504   0.151162   \n",
      "gyr_x_std           -0.847129   0.100397   -0.573034   0.750669   0.596242   \n",
      "gyr_x_var           -0.819049  -0.006251   -0.613599   0.647801   0.498432   \n",
      "gyr_y_min            0.406978  -0.669513   -0.076187  -0.884303  -0.909956   \n",
      "gyr_y_max           -0.675807   0.437954   -0.252607   0.903243   0.845587   \n",
      "gyr_y_mean          -0.037118  -0.016123   -0.033302   0.015733   0.007827   \n",
      "gyr_y_std           -0.528040   0.612355   -0.045373   0.935256   0.930355   \n",
      "gyr_y_var           -0.294495   0.680464    0.167538   0.815806   0.880847   \n",
      "gyr_z_min            0.369781  -0.663550   -0.099179  -0.851866  -0.881942   \n",
      "gyr_z_max           -0.424248   0.635148    0.040581   0.859452   0.861263   \n",
      "gyr_z_mean          -0.125998   0.027348   -0.073998   0.117368   0.096847   \n",
      "gyr_z_std           -0.418978   0.640472    0.047347   0.865875   0.871020   \n",
      "gyr_z_var           -0.161636   0.658462    0.250755   0.685488   0.757519   \n",
      "gyr_magnitude_min   -0.485569   0.218435   -0.232629   0.587350   0.561697   \n",
      "gyr_magnitude_max   -0.568990   0.574312   -0.095143   0.937815   0.922840   \n",
      "gyr_magnitude_mean  -0.675899   0.458579   -0.241925   0.927290   0.872132   \n",
      "gyr_magnitude_std   -0.557472   0.582465   -0.083334   0.933499   0.910857   \n",
      "gyr_magnitude_var   -0.334655   0.646825    0.119354   0.820480   0.867770   \n",
      "mag_x_min            0.247228  -0.063483    0.142149  -0.272849  -0.270518   \n",
      "mag_x_max            0.228436  -0.012862    0.156110  -0.217399  -0.214882   \n",
      "mag_x_mean           0.239066  -0.039520    0.149273  -0.247162  -0.244827   \n",
      "mag_x_std           -0.101748   0.250176    0.062721   0.286770   0.289799   \n",
      "mag_x_var            0.015670   0.043998    0.036180   0.028309   0.030669   \n",
      "mag_y_min           -0.016924  -0.190250   -0.117355  -0.150143  -0.183341   \n",
      "mag_y_max           -0.045581  -0.179362   -0.133135  -0.118974  -0.160336   \n",
      "mag_y_mean          -0.033741  -0.186669   -0.128388  -0.134061  -0.172150   \n",
      "mag_y_std           -0.228659   0.081821   -0.128473   0.250046   0.186388   \n",
      "mag_y_var           -0.011262   0.006803   -0.005026   0.021875   0.011372   \n",
      "mag_z_min            0.244301  -0.042796    0.152518  -0.249836  -0.229284   \n",
      "mag_z_max            0.093178  -0.018192    0.053677  -0.112279  -0.120143   \n",
      "mag_z_mean           0.183839  -0.026394    0.116304  -0.190031  -0.180828   \n",
      "mag_z_std           -0.481260   0.067005   -0.320615   0.433829   0.344511   \n",
      "mag_z_var           -0.120521  -0.000505   -0.090643   0.098181   0.072720   \n",
      "mag_magnitude_min    0.184111  -0.040790    0.111717  -0.196331  -0.187659   \n",
      "mag_magnitude_max    0.192760  -0.041135    0.117830  -0.203790  -0.194900   \n",
      "mag_magnitude_mean   0.188623  -0.040975    0.114888  -0.200177  -0.191337   \n",
      "mag_magnitude_std    0.057208  -0.002954    0.040275  -0.047442  -0.047462   \n",
      "mag_magnitude_var    0.016011  -0.003129    0.010208  -0.008633  -0.012561   \n",
      "\n",
      "                          ...          mag_z_min  mag_z_max  mag_z_mean  \\\n",
      "acc_x_min                 ...           0.260928   0.172626    0.220335   \n",
      "acc_x_max                 ...          -0.156333  -0.031365   -0.102820   \n",
      "acc_x_mean                ...           0.025132   0.083852    0.049373   \n",
      "acc_x_std                 ...          -0.233268  -0.116035   -0.180430   \n",
      "acc_x_var                 ...          -0.197624  -0.126480   -0.163196   \n",
      "acc_y_min                 ...           0.244301   0.093178    0.183839   \n",
      "acc_y_max                 ...          -0.042796  -0.018192   -0.026394   \n",
      "acc_y_mean                ...           0.152518   0.053677    0.116304   \n",
      "acc_y_std                 ...          -0.249836  -0.112279   -0.190031   \n",
      "acc_y_var                 ...          -0.229284  -0.120143   -0.180828   \n",
      "acc_z_min                 ...           0.218056   0.062331    0.151427   \n",
      "acc_z_max                 ...          -0.149254  -0.013397   -0.094895   \n",
      "acc_z_mean                ...           0.205496   0.070216    0.147771   \n",
      "acc_z_std                 ...          -0.219496  -0.049030   -0.148381   \n",
      "acc_z_var                 ...          -0.209487  -0.041214   -0.140538   \n",
      "acc_magnitude_min         ...           0.227381   0.083563    0.166126   \n",
      "acc_magnitude_max         ...          -0.240157  -0.082855   -0.174163   \n",
      "acc_magnitude_mean        ...          -0.201785  -0.088534   -0.153026   \n",
      "acc_magnitude_std         ...          -0.253429  -0.100141   -0.188303   \n",
      "acc_magnitude_var         ...          -0.248241  -0.102434   -0.186819   \n",
      "gyr_x_min                 ...           0.235464   0.067960    0.167446   \n",
      "gyr_x_max                 ...          -0.264027  -0.091535   -0.192907   \n",
      "gyr_x_mean                ...          -0.029092  -0.023921   -0.025695   \n",
      "gyr_x_std                 ...          -0.259729  -0.084823   -0.188292   \n",
      "gyr_x_var                 ...          -0.222431  -0.052447   -0.154095   \n",
      "gyr_y_min                 ...           0.229489   0.130628    0.183838   \n",
      "gyr_y_max                 ...          -0.257241  -0.106926   -0.192333   \n",
      "gyr_y_mean                ...          -0.000494   0.003468    0.000886   \n",
      "gyr_y_std                 ...          -0.254194  -0.131219   -0.199196   \n",
      "gyr_y_var                 ...          -0.196119  -0.117766   -0.158428   \n",
      "gyr_z_min                 ...           0.226825   0.145661    0.188539   \n",
      "gyr_z_max                 ...          -0.238327  -0.141427   -0.192602   \n",
      "gyr_z_mean                ...          -0.035331  -0.002988   -0.022740   \n",
      "gyr_z_std                 ...          -0.242320  -0.148782   -0.198268   \n",
      "gyr_z_var                 ...          -0.173166  -0.129787   -0.148753   \n",
      "gyr_magnitude_min         ...          -0.182929  -0.102577   -0.149175   \n",
      "gyr_magnitude_max         ...          -0.262412  -0.138186   -0.207541   \n",
      "gyr_magnitude_mean        ...          -0.280990  -0.141372   -0.220962   \n",
      "gyr_magnitude_std         ...          -0.267998  -0.141359   -0.211726   \n",
      "gyr_magnitude_var         ...          -0.211558  -0.127182   -0.171675   \n",
      "mag_x_min                 ...           0.823317   0.772632    0.810640   \n",
      "mag_x_max                 ...           0.807441   0.802462    0.817115   \n",
      "mag_x_mean                ...           0.818610   0.790359    0.817193   \n",
      "mag_x_std                 ...          -0.158343   0.060482   -0.052294   \n",
      "mag_x_var                 ...          -0.066744   0.062665   -0.003923   \n",
      "mag_y_min                 ...           0.802638   0.797096    0.808718   \n",
      "mag_y_max                 ...           0.783675   0.805324    0.802830   \n",
      "mag_y_mean                ...           0.793661   0.802317    0.807063   \n",
      "mag_y_std                 ...          -0.158980   0.036268   -0.065443   \n",
      "mag_y_var                 ...          -0.023585   0.050362    0.013380   \n",
      "mag_z_min                 ...           1.000000   0.941825    0.985407   \n",
      "mag_z_max                 ...           0.941825   1.000000    0.982405   \n",
      "mag_z_mean                ...           0.985407   0.982405    1.000000   \n",
      "mag_z_std                 ...          -0.266185   0.066566   -0.110714   \n",
      "mag_z_var                 ...          -0.158894   0.065569   -0.049693   \n",
      "mag_magnitude_min         ...           0.819635   0.793870    0.818920   \n",
      "mag_magnitude_max         ...           0.801382   0.803789    0.814565   \n",
      "mag_magnitude_mean        ...           0.812247   0.800060    0.818577   \n",
      "mag_magnitude_std         ...          -0.094137   0.105544    0.004714   \n",
      "mag_magnitude_var         ...          -0.044911   0.055314    0.004956   \n",
      "\n",
      "                    mag_z_std  mag_z_var  mag_magnitude_min  \\\n",
      "acc_x_min           -0.278981  -0.065295           0.289833   \n",
      "acc_x_max            0.387228   0.079085          -0.073629   \n",
      "acc_x_mean           0.176392   0.026472           0.133018   \n",
      "acc_x_std            0.367738   0.076716          -0.181099   \n",
      "acc_x_var            0.224847   0.038394          -0.154278   \n",
      "acc_y_min           -0.481260  -0.120521           0.184111   \n",
      "acc_y_max            0.067005  -0.000505          -0.040790   \n",
      "acc_y_mean          -0.320615  -0.090643           0.111717   \n",
      "acc_y_std            0.433829   0.098181          -0.196331   \n",
      "acc_y_var            0.344511   0.072720          -0.187659   \n",
      "acc_z_min           -0.484282  -0.113439           0.207143   \n",
      "acc_z_max            0.421491   0.109950          -0.072747   \n",
      "acc_z_mean          -0.423283  -0.098070           0.229820   \n",
      "acc_z_std            0.530979   0.135313          -0.175305   \n",
      "acc_z_var            0.525391   0.140629          -0.181217   \n",
      "acc_magnitude_min   -0.447286  -0.095757           0.174953   \n",
      "acc_magnitude_max    0.491288   0.112292          -0.198186   \n",
      "acc_magnitude_mean   0.357346   0.085115          -0.163429   \n",
      "acc_magnitude_std    0.479755   0.107159          -0.205049   \n",
      "acc_magnitude_var    0.456954   0.103345          -0.209061   \n",
      "gyr_x_min           -0.527626  -0.135541           0.199888   \n",
      "gyr_x_max            0.544955   0.135062          -0.214236   \n",
      "gyr_x_mean           0.013414  -0.002403          -0.012038   \n",
      "gyr_x_std            0.554285   0.141285          -0.211623   \n",
      "gyr_x_var            0.535858   0.144066          -0.182515   \n",
      "gyr_y_min           -0.312587  -0.057810           0.190207   \n",
      "gyr_y_max            0.473888   0.112707          -0.217195   \n",
      "gyr_y_mean           0.012411   0.011625          -0.002379   \n",
      "gyr_y_std            0.389536   0.083120          -0.210159   \n",
      "gyr_y_var            0.247903   0.045702          -0.157463   \n",
      "gyr_z_min           -0.256342  -0.037376           0.185136   \n",
      "gyr_z_max            0.305615   0.052754          -0.194059   \n",
      "gyr_z_mean           0.098942   0.031376          -0.020356   \n",
      "gyr_z_std            0.297170   0.049538          -0.197430   \n",
      "gyr_z_var            0.138008   0.008426          -0.135870   \n",
      "gyr_magnitude_min    0.263648   0.056631          -0.168264   \n",
      "gyr_magnitude_max    0.394684   0.083673          -0.216712   \n",
      "gyr_magnitude_mean   0.447136   0.099769          -0.233814   \n",
      "gyr_magnitude_std    0.403964   0.088757          -0.215337   \n",
      "gyr_magnitude_var    0.269812   0.053460          -0.165794   \n",
      "mag_x_min           -0.221417  -0.074028           0.924354   \n",
      "mag_x_max           -0.095341   0.017368           0.921896   \n",
      "mag_x_mean          -0.159678  -0.029198           0.926785   \n",
      "mag_x_std            0.633602   0.493796          -0.102495   \n",
      "mag_x_var            0.412736   0.526959          -0.025690   \n",
      "mag_y_min           -0.087334  -0.041689           0.945599   \n",
      "mag_y_max           -0.009755   0.011913           0.937639   \n",
      "mag_y_mean          -0.046717  -0.014008           0.942537   \n",
      "mag_y_std            0.587559   0.448339          -0.076167   \n",
      "mag_y_var            0.269962   0.400177          -0.012957   \n",
      "mag_z_min           -0.266185  -0.158894           0.819635   \n",
      "mag_z_max            0.066566   0.065569           0.793870   \n",
      "mag_z_mean          -0.110714  -0.049693           0.818920   \n",
      "mag_z_std            1.000000   0.701920          -0.155732   \n",
      "mag_z_var            0.701920   1.000000          -0.046490   \n",
      "mag_magnitude_min   -0.155732  -0.046490           1.000000   \n",
      "mag_magnitude_max   -0.076511   0.037315           0.991535   \n",
      "mag_magnitude_mean  -0.117334  -0.004651           0.997606   \n",
      "mag_magnitude_std    0.590337   0.670309          -0.012023   \n",
      "mag_magnitude_var    0.350626   0.570942          -0.006734   \n",
      "\n",
      "                    mag_magnitude_max  mag_magnitude_mean  mag_magnitude_std  \\\n",
      "acc_x_min                    0.288555            0.289644           0.005234   \n",
      "acc_x_max                   -0.084633           -0.079137          -0.068688   \n",
      "acc_x_mean                   0.121893            0.127778          -0.060060   \n",
      "acc_x_std                   -0.188716           -0.185009          -0.050557   \n",
      "acc_x_var                   -0.161526           -0.157860          -0.048251   \n",
      "acc_y_min                    0.192760            0.188623           0.057208   \n",
      "acc_y_max                   -0.041135           -0.040975          -0.002954   \n",
      "acc_y_mean                   0.117830            0.114888           0.040275   \n",
      "acc_y_std                   -0.203790           -0.200177          -0.047442   \n",
      "acc_y_var                   -0.194900           -0.191337          -0.047462   \n",
      "acc_z_min                    0.212933            0.210342           0.040393   \n",
      "acc_z_max                   -0.077574           -0.075305          -0.031570   \n",
      "acc_z_mean                   0.234976            0.232807           0.036884   \n",
      "acc_z_std                   -0.180559           -0.178193          -0.033026   \n",
      "acc_z_var                   -0.185280           -0.183539          -0.025281   \n",
      "acc_magnitude_min            0.182428            0.178927           0.055501   \n",
      "acc_magnitude_max           -0.206090           -0.202402          -0.054977   \n",
      "acc_magnitude_mean          -0.170442           -0.167196          -0.046486   \n",
      "acc_magnitude_std           -0.213110           -0.209323          -0.055866   \n",
      "acc_magnitude_var           -0.216985           -0.213226          -0.054993   \n",
      "gyr_x_min                    0.205393            0.202911           0.038221   \n",
      "gyr_x_max                   -0.221379           -0.218158          -0.049733   \n",
      "gyr_x_mean                  -0.011599           -0.012083          -0.000279   \n",
      "gyr_x_std                   -0.218266           -0.215254          -0.045096   \n",
      "gyr_x_var                   -0.187963           -0.185500          -0.037288   \n",
      "gyr_y_min                    0.198678            0.194556           0.060310   \n",
      "gyr_y_max                   -0.225107           -0.221365          -0.054653   \n",
      "gyr_y_mean                  -0.001154           -0.002179           0.012888   \n",
      "gyr_y_std                   -0.218460           -0.214445          -0.056888   \n",
      "gyr_y_var                   -0.165417           -0.161440          -0.054929   \n",
      "gyr_z_min                    0.193684            0.189445           0.060733   \n",
      "gyr_z_max                   -0.201770           -0.198049          -0.053879   \n",
      "gyr_z_mean                  -0.018358           -0.019626           0.017309   \n",
      "gyr_z_std                   -0.205763           -0.201690          -0.058109   \n",
      "gyr_z_var                   -0.142798           -0.139286          -0.048841   \n",
      "gyr_magnitude_min           -0.178700           -0.173540          -0.070992   \n",
      "gyr_magnitude_max           -0.225949           -0.221425          -0.063387   \n",
      "gyr_magnitude_mean          -0.243788           -0.239087          -0.067249   \n",
      "gyr_magnitude_std           -0.223272           -0.219425          -0.051888   \n",
      "gyr_magnitude_var           -0.173573           -0.169680          -0.051337   \n",
      "mag_x_min                    0.910201            0.919195          -0.052896   \n",
      "mag_x_max                    0.926529            0.925851           0.083782   \n",
      "mag_x_mean                   0.921830            0.926491           0.014326   \n",
      "mag_x_std                   -0.007922           -0.056420           0.723720   \n",
      "mag_x_var                    0.064017            0.018638           0.774561   \n",
      "mag_y_min                    0.932269            0.940650          -0.046038   \n",
      "mag_y_max                    0.935650            0.938260           0.039938   \n",
      "mag_y_mean                   0.934885            0.940792          -0.003092   \n",
      "mag_y_std                    0.009690           -0.033804           0.700746   \n",
      "mag_y_var                    0.057848            0.022714           0.678315   \n",
      "mag_z_min                    0.801382            0.812247          -0.094137   \n",
      "mag_z_max                    0.803789            0.800060           0.105544   \n",
      "mag_z_mean                   0.814565            0.818577           0.004714   \n",
      "mag_z_std                   -0.076511           -0.117334           0.590337   \n",
      "mag_z_var                    0.037315           -0.004651           0.670309   \n",
      "mag_magnitude_min            0.991535            0.997606          -0.012023   \n",
      "mag_magnitude_max            1.000000            0.997423           0.113701   \n",
      "mag_magnitude_mean           0.997423            1.000000           0.049771   \n",
      "mag_magnitude_std            0.113701            0.049771           1.000000   \n",
      "mag_magnitude_var            0.080016            0.036748           0.797703   \n",
      "\n",
      "                    mag_magnitude_var  \n",
      "acc_x_min                    0.009554  \n",
      "acc_x_max                   -0.019174  \n",
      "acc_x_mean                  -0.010913  \n",
      "acc_x_std                   -0.009740  \n",
      "acc_x_var                   -0.008598  \n",
      "acc_y_min                    0.016011  \n",
      "acc_y_max                   -0.003129  \n",
      "acc_y_mean                   0.010208  \n",
      "acc_y_std                   -0.008633  \n",
      "acc_y_var                   -0.012561  \n",
      "acc_z_min                    0.015216  \n",
      "acc_z_max                   -0.021127  \n",
      "acc_z_mean                   0.011162  \n",
      "acc_z_std                   -0.008880  \n",
      "acc_z_var                   -0.010770  \n",
      "acc_magnitude_min            0.025334  \n",
      "acc_magnitude_max           -0.023238  \n",
      "acc_magnitude_mean          -0.011499  \n",
      "acc_magnitude_std           -0.019891  \n",
      "acc_magnitude_var           -0.022629  \n",
      "gyr_x_min                    0.019087  \n",
      "gyr_x_max                   -0.022760  \n",
      "gyr_x_mean                  -0.004644  \n",
      "gyr_x_std                   -0.018853  \n",
      "gyr_x_var                   -0.019176  \n",
      "gyr_y_min                    0.023091  \n",
      "gyr_y_max                   -0.016461  \n",
      "gyr_y_mean                   0.030593  \n",
      "gyr_y_std                   -0.016772  \n",
      "gyr_y_var                   -0.017653  \n",
      "gyr_z_min                    0.023235  \n",
      "gyr_z_max                   -0.016169  \n",
      "gyr_z_mean                   0.019504  \n",
      "gyr_z_std                   -0.018147  \n",
      "gyr_z_var                   -0.015933  \n",
      "gyr_magnitude_min           -0.020900  \n",
      "gyr_magnitude_max           -0.018033  \n",
      "gyr_magnitude_mean          -0.018058  \n",
      "gyr_magnitude_std           -0.007432  \n",
      "gyr_magnitude_var           -0.008765  \n",
      "mag_x_min                   -0.010191  \n",
      "mag_x_max                    0.068254  \n",
      "mag_x_mean                   0.028699  \n",
      "mag_x_std                    0.489969  \n",
      "mag_x_var                    0.801580  \n",
      "mag_y_min                   -0.015742  \n",
      "mag_y_max                    0.051618  \n",
      "mag_y_mean                   0.018160  \n",
      "mag_y_std                    0.653136  \n",
      "mag_y_var                    0.935335  \n",
      "mag_z_min                   -0.044911  \n",
      "mag_z_max                    0.055314  \n",
      "mag_z_mean                   0.004956  \n",
      "mag_z_std                    0.350626  \n",
      "mag_z_var                    0.570942  \n",
      "mag_magnitude_min           -0.006734  \n",
      "mag_magnitude_max            0.080016  \n",
      "mag_magnitude_mean           0.036748  \n",
      "mag_magnitude_std            0.797703  \n",
      "mag_magnitude_var            1.000000  \n",
      "\n",
      "[60 rows x 60 columns]\n"
     ]
    }
   ],
   "source": [
    "corr = df_X_normalized[df_X_normalized.columns].corr()\n",
    "print(corr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ztX0lxnYQDMd"
   },
   "outputs": [],
   "source": [
    "print(df_X_normalized.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "iitJARg8QDMh"
   },
   "outputs": [],
   "source": [
    "#####################################\n",
    "#### EXPORT results to csv files ####\n",
    "#####################################\n",
    "\n",
    "df_acc_cut.to_csv('datasets/final_acc.csv', sep='\\t', encoding='utf-8')\n",
    "df_mag_cut.to_csv('datasets/final_mag.csv', sep='\\t', encoding='utf-8')\n",
    "df_gyr_cut.to_csv('datasets/final_gyr.csv', sep='\\t', encoding='utf-8')\n",
    "df_gps_new.to_csv('datasets/final_gps.csv', sep='\\t', encoding='utf-8')\n",
    "\n",
    "# Filter for null values in gps\n",
    "#df_null = df_gps_new[df_gps_new['duration']==0]\n",
    "#df_null.to_csv('datasets/gps_null.csv', sep='\\t', encoding='utf-8')\n",
    "\n",
    "# Filter for startTime=endTime (=> endTime not correctly set)\n",
    "#df_no_duration = df_act[df_act['startTime'] == df_act['endTime']]\n",
    "#df_no_duration.to_csv('datasets/final_no_duration.csv', sep='\\t', encoding='utf-8')\n",
    "\n",
    "#df_no_value = df_acc_new[df_acc_new['definedActivity'] == 7]\n",
    "\n",
    "#df_no_value[['x','y','z']].to_csv('datasets/final_no_value.csv', sep='\\t', encoding='utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QsVf5HBgQDMk"
   },
   "outputs": [],
   "source": [
    "################################\n",
    "#### PLOT specific activity ####\n",
    "################################\n",
    "\n",
    "def plot_activity(activity, df):\n",
    "    #data = df[df['activityId'] == activity][['x', 'y', 'z','magnitude']]\n",
    "    data = df[df['definedActivity'] == activity][['x', 'y', 'z','magnitude']].reset_index().drop('index', axis=1)\n",
    "    \n",
    "    axis = data.plot(subplots=True,  \n",
    "                     title=activity,\n",
    "                    figsize=(14,12))\n",
    "    for ax in axis:\n",
    "        ax.legend(loc='lower left', bbox_to_anchor=(1.0, 0.5))\n",
    "\n",
    "df_specAct = df_gyr_denoise\n",
    "plot_activity(5, df_specAct)\n",
    "\n",
    "# Create filter to only show a specific activity of a dataframe\n",
    "df_isin_acc = df_acc_new['activityId']=='5b7bdc6d5d0e657f28c769d9'\n",
    "df_acc_filtered = df_acc_new[df_isin_acc]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "T85mU7HRQDMn",
    "outputId": "7b4a76da-1b1a-460d-c18f-db609a78a434"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AxesSubplot(0.125,0.125;0.775x0.755)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEGCAYAAAB1iW6ZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAADt5JREFUeJzt3X2MZXV9x/H3B1atCrWSHRDEdaxBhURd7BaaUoxKpYi2SAsRapW22q0ttmLxj01rI2nTBhstNqmpXQWlDz6iBNpaCkWqaA1ledBdXCkUtoDysMYHRFN14ds/7hkcxxnunXvnztn5+X4lkzn33HPP/c4yvPfsmXvupKqQJK19+/Q9gCRpZRh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRqxbzSdbv359zc7OruZTStKad911132lqmaGbbeqQZ+dnWXbtm2r+ZSStOYl+d9RtvOUiyQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1wqBLUiNW9cIiSVoL7tpy9VT3f+i5x05lvx6hS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjDLokNcKgS1IjhgY9yVOSXJVkZ5KbkryhW39AkiuS3NJ9fuL0x5UkLWWUI/Q9wNlVdTjwM8CZSY4AtgBXVtVhwJXdbUlST4YGvarurqrru+VvAjuBJwMnARd2m10IvHxaQ0qShlvWOfQks8CRwDXAQVV1NwyiDxy4xGM2J9mWZNvu3bsnm1aStKSRg55kP+CjwFlVdf+oj6uqrVW1qao2zczMjDOjJGkEIwU9yaMYxPwfq+pj3ep7kxzc3X8wcN90RpQkjWKUV7kEOB/YWVV/Oe+uS4EzuuUzgEtWfjxJ0qjWjbDNMcCrgO1JbuzW/SFwLvDhJK8B7gBOnc6IkqRRDA16VX0ayBJ3H7ey40iSxuWVopLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0w6JLUCIMuSY0YGvQkFyS5L8mOeevOSfKlJDd2HydOd0xJ0jCjHKG/DzhhkfXnVdXG7uPjKzuWJGm5hga9qj4FfHUVZpEkTWDdBI99fZJXA9uAs6vqa4ttlGQzsBlgw4YNEzzdGnTOE6a8/29Md/+S1pRxfyj6N8DTgY3A3cDbl9qwqrZW1aaq2jQzMzPm00mShhkr6FV1b1U9WFUPAe8GjlrZsSRJyzVW0JMcPO/mycCOpbaVJK2OoefQk3wAeAGwPsldwFuAFyTZCBSwC/jtKc4oSRrB0KBX1emLrD5/CrNIkibglaKS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNMOiS1AiDLkmNWNf3AJLa8/ZXvGyq+z/7Q/881f2vVR6hS1IjDLokNcKgS1IjDLokNcKgS1IjhgY9yQVJ7kuyY966A5JckeSW7vMTpzumJGmYUY7Q3wecsGDdFuDKqjoMuLK7LUnq0dCgV9WngK8uWH0ScGG3fCHw8hWeS5K0TOOeQz+oqu4G6D4fuNSGSTYn2ZZk2+7du8d8OknSMFP/oWhVba2qTVW1aWZmZtpPJ0k/ssYN+r1JDgboPt+3ciNJksYxbtAvBc7ols8ALlmZcSRJ4xrlZYsfAD4LPDPJXUleA5wLvDjJLcCLu9uSpB4NfbfFqjp9ibuOW+FZJEkT8EpRSWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRhh0SWqEQZekRqzre4BHMrvlX6a6/13nvnSq+5ek1eQRuiQ1wqBLUiMMuiQ1wqBLUiMMuiQ1YqJXuSTZBXwTeBDYU1WbVmIoSdLyrcTLFl9YVV9Zgf1IkibgKRdJasSkR+gFXJ6kgL+tqq0LN0iyGdgMsGHDhgmfThrNzmcdPtX9H/7FnVPdvzSOSY/Qj6mq5wEvAc5M8vyFG1TV1qraVFWbZmZmJnw6SdJSJgp6VX25+3wfcDFw1EoMJUlavrGDnuTxSfafWwaOB3as1GCSpOWZ5Bz6QcDFSeb28/6qumxFppIkLdvYQa+q24DnruAskqQJ+LJFSWqEQZekRhh0SWrEXv0bi9SvZ1/47Knte/sZ26e2b+lHlUfoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjTDoktQIgy5JjfDCImkv9M7XfWKq+z/zXS+a6v7VD4/QJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakRBl2SGmHQJakREwU9yQlJbk5ya5ItKzWUJGn5xg56kn2BdwIvAY4ATk9yxEoNJklankmO0I8Cbq2q26rqu8AHgZNWZixJ0nKlqsZ7YHIKcEJVvba7/Srg6Kp6/YLtNgObu5vPBG4ef9yh1gNfmeL+p835+7OWZwfn79u0539qVc0M22jdBE+QRdb90N8OVbUV2DrB84wsybaq2rQazzUNzt+ftTw7OH/f9pb5JznlchfwlHm3DwW+PNk4kqRxTRL0a4HDkjwtyaOB04BLV2YsSdJyjX3Kpar2JHk98G/AvsAFVXXTik02nlU5tTNFzt+ftTw7OH/f9or5x/6hqCRp7+KVopLUCIMuSY0w6JLUCIOusSQ5KslPd8tHJPmDJCf2Pde4kvxd3zNIk5rkwiJNIMmzgCcD11TVA/PWn1BVl/U32XBJ3sLgPXzWJbkCOBr4D2BLkiOr6s/6nG+YJAtfXhvghUl+AqCqfmn1pxpfkp9j8FYcO6rq8r7nGSbJ0cDOqro/yWOBLcDzgC8Af15V3+h1wCGS/D5wcVXd2fcsCzX5Kpckv1FV7+17jqV03xBnAjuBjcAbquqS7r7rq+p5fc43TJLtDOZ+DHAPcOi8/zmvqarn9DrgEEmuZxCP9zC4ujnABxhcS0FVfbK/6YZL8l9VdVS3/FsMvpcuBo4H/qmqzu1zvmGS3AQ8t3vp81bg28BFwHHd+l/udcAhknwD+BbwPwy+bz5SVbv7napTVc19AHf0PcOQ+bYD+3XLs8A2BlEHuKHv+UaY/4bFlrvbN/Y93wjz7wO8EbgC2Nitu63vucb8878WmOmWHw9s73u+EebfOW/5+gX3rYXvnxu676HjgfOB3cBlwBnA/n3OtmZPuST5/FJ3AQet5ixj2Le60yxVtSvJC4CLkjyVxd8jZ2/z3SSPq6pvAz81tzLJE4CH+htrNFX1EHBeko90n+9lbZ1+3CfJExlEJdUdHVbVt5Ls6Xe0keyY96/ozyXZVFXbkjwD+F7fw42guu+hy4HLkzyKwSnI04G3AUPfRGta1tI38UIHAb8AfG3B+gD/ufrjLMs9STZW1Y0AVfVAkpcBFwDP7ne0kTy/qr4DD8dxzqMYHKWsCVV1F3BqkpcC9/c9zzI8AbiOwfd6JXlSVd2TZD/WxgHBa4G/SvJmBu9Q+NkkdwJ3dvft7X7gz7iqvsfgbU8u7U479mbNnkNPcj7w3qr69CL3vb+qfrWHsUaS5FBgT1Xds8h9x1TVZ3oYS2tckscBB1XV7X3PMook+wM/yeDA8q6qurfnkUaS5BlV9d99z7GYNRt0SdIP8nXoktQIgy5JjTDo6l2Sc5K86RHun0lyTZIbkhyb5ONzFwGtwHM/sOD2G5P8X/eKnWGPPas7bz13+xHnSnJIkou65Y1r+cpa7Z0MutaC44AvVtWRVXV1VZ1YVV+f0nOdzuC13SePsO1ZwMNBHzZXVX25qk7pbm4EDLpWlEFXL5L8UZKbk/w7g18eTpKnJ7ksyXVJrk7yrCQbgb8ATkxyY5LHJtmVZH2S2SQ7k7w7yU1JLp972dhi++rWPy3JZ5Ncm+RPF8z0dGA/4M0Mwj63ft8kb0uyPcnnk/xed7XvIcBVSa7qtpub661Jfnfe489JcnY3747uN3z9CfCK7mt6RZJbksx02++T5NYk66f1569G9X3VlR8/eh8MLkbazuDo9seBW4E3AVcCh3XbHA18olv+deCv5z1+F4Pfsj4L7OH7V3t+GPi1bnmpfV0KvLpbPhN4YN5+3wz8MYMDnV3Agd363wE+Cqzrbh8wf45F5joS+OS89V8ANnTz7ljia3oLcFa3fDzw0b7/O/mx9j7W8oVFWruOZfDmRt+Gh98s68eAnwU+kjx83cZjRtjX7dVdoMXgYpvZ7gKbpfZ1DPAr3fLfA2+dt6/TgJOr6qEkHwNOBd4J/DzwrqraA1BVX32kgarqhiQHJjmEwVWDX6uqO5LMPsLDLgAuAd4B/Caw174XkfZeBl19WXgBxD7A16tq4zL38515yw8Cjx1hXz908UWS5wCHAVd0fwk8GriNQdCz2GOGuAg4BXgS8MFhG1fVnUnuTfIiBv+ieOUyn0/yHLp68Sng5O58+P7ALzJ4x73bk5wKkIHnjrPzqrr/Efb1Gbp3VeQHo3k6cE5VzXYfhwBP7t5f53LgdUnWdfs7oHvMN4H9lxjjg93znMIg7gst9tj3AP8AfLiqHhztq5W+z6Br1VXV9cCHgBsZnJu+urvrlcBrknwOuAk4aYKnWWpfbwDOTHItg/dEmXMag7egne/ibv17gDuAz3f7m3tbia3Av879UHTB13gTg2B/qaruXmS+q4Aj5n4o2q27lMEPZT3dorF46b+0l0iyCTivqo7texatTZ5Dl/YCSbYweDWN5841No/QJakRnkOXpEYYdElqhEGXpEYYdElqhEGXpEb8PzIkIW5BedeEAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(df_acc_cut.groupby('definedActivity')['activityId'].nunique().plot(kind='bar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "S7wCvHjAQDMv",
    "outputId": "c393a8b1-20aa-4ae2-9bf8-8e55b4859a51"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AxesSubplot(0.125,0.125;0.775x0.755)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(df_acc_cut.groupby('definedActivity')['activityId'].count().plot(kind='bar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "B4ICvxZ5QDM5"
   },
   "outputs": [],
   "source": [
    "               \n",
    "                #################################################################\n",
    "                #################################################################\n",
    "                ##################### END OF USED STUFF #########################\n",
    "                #################################################################\n",
    "                #################################################################\n",
    "                                            \n",
    "                                            THE END"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9QIhka7iQDM9"
   },
   "outputs": [],
   "source": [
    "######################################################################################################################\n",
    "######################################################################################################################\n",
    "######################################################################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hzdMnG5mQDNB"
   },
   "outputs": [],
   "source": [
    "##############################################\n",
    "#### REMOVE Duplicates in dataframes #########\n",
    "##############################################\n",
    "\n",
    "#print(df_acc_new.groupby('activityId')['x'].apply(lambda x: x.count()))\n",
    "def removeAllDuplicates():\n",
    "    #is_duplicate_acc = df_acc_new['activityId'] == activity\n",
    "    #is_duplicate_gyr = df_gyr_new['activityId'] == activity\n",
    "    #is_duplicate_mag = df_mag_new['activityId'] == activity\n",
    "\n",
    "    #filter_duplicate_acc = df_acc_new[is_duplicate_acc]\n",
    "    #filter_duplicate_gyr = df_gyr_new[is_duplicate_gyr]\n",
    "    #filter_duplicate_mag = df_mag_new[is_duplicate_mag]\n",
    "    \n",
    "    duplicates_removed_acc = df_acc_denoise.reset_index().drop_duplicates(subset='timestamp', keep='last')\n",
    "    duplicates_removed_gyr = df_gyr_denoise.reset_index().drop_duplicates(subset='timestamp', keep='last')\n",
    "    duplicates_removed_mag = df_mag_denoise.reset_index().drop_duplicates(subset='timestamp', keep='last')\n",
    "    \n",
    "    print(\"old/new ACC --> \",len(df_acc_denoise), \" | \", len(duplicates_removed_acc))\n",
    "    print(\"old/new GYR --> \",len(df_gyr_denoise), \" | \", len(duplicates_removed_gyr))\n",
    "    print(\"old/new MAG --> \",len(df_mag_denoise), \" | \", len(duplicates_removed_mag))\n",
    "\n",
    "    return duplicates_removed_acc, duplicates_removed_gyr, duplicates_removed_mag\n",
    "#np.set_printoptions(threshold=np.inf)\n",
    "#print(filter_duplicate.index, filter_duplicate.index.duplicated(keep=False))\n",
    "\n",
    "#df_acc_denoise, df_gyr_denoise, df_mag_denoise = removeDuplicates()"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "Preprocessing-Data.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}