notebooks/mBrain/C5.1_Label_off_wrist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook demonstrates how the `off-wrist` periods were labeled and serve as a \n",
    "<br>\n",
    "generic approach to label intervals of interest in large time series datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from datetime import datetime\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import plotly.graph_objects as go\n",
    "from functional import seq\n",
    "from IPython.display import display\n",
    "from plotly.subplots import make_subplots\n",
    "from plotly_resampler import FigureWidgetResampler\n",
    "from plotly_resampler.aggregation import MedDiffGapHandler, MinMaxLTTB\n",
    "\n",
    "pd.options.display.max_columns = None\n",
    "pd.options.display.max_colwidth = None\n",
    "\n",
    "sys.path.append(\"../..\")\n",
    "from code_utils.path_conf import mbrain_metadata_path, processed_mbrain_path\n",
    "\n",
    "USE_PNG = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Widgets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. File selection widgets\n",
    "# ---- user selection\n",
    "user_widget = widgets.Dropdown(\n",
    "    options=sorted(\n",
    "        seq(mbrain_metadata_path.iterdir())\n",
    "        .filter(lambda x: x.is_dir())\n",
    "        .map(lambda x: x.name)\n",
    "    )\n",
    ")\n",
    "\n",
    "# ---- time range selection\n",
    "t_start_widget = widgets.Dropdown(options=[])\n",
    "t_end_widget = widgets.Dropdown(options=[])\n",
    "\n",
    "def update_time_range_widget(change):\n",
    "    min_time, max_time = (\n",
    "        pd.to_datetime(\n",
    "            pd.read_csv(\n",
    "                mbrain_metadata_path.joinpath(user_widget.value, \"event_dump.csv\")\n",
    "            )[\"time\"]\n",
    "            .quantile([0, 1])\n",
    "            .values,\n",
    "            unit=\"ms\",\n",
    "        )\n",
    "        .tz_localize(\"utc\")\n",
    "        .tz_convert(\"Europe/Brussels\")\n",
    "    )\n",
    "\n",
    "    min_time, max_time = min_time.date(), max_time.date()\n",
    "\n",
    "    t_end_widget.options = (\n",
    "        seq(\n",
    "            pd.date_range(\n",
    "                min_time + pd.Timedelta(days=1),\n",
    "                max_time + pd.Timedelta(days=2),\n",
    "                freq=\"D\",\n",
    "            )\n",
    "        )\n",
    "        .map(lambda x: x.strftime(\"%Y_%m_%d\"))\n",
    "        .to_list()\n",
    "    )\n",
    "    t_end_widget.value = t_end_widget.options[-1]\n",
    "\n",
    "    t_start_widget.options = (\n",
    "        seq(pd.date_range(min_time - pd.Timedelta(days=1), max_time, freq=\"D\"))\n",
    "        .map(lambda x: x.strftime(\"%Y_%m_%d\"))\n",
    "        .to_list()\n",
    "    )\n",
    "\n",
    "# add observer to user widget to update both time range widgets\n",
    "user_widget.observe(update_time_range_widget, \"value\")\n",
    "\n",
    "\n",
    "def update_t_end_widget(change):\n",
    "    if t_start_widget.value is None or t_end_widget.value is None:\n",
    "        return\n",
    "    t_start_date = datetime.strptime(t_start_widget.value, \"%Y_%m_%d\")\n",
    "    t_end_date = datetime.strptime(t_end_widget.value, \"%Y_%m_%d\")\n",
    "\n",
    "    if t_start_date >= t_end_date:\n",
    "        t_end_date = t_start_date + pd.Timedelta(days=1)\n",
    "        t_end_widget.value = t_end_date.strftime(\"%Y_%m_%d\")\n",
    "\n",
    "\n",
    "# add observer to t_start_widget to update t_end_widget\n",
    "t_start_widget.observe(update_t_end_widget, \"value\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The dashboard"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# utility functions for the dashboard\n",
    "def _filter_glob_dates(glob, t_start: pd.Timestamp, t_end: pd.Timestamp):\n",
    "    return (\n",
    "        seq(glob)\n",
    "        .filter(\n",
    "            lambda x: t_start\n",
    "            <= datetime.strptime(\"_\".join(x.stem.split(\"_\")[-3:]), \"%Y_%m_%d\")\n",
    "            <= t_end\n",
    "        )\n",
    "        .to_list()\n",
    "    )\n",
    "\n",
    "\n",
    "def get_user_data_interval(user, t_start, t_end, modality, empatica=True):\n",
    "    glob = processed_mbrain_path.glob(f\"{user}*.E4*/{modality}*.parquet\")\n",
    "    if not empatica:\n",
    "        glob = set(processed_mbrain_path.glob(f\"{user}/{modality}*.parquet\")) - set(\n",
    "            glob\n",
    "        )\n",
    "    glob = _filter_glob_dates(glob, t_start, t_end)\n",
    "    if len(glob):\n",
    "        out = pd.concat([pd.read_parquet(f) for f in glob])\n",
    "        if \"timestamp\" in out.columns:\n",
    "            out = out.set_index(\"timestamp\")\n",
    "        out.sort_index(inplace=True)\n",
    "        return out[~out.index.duplicated(keep=\"first\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the label config\n",
    "label_dict = {\n",
    "    \"sleep-period\": {\n",
    "        \"type\": \"x-range\",\n",
    "        \"plt_kwargs\": {\"line_width\": 0.5, \"fillcolor\": \"green\", \"opacity\": 0.15},\n",
    "    },\n",
    "    \"wake-up\": {\n",
    "        \"type\": \"x-range\",\n",
    "        \"plt_kwargs\": {\"line_width\": 0.5, \"fillcolor\": \"purple\", \"opacity\": 0.15},\n",
    "    },\n",
    "    \"off-wrist\": {\n",
    "        \"type\": \"x-range\",\n",
    "        \"plt_kwargs\": {\"line_width\": 0.5, \"fillcolor\": \"red\", \"opacity\": 0.15},\n",
    "    },\n",
    "    \"snooze\": {\n",
    "        \"type\": \"x-range\",\n",
    "        \"plt_kwargs\": {\"line_width\": 0.5, \"fillcolor\": \"gray\", \"opacity\": 0.15},\n",
    "    },\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2bc1f1c46568488986a14cb3028c83ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='user_id', options=('MBRAIN21-001', 'MBRAIN21-002', 'MBRAIN21-003',…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fw_fig = FigureWidgetResampler(default_downsampler=MinMaxLTTB(parallel=True))\n",
    "meta_cols = [\"label\", \"start\", \"end\", \"user\"]\n",
    "try:\n",
    "    len(meta_list)\n",
    "    df_meta = pd.DataFrame(meta_list, columns=meta_cols)\n",
    "except NameError:\n",
    "    df_meta = pd.read_csv(mbrain_metadata_path / \"off_wrist_labeled.csv\")\n",
    "    meta_list = list(df_meta.values)\n",
    "\n",
    "prev_x = []\n",
    "point_list = []\n",
    "\n",
    "# Create a label selector\n",
    "label_selector = widgets.Dropdown()\n",
    "label_selector.options = list(label_dict.keys())\n",
    "\n",
    "\n",
    "def update_point(trace, points, selector):\n",
    "    if not len(points.xs):\n",
    "        return\n",
    "\n",
    "    # print(trace, points, selector)\n",
    "    global prev_x, point_list, meta_list, fw_fig\n",
    "    config = label_dict[label_selector.value]\n",
    "\n",
    "    if config.get(\"type\", \"\") == \"x-range\":\n",
    "        prev_x.append(points.xs[0])\n",
    "        if len(prev_x) == 2:\n",
    "            fw_fig.add_vrect(prev_x[0], prev_x[1], **config.get(\"plt_kwargs\", {}))\n",
    "            # add a row to df_meta\n",
    "            meta_list.append(\n",
    "                [\n",
    "                    label_selector.value,\n",
    "                    prev_x[0],\n",
    "                    prev_x[1],\n",
    "                    user_widget.value,\n",
    "                ]\n",
    "            )\n",
    "            prev_x = []\n",
    "\n",
    "\n",
    "# ignore jupyter_client warnings\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\", module=\"jupyter_client\")\n",
    "warnings.filterwarnings(\"ignore\", module=\"pandas\")\n",
    "\n",
    "\n",
    "@widgets.interact_manual\n",
    "def test(\n",
    "    user_id=user_widget,\n",
    "    t_start=t_start_widget,\n",
    "    t_end=t_end_widget,\n",
    "    label=label_selector,\n",
    "):\n",
    "    \"\"\"The main function to display the data\"\"\"\n",
    "    global fw_fig, df_meta\n",
    "    t_start = pd.Timestamp(datetime.strptime(t_start, \"%Y_%m_%d\"))\n",
    "    t_end = pd.Timestamp(datetime.strptime(t_end, \"%Y_%m_%d\"))\n",
    "\n",
    "    # fmt: off\n",
    "    # 1. Check if the data is long enough\n",
    "    e4_acc = get_user_data_interval(user_id, t_start, t_end, \"acc\").add_prefix( \"e4_\")\n",
    "    if not len(e4_acc):\n",
    "        print(\"data is too short, returning\")\n",
    "        print(f\"{e4_acc.shape[0]:,}\")\n",
    "        return\n",
    "\n",
    "    # 2. Create the figure\n",
    "    n_rows = 3\n",
    "    fw_fig = FigureWidgetResampler(\n",
    "        make_subplots(rows=n_rows, cols=1, shared_xaxes=True, vertical_spacing=0.08,\n",
    "                      specs=np.array([[{\"secondary_y\": True}] * n_rows]).reshape(-1, 1).tolist(),\n",
    "                      subplot_titles=['E4: skin temperature & skin conductance', 'E4: ACC',\n",
    "                    #    'Phone: accelerometer-x & E4: BVP + <b>Annotations</b>']\n",
    "                       'E4: BVP + <b>Annotations</b>']\n",
    "                      ), default_n_shown_samples=1000)\n",
    "\n",
    "    # 3. Add the data to the figure\n",
    "    e4_tmp = get_user_data_interval(user_id, t_start, t_end, \"tmp\").add_prefix( \"e4_\")\n",
    "    e4_eda = get_user_data_interval(user_id, t_start, t_end, \"gsr\").add_prefix( \"e4_\")\n",
    "    e4_bvp = get_user_data_interval(user_id, t_start, t_end, \"bvp\").add_prefix( \"e4_\")\n",
    "    for c in e4_eda.columns:\n",
    "        fw_fig.add_trace(go.Scattergl(name=c, opacity=.5, line_width=0, fill='tozeroy', line_shape='vh', legend='legend1'), \n",
    "        gap_handler=MedDiffGapHandler(fill_value=0), secondary_y=True, hf_x=e4_eda.index, hf_y=e4_eda[c], row=1, col=1)\n",
    "    for c in e4_tmp.columns:\n",
    "        fw_fig.add_trace(go.Scattergl(name=c, legend='legend1'), hf_x=e4_tmp.index, hf_y=e4_tmp[c], row=1, col=1)\n",
    "    for c in e4_bvp.columns:\n",
    "        fw_fig.add_trace(go.Scattergl(name=c, legend='legend3'), secondary_y=False, hf_x=e4_bvp.index, hf_y=e4_bvp[c], row=3, col=1)\n",
    "\n",
    "    # fix the y-range of the skin conductance data\n",
    "    fw_fig.update_yaxes(range=[0, 1.5], row=1, col=1, secondary_y=True)\n",
    "    for c in list(set(e4_acc.columns)):\n",
    "        fw_fig.add_trace(go.Scattergl(name=c, legend='legend2', opacity=0.7), hf_x=e4_acc.index, hf_y=e4_acc[c] / 64, row=2, col=1)\n",
    "\n",
    "    # specify the layout and hovermode (vertical dashed line)\n",
    "    fw_fig.update_layout(template=\"plotly_white\", height=650, hovermode=\"x unified\")\n",
    "    fw_fig.update_layout(margin=dict(l=0, r=0, t=40, b=20),)\n",
    "    fw_fig.update_traces(xaxis='x3')\n",
    "\n",
    "    # shade the weekends (grey)\n",
    "    for date in pd.date_range(t_start, t_end, freq='D'):\n",
    "        if date.dayofweek == 5:\n",
    "            fw_fig.add_vrect(date, date + pd.Timedelta(days=2), fillcolor='gray', opacity=0.15, line_color='black', row=n_rows, col=1)\n",
    "\n",
    "\n",
    "    # add update_point callback to the movement data (row 2)\n",
    "    for trace in fw_fig.data:\n",
    "        if 'e4_acc' in trace.name.lower():\n",
    "            trace.on_click(update_point)\n",
    "            break\n",
    "\n",
    "    # 4. Add existing annotations\n",
    "    if len(meta_list):\n",
    "        df_meta = pd.DataFrame(meta_list, columns=meta_cols[:])\n",
    "    for _, r in df_meta[(df_meta.user == user_id)].iterrows():\n",
    "        fw_fig.add_vrect(r.start, r.end, **label_dict[r.label][\"plt_kwargs\"], row=n_rows, col=1)\n",
    "    if USE_PNG:\n",
    "        fw_fig.show(renderer=\"png\", width=1500, height=800)\n",
    "    display(fw_fig)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>label</th>\n",
       "      <th>start</th>\n",
       "      <th>end</th>\n",
       "      <th>user</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-09-04 09:42:30.986</td>\n",
       "      <td>2022-09-04 09:52:44.235</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-09-13 13:20:33.472</td>\n",
       "      <td>2022-09-13 14:20:47.941</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-09-14 09:13:33.535</td>\n",
       "      <td>2022-09-14 09:28:51.535</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-09-14 14:55:57.598</td>\n",
       "      <td>2022-09-14 15:32:47.722</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-09-15 07:00:40.692</td>\n",
       "      <td>2022-09-15 07:25:51.66</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>130</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-11-03 17:10:21.736</td>\n",
       "      <td>2022-11-03 17:45:56.615</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>131</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2022-11-15 15:58:16.782</td>\n",
       "      <td>2022-11-15 16:13:09.917</td>\n",
       "      <td>MBRAIN21-002</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>132</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2021-09-03 16:10:35.818</td>\n",
       "      <td>2021-09-03 16:11:45.509</td>\n",
       "      <td>MBRAIN21-003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>133</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2021-10-31 12:59:23.083</td>\n",
       "      <td>2021-10-31 12:59:39.427</td>\n",
       "      <td>MBRAIN21-003</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>134</th>\n",
       "      <td>off-wrist</td>\n",
       "      <td>2021-10-03 19:53:25.509</td>\n",
       "      <td>2021-10-03 19:53:57.292</td>\n",
       "      <td>MBRAIN21-004</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>135 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "         label                    start                      end          user\n",
       "0    off-wrist  2022-09-04 09:42:30.986  2022-09-04 09:52:44.235  MBRAIN21-002\n",
       "1    off-wrist  2022-09-13 13:20:33.472  2022-09-13 14:20:47.941  MBRAIN21-002\n",
       "2    off-wrist  2022-09-14 09:13:33.535  2022-09-14 09:28:51.535  MBRAIN21-002\n",
       "3    off-wrist  2022-09-14 14:55:57.598  2022-09-14 15:32:47.722  MBRAIN21-002\n",
       "4    off-wrist  2022-09-15 07:00:40.692   2022-09-15 07:25:51.66  MBRAIN21-002\n",
       "..         ...                      ...                      ...           ...\n",
       "130  off-wrist  2022-11-03 17:10:21.736  2022-11-03 17:45:56.615  MBRAIN21-002\n",
       "131  off-wrist  2022-11-15 15:58:16.782  2022-11-15 16:13:09.917  MBRAIN21-002\n",
       "132  off-wrist  2021-09-03 16:10:35.818  2021-09-03 16:11:45.509  MBRAIN21-003\n",
       "133  off-wrist  2021-10-31 12:59:23.083  2021-10-31 12:59:39.427  MBRAIN21-003\n",
       "134  off-wrist  2021-10-03 19:53:25.509  2021-10-03 19:53:57.292  MBRAIN21-004\n",
       "\n",
       "[135 rows x 4 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.DataFrame(meta_list, columns=meta_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# meta_list = meta_list[:-1]\n",
    "# pd.DataFrame(meta_list, columns=meta_cols).to_csv('tmp_meta.csv')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "mbrain-data-analysis-hDKBtCaA-py3.8",
   "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.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}