format_vehkaoja_dogs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "86ce8245-b923-42ba-b1cf-b0a8bdb804d4",
   "metadata": {},
   "source": [
    "# Notebook to format data from \"Movement Sensor Dataset for Dog Behavior Classification\", Vehkaoja et al (2017).\n",
    "\n",
    "[Data is here](https://data.mendeley.com/datasets/vxhx934tbn/1) \n",
    "\n",
    "[Related paper is here](https://www.sciencedirect.com/science/article/pii/S0168159121001805#:~:text=Two%20sensor%20devices%20were%20attached,one%20on%20the%20neck%20collar.&text=The%20results%20were%20promising%3B%20the,yielded%2075%20%25%20accuracy%20at%20best.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77461baa-2d89-4ddf-b8b9-283f19b3313e",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a9cd11e9-258b-4304-a21d-f826f276b73b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Outputs:\n",
    "# formatted dataset directory\n",
    "# dataset_metadata (yaml), includes\n",
    "## sample_rate\n",
    "## dataset_label_names (list)\n",
    "## dataset_feature_names (list)\n",
    "## clip_ids (list)\n",
    "# clip_data (directory), includes\n",
    "## data_files (multiple files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7470e077-e978-495a-b349-27cc5a6b2a40",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ec388900-f0ab-4e41-a56b-9597e4f4911f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import h5py\n",
    "from matplotlib import pyplot as plt\n",
    "import glob\n",
    "import yaml\n",
    "import tqdm\n",
    "import scipy.signal as signal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6bc728a2-a91e-4da2-abea-4b57ceb4e818",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify data filepaths\n",
    "\n",
    "raw_data_dir = '/home/jupyter/behavior_data_local/data/raw/vehkaoja_dogs'\n",
    "formatted_data_dir = '/home/jupyter/behavior_data_local/data/formatted/vehkaoja_dogs'\n",
    "\n",
    "if not os.path.exists(formatted_data_dir):\n",
    "    os.makedirs(formatted_data_dir)\n",
    "    \n",
    "data_fp = os.path.join(raw_data_dir, 'DogMoveData.csv')\n",
    "\n",
    "clip_data_dir = os.path.join(formatted_data_dir, 'clip_data')\n",
    "if not os.path.exists(clip_data_dir):\n",
    "    os.makedirs(clip_data_dir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed6d55ef-3574-4052-9506-6c2d9af412cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up clip ids and metadata\n",
    "\n",
    "# Dataset metadata\n",
    "dataset_metadata = {}\n",
    "sr = 100\n",
    "dataset_metadata['sr'] = sr ## from dataset documentation\n",
    "dataset_metadata['dataset_name'] = 'vehkaoja_dogs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4adfe299-65f8-466a-9f05-3a6edb076aa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_full = pd.read_csv(data_fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "25cc6bef-abec-46aa-a11e-40564b9d0062",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_clip_id(row):\n",
    "    return 'individual_' + str(row['DogID']) + '_test_' + str(row['TestNum'])\n",
    "\n",
    "data_full['clip_id'] = data_full.apply(create_clip_id, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "289d75dd-6fb9-44a5-9ac5-bea4c6fe24d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get a list of the individual ids\n",
    "\n",
    "individual_ids = sorted(set(data_full['DogID']))\n",
    "dataset_metadata['individual_ids'] = individual_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "afe02421-9aeb-4fa3-8197-7d3497c4108d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Clip ids\n",
    "clip_ids = sorted(set(data_full['clip_id']))  \n",
    "dataset_metadata['clip_ids'] = clip_ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1c410f30-41bd-467e-992b-4bf5399d2051",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: [16, 22, 28, 36, 45, 51, 56, 61, 68], 1: [18, 23, 29, 39, 46, 52, 57, 63, 70], 2: [19, 25, 30, 41, 47, 53, 58, 65, 72], 3: [20, 26, 33, 43, 48, 54, 59, 66, 73], 4: [21, 27, 34, 44, 49, 55, 60, 67, 74]}\n",
      "There are 45 individuals\n"
     ]
    }
   ],
   "source": [
    "# Set up data splits: divide individuals across folds for cross validation\n",
    "\n",
    "n_folds = 5\n",
    "dataset_metadata['n_folds'] = n_folds\n",
    "individuals_per_fold = {i : [] for i in range(n_folds)}\n",
    "\n",
    "for pointer, individual in enumerate(individual_ids):\n",
    "    individuals_per_fold[pointer % n_folds].append(individual)\n",
    "    \n",
    "dataset_metadata['individuals_per_fold'] = individuals_per_fold\n",
    "    \n",
    "print(individuals_per_fold)\n",
    "print(\"There are %d individuals\" % len(individual_ids))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7ea20959-639e-4f2c-8efa-945516302110",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Integer codes for individuals\n",
    "\n",
    "clip_id_to_individual_id = {clip_id : int(clip_id.split('_')[1]) for clip_id in clip_ids}\n",
    "dataset_metadata['clip_id_to_individual_id'] = clip_id_to_individual_id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "02c3ee68-2436-4782-b8a8-bbeb354956df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up clip ids \n",
    "\n",
    "clip_ids_per_fold = {i : [] for i in range(n_folds)}\n",
    "for clip_id in clip_ids:\n",
    "    individual = clip_id_to_individual_id[clip_id]\n",
    "    for fold in range(n_folds):\n",
    "        if individual in individuals_per_fold[fold]:\n",
    "            clip_ids_per_fold[fold].append(clip_id)\n",
    "for fold in range(n_folds):\n",
    "    clip_ids_per_fold[fold] = sorted(clip_ids_per_fold[fold])\n",
    "\n",
    "dataset_metadata['clip_ids_per_fold'] = clip_ids_per_fold"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fca914b-f4d0-4265-b18c-71cd7aca2dc5",
   "metadata": {},
   "source": [
    "## Create dataset-level metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "294ee416-1f03-4891-8e99-caaf33773c3e",
   "metadata": {},
   "source": [
    "Each frame can be annotated with up to three behaviors simultaneously. We want to pare it down to a typical multi-class classification problem. We will eliminate some of the labels, since they typically occur coincidentally with other behaviors. After this, if frames have more than one label we call them `unknown`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c2146239-1d30-45b5-8eaf-ba47823fd915",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['<undefined>', 'Bowing', 'Carrying object', 'Drinking', 'Eating', 'Extra_Synchronization', 'Galloping', 'Jumping', 'Lying chest', 'Pacing', 'Panting', 'Playing', 'Shaking', 'Sitting', 'Sniffing', 'Standing', 'Synchronization', 'Trotting', 'Tugging', 'Walking']\n"
     ]
    }
   ],
   "source": [
    "# Get the names of the observed labels\n",
    "\n",
    "observed_labels = list(set(data_full['Behavior_1']).union(data_full['Behavior_3']).union(data_full['Behavior_3']))\n",
    "observed_labels.sort()\n",
    "\n",
    "print(observed_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "97edfab7-18ef-49e5-a076-e9e9493e3da6",
   "metadata": {},
   "outputs": [],
   "source": [
    "if False:\n",
    "    coincident_behaviors = {}\n",
    "    print(len(data_full))\n",
    "    for i, row in tqdm.tqdm(data_full.iterrows()):\n",
    "        row_behaviors = set(row[['Behavior_1', 'Behavior_2', 'Behavior_3']])\n",
    "        row_behaviors.discard('<undefined>')\n",
    "        row_behaviors = list(row_behaviors)\n",
    "        row_behaviors.sort()\n",
    "        row_behaviors = tuple(row_behaviors)\n",
    "        if row_behaviors not in coincident_behaviors:\n",
    "            coincident_behaviors[row_behaviors] = 0\n",
    "        coincident_behaviors[row_behaviors] += 1\n",
    "\n",
    "    {k: v for k, v in sorted(coincident_behaviors.items(), key=lambda item: item[1])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "409885d1-25fe-4508-9fc8-730480f9b5ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"\\n{('Playing', 'Tugging', 'Walking'): 3,\\n ('Bowing',): 4,\\n ('Panting', 'Playing', 'Standing'): 16,\\n ('Shaking', 'Synchronization'): 35,\\n ('Carrying object', 'Playing'): 44,\\n ('Lying chest', 'Playing'): 58,\\n ('Playing', 'Standing'): 60,\\n ('Carrying object', 'Shaking'): 91,\\n ('Eating', 'Panting', 'Sitting'): 95,\\n ('Playing', 'Walking'): 119,\\n ('Lying chest', 'Panting', 'Playing'): 174,\\n ('Carrying object', 'Playing', 'Walking'): 182,\\n ('Eating', 'Galloping'): 195,\\n ('Eating',): 219,\\n ('Carrying object', 'Playing', 'Standing'): 247,\\n ('Bowing', 'Eating'): 271,\\n ('Extra_Synchronization',): 287,\\n ('Playing', 'Shaking'): 303,\\n ('Pacing', 'Playing'): 382,\\n ('Carrying object', 'Playing', 'Shaking'): 384,\\n ('Eating', 'Pacing'): 449,\\n ('Eating', 'Panting', 'Standing'): 477,\\n ('Carrying object', 'Lying chest', 'Playing'): 687,\\n ('Carrying object', 'Pacing', 'Playing'): 1002,\\n ('Carrying object', 'Standing'): 1075,\\n ('Tugging',): 1134,\\n ('Bowing', 'Carrying object', 'Playing'): 1265,\\n ('Carrying object', 'Lying chest'): 1832,\\n ('Panting',): 2331,\\n ('Carrying object', 'Trotting'): 2780,\\n ('Carrying object', 'Jumping', 'Playing'): 3653,\\n ('Galloping',): 3668,\\n ('Playing', 'Trotting'): 6430,\\n ('Carrying object', 'Walking'): 6861,\\n ('Eating', 'Trotting'): 10752,\\n ('Synchronization',): 16720,\\n ('Jumping', 'Playing', 'Tugging'): 18199,\\n ('Jumping', 'Playing'): 20224,\\n ('Eating', 'Walking'): 25552,\\n ('Carrying object', 'Playing', 'Trotting'): 36445,\\n ('Shaking',): 41366,\\n ('Drinking',): 64721,\\n ('Pacing',): 76766,\\n ('Eating', 'Sitting'): 77448,\\n ('Eating', 'Lying chest'): 81368,\\n ('Galloping', 'Playing'): 81752,\\n ('Carrying object', 'Galloping', 'Playing'): 89311,\\n ('Eating', 'Standing'): 115980,\\n ('Playing', 'Tugging'): 277766,\\n ('Standing',): 370930,\\n ('Sitting',): 389467,\\n ('Playing',): 398320,\\n ('Lying chest',): 463266,\\n ('Panting', 'Standing'): 538925,\\n ('Lying chest', 'Panting'): 582517,\\n ('Panting', 'Sitting'): 653106,\\n ('Trotting',): 717472,\\n ('Walking',): 750318,\\n ('Sniffing',): 1026178,\\n (): 3649386}\\n \""
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#output of the previous cell\n",
    "\n",
    "'''\n",
    "{('Playing', 'Tugging', 'Walking'): 3,\n",
    " ('Bowing',): 4,\n",
    " ('Panting', 'Playing', 'Standing'): 16,\n",
    " ('Shaking', 'Synchronization'): 35,\n",
    " ('Carrying object', 'Playing'): 44,\n",
    " ('Lying chest', 'Playing'): 58,\n",
    " ('Playing', 'Standing'): 60,\n",
    " ('Carrying object', 'Shaking'): 91,\n",
    " ('Eating', 'Panting', 'Sitting'): 95,\n",
    " ('Playing', 'Walking'): 119,\n",
    " ('Lying chest', 'Panting', 'Playing'): 174,\n",
    " ('Carrying object', 'Playing', 'Walking'): 182,\n",
    " ('Eating', 'Galloping'): 195,\n",
    " ('Eating',): 219,\n",
    " ('Carrying object', 'Playing', 'Standing'): 247,\n",
    " ('Bowing', 'Eating'): 271,\n",
    " ('Extra_Synchronization',): 287,\n",
    " ('Playing', 'Shaking'): 303,\n",
    " ('Pacing', 'Playing'): 382,\n",
    " ('Carrying object', 'Playing', 'Shaking'): 384,\n",
    " ('Eating', 'Pacing'): 449,\n",
    " ('Eating', 'Panting', 'Standing'): 477,\n",
    " ('Carrying object', 'Lying chest', 'Playing'): 687,\n",
    " ('Carrying object', 'Pacing', 'Playing'): 1002,\n",
    " ('Carrying object', 'Standing'): 1075,\n",
    " ('Tugging',): 1134,\n",
    " ('Bowing', 'Carrying object', 'Playing'): 1265,\n",
    " ('Carrying object', 'Lying chest'): 1832,\n",
    " ('Panting',): 2331,\n",
    " ('Carrying object', 'Trotting'): 2780,\n",
    " ('Carrying object', 'Jumping', 'Playing'): 3653,\n",
    " ('Galloping',): 3668,\n",
    " ('Playing', 'Trotting'): 6430,\n",
    " ('Carrying object', 'Walking'): 6861,\n",
    " ('Eating', 'Trotting'): 10752,\n",
    " ('Synchronization',): 16720,\n",
    " ('Jumping', 'Playing', 'Tugging'): 18199,\n",
    " ('Jumping', 'Playing'): 20224,\n",
    " ('Eating', 'Walking'): 25552,\n",
    " ('Carrying object', 'Playing', 'Trotting'): 36445,\n",
    " ('Shaking',): 41366,\n",
    " ('Drinking',): 64721,\n",
    " ('Pacing',): 76766,\n",
    " ('Eating', 'Sitting'): 77448,\n",
    " ('Eating', 'Lying chest'): 81368,\n",
    " ('Galloping', 'Playing'): 81752,\n",
    " ('Carrying object', 'Galloping', 'Playing'): 89311,\n",
    " ('Eating', 'Standing'): 115980,\n",
    " ('Playing', 'Tugging'): 277766,\n",
    " ('Standing',): 370930,\n",
    " ('Sitting',): 389467,\n",
    " ('Playing',): 398320,\n",
    " ('Lying chest',): 463266,\n",
    " ('Panting', 'Standing'): 538925,\n",
    " ('Lying chest', 'Panting'): 582517,\n",
    " ('Panting', 'Sitting'): 653106,\n",
    " ('Trotting',): 717472,\n",
    " ('Walking',): 750318,\n",
    " ('Sniffing',): 1026178,\n",
    " (): 3649386}\n",
    " '''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a8e954b-384d-446b-adbf-8d6c3325e22f",
   "metadata": {},
   "source": [
    "Now we define the mapping from `observed_labels` to the `beh_labels` we will use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4676d9a6-0057-4073-b285-99b6c57bb16b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We re-code each of the three behaviors according to the following:\n",
    "# This is following \"Dog behaviour classification with movement sensors placed on the harness and the collar\"\n",
    "# Except we include panting, because it is so strongly represented\n",
    "# We also include shaking, because the signal is so strong\n",
    "\n",
    "observed_labels_to_beh_label_first_pass = {'<undefined>' : 'unknown',\n",
    "                                           'Bowing' : 'unknown', \n",
    "                                           'Carrying object' : 'unknown', \n",
    "                                           'Drinking' : 'unknown', \n",
    "                                           'Eating' : 'unknown',\n",
    "                                           'Extra_Synchronization' : 'unknown',\n",
    "                                           'Galloping' : 'galloping',\n",
    "                                           'Jumping' : 'unknown', \n",
    "                                           'Lying chest' : 'lying_chest',\n",
    "                                           'Pacing' : 'unknown',\n",
    "                                           'Panting' : 'panting', # will get incorporated in second pass\n",
    "                                           'Playing' : 'unknown',\n",
    "                                           'Shaking' : 'shaking',\n",
    "                                           'Sitting' : 'sitting',\n",
    "                                           'Sniffing' : 'sniffing',\n",
    "                                           'Standing' : 'standing',\n",
    "                                           'Synchronization' : 'unknown',\n",
    "                                           'Trotting' : 'trotting',\n",
    "                                           'Tugging' : 'unknown', \n",
    "                                           'Walking' : 'walking'}\n",
    "\n",
    "# add the re-coded columns\n",
    "\n",
    "data_full['B1_beh'] = data_full['Behavior_1'].map(observed_labels_to_beh_label_first_pass)\n",
    "data_full['B2_beh'] = data_full['Behavior_2'].map(observed_labels_to_beh_label_first_pass)\n",
    "data_full['B3_beh'] = data_full['Behavior_3'].map(observed_labels_to_beh_label_first_pass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "32a4549b-437b-4b90-99b0-294e936758a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Use these three columns to form single labels.\n",
    "\n",
    "def beh_label_first_pass_to_second_pass(row):\n",
    "    B1 = row['B1_beh']\n",
    "    B2 = row['B2_beh']\n",
    "    B3 = row['B3_beh']\n",
    "    all_beh = set([B1, B2, B3])\n",
    "    all_beh.discard('unknown')\n",
    "    if len(all_beh) == 0:\n",
    "        return 'unknown'\n",
    "    elif len(all_beh) > 2:\n",
    "        return 'unknown'\n",
    "    elif 'panting' in all_beh:\n",
    "        if 'standing' in all_beh:\n",
    "            return 'panting_standing'\n",
    "        elif 'sitting' in all_beh:\n",
    "            return 'panting_sitting'\n",
    "        elif 'lying_chest' in all_beh:\n",
    "            return 'panting_lying_chest'\n",
    "        else:\n",
    "            return 'unknown'\n",
    "    elif len(all_beh) == 1:\n",
    "        return all_beh.pop()\n",
    "    else:\n",
    "        return 'unknown'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0253478f-104d-4e69-a09c-93f4107b59e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert to final beh_labels\n",
    "\n",
    "data_full['beh_label'] = data_full.apply(beh_label_first_pass_to_second_pass, axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "444a3dc3-dfb0-4907-833e-8caf3eb4d88d",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Integer codes for specific behaviors\n",
    "\n",
    "# list of behaviors (from Jeantet et al 2020)\n",
    "beh_names = set(data_full['beh_label'])\n",
    "beh_names.discard('unknown')\n",
    "beh_names = sorted(beh_names)\n",
    "beh_names.insert(0, 'unknown')\n",
    "\n",
    "dataset_metadata['label_names'] = beh_names\n",
    "\n",
    "beh_str_to_int = {name : i for i, name in enumerate(beh_names)}\n",
    "beh_int_to_str = {i : name for i, name in enumerate(beh_names)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "1ed7a11e-5510-4010-89d1-ccf095e2d83a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "unknown                4533143\n",
       "sniffing               1026178\n",
       "walking                 783035\n",
       "trotting                773879\n",
       "panting_sitting         653201\n",
       "panting_lying_chest     582691\n",
       "lying_chest             547211\n",
       "panting_standing        539418\n",
       "standing                488292\n",
       "sitting                 466915\n",
       "galloping               174926\n",
       "shaking                  42179\n",
       "Name: beh_label, dtype: int64"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What are the observed labels?\n",
    "\n",
    "data_full['beh_label'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1d3e7a7f-39b8-4765-bc74-414e5a951dd6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['DogID', 'TestNum', 't_sec', 'ABack_x', 'ABack_y', 'ABack_z', 'ANeck_x',\n",
       "       'ANeck_y', 'ANeck_z', 'GBack_x', 'GBack_y', 'GBack_z', 'GNeck_x',\n",
       "       'GNeck_y', 'GNeck_z', 'Task', 'Behavior_1', 'Behavior_2', 'Behavior_3',\n",
       "       'PointEvent', 'clip_id', 'B1_beh', 'B2_beh', 'B3_beh', 'beh_label'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## What are the annotation names in the data originally?\n",
    "\n",
    "data_full.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f438d48f-0596-4a58-8669-358c9a4cec2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "## clip_data column names\n",
    "\n",
    "clip_column_names = ['AccX_Back', 'AccY_Back', 'AccZ_Back', 'AccX_Neck',\n",
    "       'AccY_Neck', 'AccZ_Neck', 'GyrX_Back', 'GyrY_Back', 'GyrZ_Back', 'GyrX_Neck',\n",
    "       'GyrY_Neck', 'GyrZ_Neck', 'individual_id', 'label']\n",
    "dataset_metadata['clip_column_names'] = clip_column_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "a560ecfd-2ff8-4aff-a58c-76bb31200b86",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Save off dataset level metadata\n",
    "\n",
    "dataset_metadata_fp = os.path.join(formatted_data_dir, 'dataset_metadata.yaml')\n",
    "\n",
    "with open(dataset_metadata_fp, 'w') as file:\n",
    "    yaml.dump(dataset_metadata, file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f964b042-2a2b-4690-bdd1-1685991ca77f",
   "metadata": {},
   "source": [
    "## Format Clip Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "226d618a-e1ac-4b91-993b-2c1b50e1f7a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 62/62 [03:41<00:00,  3.57s/it]\n"
     ]
    }
   ],
   "source": [
    "# For each clip, create and save the data in the correct format\n",
    "\n",
    "total_dur_samples = 0\n",
    "total_annotation_dur_samples = 0\n",
    "\n",
    "for clip_id in tqdm.tqdm(clip_ids):\n",
    "    # subselect features\n",
    "    clip_df = data_full[data_full['clip_id'] == clip_id]\n",
    "    clip_dur_samples = len(clip_df)\n",
    "    \n",
    "    total_dur_samples += clip_dur_samples\n",
    "    \n",
    "    per_frame_AccX_Back = np.expand_dims(np.array(clip_df['ABack_x']), axis = -1)\n",
    "    per_frame_AccY_Back = np.expand_dims(np.array(clip_df['ABack_y']), axis = -1)\n",
    "    per_frame_AccZ_Back = np.expand_dims(np.array(clip_df['ABack_z']), axis = -1)\n",
    "    \n",
    "    per_frame_AccX_Neck = np.expand_dims(np.array(clip_df['ANeck_x']), axis = -1)\n",
    "    per_frame_AccY_Neck = np.expand_dims(np.array(clip_df['ANeck_y']), axis = -1)\n",
    "    per_frame_AccZ_Neck = np.expand_dims(np.array(clip_df['ANeck_z']), axis = -1)\n",
    "    \n",
    "    per_frame_GyrX_Back = np.expand_dims(np.array(clip_df['GBack_x']), axis = -1)\n",
    "    per_frame_GyrY_Back = np.expand_dims(np.array(clip_df['GBack_y']), axis = -1)\n",
    "    per_frame_GyrZ_Back = np.expand_dims(np.array(clip_df['GBack_z']), axis = -1)\n",
    "    \n",
    "    per_frame_GyrX_Neck = np.expand_dims(np.array(clip_df['GNeck_x']), axis = -1)\n",
    "    per_frame_GyrY_Neck = np.expand_dims(np.array(clip_df['GNeck_y']), axis = -1)\n",
    "    per_frame_GyrZ_Neck = np.expand_dims(np.array(clip_df['GNeck_z']), axis = -1)\n",
    "    \n",
    "    per_frame_annotations = np.expand_dims(np.array(clip_df['beh_label'].map(lambda x: beh_str_to_int[x])), axis = -1)\n",
    "    \n",
    "    clip_annotation_dur_samples = sum(per_frame_annotations > 0)\n",
    "    total_annotation_dur_samples += clip_annotation_dur_samples\n",
    "    \n",
    "    individual_id = clip_id_to_individual_id[clip_id]\n",
    "    per_frame_individual_id = np.full_like(per_frame_annotations, individual_id)\n",
    "    \n",
    "    clip_data = np.concatenate([per_frame_AccX_Back,\n",
    "                                per_frame_AccY_Back,\n",
    "                                per_frame_AccZ_Back,\n",
    "                                per_frame_AccX_Neck,\n",
    "                                per_frame_AccY_Neck,\n",
    "                                per_frame_AccZ_Neck,\n",
    "                                per_frame_GyrX_Back,\n",
    "                                per_frame_GyrY_Back,\n",
    "                                per_frame_GyrZ_Back,\n",
    "                                per_frame_GyrX_Neck,\n",
    "                                per_frame_GyrY_Neck,\n",
    "                                per_frame_GyrZ_Neck,\n",
    "                                per_frame_individual_id, \n",
    "                                per_frame_annotations], axis = 1)\n",
    "    \n",
    "    clip_data_fp = os.path.join(clip_data_dir, clip_id + '.csv')\n",
    "    np.savetxt(clip_data_fp, clip_data, delimiter=\",\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "65879013-2f4e-4348-acca-9d9b5ec54f73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total duration is 106110.680000 seconds, i.e. 29.475189 hours\n",
      "total annotation duration is 60779.250000 seconds, i.e. 16.883125 hours\n"
     ]
    }
   ],
   "source": [
    "total_dur_sec = total_dur_samples / sr\n",
    "total_dur_hours = total_dur_sec / 3600\n",
    "print(\"total duration is %f seconds, i.e. %f hours\" % (total_dur_sec, total_dur_hours))\n",
    "\n",
    "total_annotation_dur_sec = total_annotation_dur_samples / sr\n",
    "total_annotation_dur_hours = total_annotation_dur_sec / 3600\n",
    "print(\"total annotation duration is %f seconds, i.e. %f hours\" % (total_annotation_dur_sec, total_annotation_dur_hours))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9844300-e520-49a9-b975-210caa20a21f",
   "metadata": {},
   "source": [
    "## Check it all looks ok"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "717812e0-af4e-4bd0-96db-5ce83ece61c3",
   "metadata": {},
   "outputs": [],
   "source": [
    "clip_id = clip_ids[4]\n",
    "clip_data_fp = os.path.join(clip_data_dir, clip_id + '.csv')\n",
    "data = np.genfromtxt(clip_data_fp, delimiter = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "77164f71-4257-43b1-ae76-49f1438c836e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(185904, 14)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b1d243b7-ec2e-4bc5-8239-400cc7241953",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(np.shape(data)[1]):\n",
    "    plt.plot(data[:50000, i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ff4e9c59-9f68-4ee9-9cfd-0d1ca21b5900",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7feb1175c490>]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(data[:, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb4a8985-1424-4ce0-b30b-1210f3df2e99",
   "metadata": {},
   "source": [
    "## Plot Dataset Summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "fd033c1a-1f97-4884-b232-84434ef336d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Count class representation\n",
    "\n",
    "beh_names = dataset_metadata['label_names']\n",
    "label_count = {fold : {name : 0 for name in beh_names} for fold in range(n_folds)}\n",
    "\n",
    "for clip_id in clip_ids:\n",
    "    clip_data_fp = os.path.join(clip_data_dir, clip_id + '.csv')\n",
    "    data = pd.read_csv(clip_data_fp, delimiter = ',', header = None)\n",
    "    counts = data[data.keys()[-1]].astype(int).value_counts()\n",
    "    for key in counts.keys():\n",
    "        name = beh_names[key]\n",
    "        for fold in range(n_folds):\n",
    "            if clip_id in dataset_metadata['clip_ids_per_fold'][fold]:\n",
    "                label_count[fold][name] += counts[key]\n",
    "                \n",
    "label_perc = {fold : {name : 0 for name in beh_names[1:]} for fold in range(n_folds)}\n",
    "\n",
    "for name in beh_names[1:]:\n",
    "    for fold in range(n_folds):\n",
    "        label_perc[fold][name] = float(label_count[fold][name] / sum([label_count[fold][j] for j in beh_names[1:]]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "995f092b-89cb-4d31-9ac9-8f385c7bfddb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot class representation\n",
    "\n",
    "# https://gist.github.com/thriveth/8560036#file-cbcolors-py\n",
    "CB_color_cycle = ['#377eb8', '#ff7f00', '#4daf4a',\n",
    "                  '#f781bf', '#a65628', '#984ea3',\n",
    "                  '#999999', '#e41a1c', '#dede00']\n",
    "\n",
    "keys = np.arange(len(beh_names))[1:]\n",
    "offset = 0.1\n",
    "width = 0.1\n",
    "plt.figure(figsize=(8, 6), dpi=80)\n",
    "\n",
    "for fold in range(n_folds):\n",
    "    current_offset = -(fold - n_folds // 2)*offset\n",
    "    plt.barh(keys +current_offset, [label_perc[fold][beh_names[key]] for key in keys], height=width, align='center', label = fold, color = CB_color_cycle[fold])\n",
    "    \n",
    "plt.title(\"Class representation across folds\")\n",
    "plt.yticks(keys, beh_names[1:], fontsize = 7, rotation = 60)\n",
    "plt.xlabel('Percent of known labels')\n",
    "plt.legend()\n",
    "target_fp = os.path.join(formatted_data_dir, 'class_rep.svg')\n",
    "\n",
    "plt.savefig(target_fp, format='svg')\n",
    "plt.show()\n",
    "\n",
    "numerical_target_fp = os.path.join(formatted_data_dir, 'class_rep.yaml')\n",
    "with open(numerical_target_fp, 'w') as file:\n",
    "    yaml.dump(label_perc, file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0a77ecb1-0267-4a76-b651-0d1d9a2aec37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x144 with 5 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Pie chart, of known vs unknown samples \n",
    "\n",
    "labels = 'Known', 'Unknown'\n",
    "sizes = {fold : [sum([label_count[fold][j] for j in beh_names[1:]]), label_count[fold]['unknown']] for fold in range(n_folds)}\n",
    "# train_sizes = [sum([train_label_count[j] for j in beh_names[1:]]), train_label_count['unknown']]\n",
    "# val_sizes = [sum([val_label_count[j] for j in beh_names[1:]]), val_label_count['unknown']]\n",
    "# test_sizes = [sum([test_label_count[j] for j in beh_names[1:]]), test_label_count['unknown']]\n",
    "\n",
    "fig, ax = plt.subplots(1,n_folds, figsize = (3*n_folds,2))\n",
    "\n",
    "for fold in range(n_folds):\n",
    "    ax[fold].pie(sizes[fold], labels=labels, autopct='%1.1f%%', startangle=90)\n",
    "    ax[fold].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "    ax[fold].set_title(fold)\n",
    "\n",
    "target_fp = os.path.join(formatted_data_dir, 'perc_known.svg')\n",
    "\n",
    "plt.savefig(target_fp, format='svg')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0051533e-bc12-4349-bc68-09a2962e40e0",
   "metadata": {},
   "source": [
    "## Temporal Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "abc1cef3-6402-435e-8c96-51356181473b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 62/62 [00:32<00:00,  1.91it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean overall label duration is 15.484 seconds\n",
      "Re-saving metadata to /home/jupyter/behavior_data_local/data/formatted/vehkaoja_dogs/dataset_metadata.yaml\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "####################################\n",
    "infill_max_dur_sec = 0 # If annotations are nnnnn0000000nnnnn, where 0=unknown, do we fill in 0's with n's?\n",
    "####################################\n",
    "\n",
    "# This cell runs almost as a stand alone, but requires the first few cells of this notebook to be run first\n",
    "\n",
    "import tqdm\n",
    "from pathlib import Path\n",
    "\n",
    "dataset_metadata_fp = os.path.join(formatted_data_dir, 'dataset_metadata.yaml')\n",
    "\n",
    "with open(dataset_metadata_fp, 'r') as file:\n",
    "    metadata = yaml.safe_load(file)\n",
    "\n",
    "clip_fps = list(Path(clip_data_dir).glob('*.csv'))\n",
    "\n",
    "def create_list_of_durations(x, infill_max_dur_sec, samplerate, unknown_value = 0):\n",
    "    # First pass: create a list of label durations, together with a list of the associated classes\n",
    "    current_value = 0\n",
    "    current_dur = 0\n",
    "    list_of_durs = []\n",
    "    list_of_labels = []\n",
    "    for i in x:\n",
    "        if i == current_value:\n",
    "            current_dur += 1\n",
    "        elif i != current_value:\n",
    "            list_of_durs.append(current_dur / samplerate)\n",
    "            list_of_labels.append(current_value)\n",
    "            current_dur = 1\n",
    "            current_value = i\n",
    "            \n",
    "    list_of_durs.append(current_dur)\n",
    "    list_of_labels.append(current_value)\n",
    "            \n",
    "    # repeatedly merge similar labels if they are seperated by unknowns of short duration\n",
    "    # This is mainly to deal with duty cycling of observations\n",
    "    infill_max_dur_samples = int(infill_max_dur_sec * samplerate)\n",
    "    \n",
    "    if list_of_labels[0] == unknown_value:\n",
    "        del list_of_labels[0]\n",
    "        del list_of_durs[0]\n",
    "        \n",
    "    if list_of_labels[-1] == unknown_value:\n",
    "        del list_of_labels[-1]\n",
    "        del list_of_durs[-1]\n",
    "    \n",
    "    j = 1\n",
    "    while j<len(list_of_labels)-1:\n",
    "        if list_of_labels[j] != unknown_value:\n",
    "            j+= 1\n",
    "        elif list_of_labels[j-1] == list_of_labels[j+1] and list_of_durs[j] < infill_max_dur_samples:\n",
    "            # merge if it's a short interval of unknowns between two of the same label\n",
    "            list_of_durs[j-1] += list_of_durs[j+1]\n",
    "            del list_of_durs[j+1]\n",
    "            del list_of_durs[j]\n",
    "            del list_of_labels[j+1]\n",
    "            del list_of_labels[j]\n",
    "        else:\n",
    "            # otherwise, drop the unknown segment\n",
    "            del list_of_durs[j]\n",
    "            del list_of_labels[j]\n",
    "\n",
    "    return list_of_labels, list_of_durs # list of annotation durations, in samples.\n",
    "                             \n",
    "durs_sec_by_individual = {i : [] for i in metadata['individual_ids']}\n",
    "overall_durs_sec = []\n",
    "    \n",
    "for fp in tqdm.tqdm(clip_fps):\n",
    "    clip_id = fp.stem\n",
    "    individual_id = metadata['clip_id_to_individual_id'][clip_id]\n",
    "    clip_annotations = list(pd.read_csv(fp, header = None).values[:, -1])\n",
    "    l, d = create_list_of_durations(clip_annotations, infill_max_dur_sec, metadata['sr'])\n",
    "    durs_sec_by_individual[individual_id].extend(d)\n",
    "    overall_durs_sec.extend(d)\n",
    "    \n",
    "mean_dur_sec_by_individual = {i : float(np.mean(durs_sec_by_individual[i])) for i in durs_sec_by_individual}\n",
    "mean_overall_dur_sec = float(np.mean(overall_durs_sec))\n",
    "\n",
    "metadata['mean_dur_sec_by_individual'] = mean_dur_sec_by_individual\n",
    "metadata['mean_overall_dur_sec'] = mean_overall_dur_sec\n",
    "\n",
    "print(\"Mean overall label duration is %0.3f seconds\" % mean_overall_dur_sec)\n",
    "\n",
    "print(\"Re-saving metadata to %s\" % str(dataset_metadata_fp))\n",
    "\n",
    "with open(dataset_metadata_fp, 'w') as file:\n",
    "    yaml.dump(metadata, file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "914d611c-1f87-4347-a06d-d9128f7f4cb1",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "pytorch-gpu.1-11.m94",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/pytorch-gpu.1-11:m94"
  },
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}