When Did I.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Seizure Diary Notebook\n",
    " Import Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Parse Seizure Diary File and plot data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "trusted": true
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4d24a4727bf64a69a98049eed3050a73",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(DatePicker(value=datetime.date(2024, 1, 16), description='Start Date'), SelectMultiple(d…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "import datetime\n",
    "import ipywidgets as widgets\n",
    "import warnings\n",
    "def multi(a, b, c, d, f, g):\n",
    "    \n",
    "    # Read the data\n",
    "    df = pd.read_csv('Pruned_When-Did-I.csv', index_col=2, parse_dates=True)\n",
    "    df = df.loc[df['Note'] != \"NHNN VT\"]  # Exclude certain rows\n",
    "\n",
    "    # Identify occurrences of 'drug changes'\n",
    "    specific_action_df = df[df['Action'] == 'Change Cenobamate']\n",
    "    specific_action_df1 = df[df['Action'] == 'Change Vimpat dose']\n",
    "    specific_action_df2 = df[df['Action'] == 'Reduce my lamotrogine last']\n",
    "    specific_action_df3 = df[df['Action'] == 'Reduce Clobazam']\n",
    "    specific_action_df4 = df[df['Action'] == 'Need Rescue meds']\n",
    "    specific_action_df5 = df[df['Action'] == 'Change Perampanel ']\n",
    "    \n",
    "    # Identify occurrences of seizure types\n",
    "    types = list(b)\n",
    "    df = df[df['Action'].isin(types)]\n",
    "\n",
    "    # Convert the datetime column to a pandas datetime object\n",
    "    df['datetime'] = df.index\n",
    "    df['hour'] = df['datetime'].dt.hour\n",
    "    df['dayofweek'] = df['datetime'].dt.dayofweek\n",
    "\n",
    "    # Filter by date range\n",
    "    startdate = pd.to_datetime(a)\n",
    "    enddate = pd.to_datetime(c)\n",
    "    df = df[(df['datetime'] >= startdate) & (df['datetime'] < enddate)]\n",
    "\n",
    "    # Create a complete range of periods\n",
    "    if d == 'Weekly':\n",
    "        period_freq = 'W'\n",
    "        label_format = '%b %Y'  # Month Year format\n",
    "    elif d=='Monthly':\n",
    "        period_freq = 'M'\n",
    "        label_format = '%b %Y'\n",
    "    elif d=='Daily':\n",
    "        period_freq = 'D'\n",
    "        label_format = '%b %Y'\n",
    "\n",
    "    all_periods = pd.period_range(start=startdate, end=enddate, freq=period_freq)\n",
    "\n",
    "    # Group the data by period\n",
    "    df['period'] = df['datetime'].dt.to_period(freq=period_freq)\n",
    "    grouped = df.groupby('period').apply(lambda x: np.histogram(x['hour'], bins=range(25))[0])\n",
    "    grouped_df = pd.DataFrame(grouped.tolist(), index=grouped.index)\n",
    "\n",
    "    # Merge with the complete periods\n",
    "    complete_grouped_df = grouped_df.reindex(all_periods, fill_value=0)\n",
    "\n",
    "    # Visualization\n",
    "    fig = plt.figure(figsize=(12, 9))\n",
    "    gs = gridspec.GridSpec(2, 2, height_ratios=[1, 4], width_ratios=[20, 1])\n",
    "\n",
    "    # Axes for the histogram\n",
    "    ax0 = plt.subplot(gs[0, 0])\n",
    "\n",
    "    # Axes for the heatmap\n",
    "    ax1 = plt.subplot(gs[1, 0])\n",
    "\n",
    "    # Axes for the colorbar (aligned with the heatmap)\n",
    "    ax2 = plt.subplot(gs[1, 1])\n",
    "\n",
    "    # Plotting Histogram for Counts\n",
    "    ax0.bar(complete_grouped_df.index.astype(str), complete_grouped_df.sum(axis=1), color='blue')\n",
    "    ax0.set_title(f'{d} Seizure Count', fontsize=14)\n",
    "    ax0.set_xticklabels([])  # Remove x-tick labels\n",
    "    ax0.set_ylabel('Count')\n",
    "    ax0.set_xlim([-0.5, len(complete_grouped_df.index) - 0.5])  # Align x-axis with heatmap\n",
    "\n",
    "    # Plot Heatmap\n",
    "\n",
    "    im = ax1.imshow(complete_grouped_df.T, aspect='auto', cmap='inferno',vmin=-0, vmax=3)  # Transpose the DataFrame\n",
    "    ax1.set_title(f'{d} Seizure Counts by Hour of Day',fontsize=14)\n",
    "    ax1.set_xlabel('Period')\n",
    "\n",
    "\n",
    "    # Only label the first week of each month\n",
    "    if d == 'Weekly':\n",
    "        labels = [''] * len(all_periods)\n",
    "        previous_month = None\n",
    "        for i, period in enumerate(all_periods):\n",
    "            if period.month != previous_month:\n",
    "                labels[i] = period.strftime('%b %Y')\n",
    "                previous_month = period.month\n",
    "    else:  # If it's monthly, label each month\n",
    "        labels = [period.strftime('%b %Y') for period in all_periods]\n",
    "\n",
    "    ax1.set_xticks(np.arange(len(all_periods)))\n",
    "    ax1.set_xticklabels(labels, rotation=90)\n",
    "    ax1.set_ylabel('Hour of Day', fontsize=14)\n",
    "    index=[]\n",
    "\n",
    "    # add datetime to spec actions\n",
    "    specific_action_df['datetime'] = specific_action_df.index\n",
    "    specific_action_df1['datetime'] = specific_action_df1.index\n",
    "    specific_action_df2['datetime'] = specific_action_df2.index\n",
    "    specific_action_df3['datetime'] = specific_action_df3.index\n",
    "    specific_action_df4['datetime'] = specific_action_df4.index\n",
    "    specific_action_df5['datetime'] = specific_action_df5.index\n",
    "\n",
    "    # Add a new column for period index\n",
    "    def get_period_index(date):\n",
    "        period = date.to_period(freq=period_freq)\n",
    "        if period in all_periods:\n",
    "            return np.where(all_periods == period)[0][0]\n",
    "        else:\n",
    "            return None\n",
    "\n",
    "    specific_action_df['period_index'] = specific_action_df['datetime'].apply(get_period_index)\n",
    "    specific_action_df1['period_index'] = specific_action_df1['datetime'].apply(get_period_index)\n",
    "    specific_action_df2['period_index'] = specific_action_df2['datetime'].apply(get_period_index)\n",
    "    specific_action_df3['period_index'] = specific_action_df3['datetime'].apply(get_period_index)\n",
    "    specific_action_df4['period_index'] = specific_action_df4['datetime'].apply(get_period_index)\n",
    "    specific_action_df5['period_index'] = specific_action_df5['datetime'].apply(get_period_index)\n",
    "\n",
    "    if f == 'Yes':\n",
    "        #ax1.text(1, 10, 'CNB', ha='center', va='center', color='white',fontsize=16)\n",
    "        for i in range(0,len(specific_action_df)):\n",
    "            if specific_action_df['period_index'][i] is not None and np.isfinite(specific_action_df['period_index'][i]):\n",
    "        # Annotate specific actions on the heatmap\n",
    "                note=specific_action_df['Note'][i]\n",
    "                ax1.text(specific_action_df['period_index'][i], 11, note, ha='center', va='center', color='white',fontsize=14)\n",
    "\n",
    "        #ax1.text(2, 13, 'LAC 600', ha='center', va='center', color='red',fontsize=16)\n",
    "        for i in range(0,len(specific_action_df1)):\n",
    "            if specific_action_df1['period_index'][i] is not None and np.isfinite(specific_action_df1['period_index'][i]):\n",
    "        # Annotate specific actions on the heatmap\n",
    "                note=specific_action_df1['Note'][i]\n",
    "                ax1.text(specific_action_df1['period_index'][i], 13, note, ha='center', va='center', color='red',fontsize=14)\n",
    "    \n",
    "        for i in range(0,len(specific_action_df5)):\n",
    "            if specific_action_df5['period_index'][i] is not None and np.isfinite(specific_action_df5['period_index'][i]):\n",
    "        # Annotate specific actions on the heatmap\n",
    "                note=specific_action_df5['Note'][i]\n",
    "                ax1.text(specific_action_df5['period_index'][i], 16, note, ha='center', va='center', color='y',fontsize=14)\n",
    "\n",
    "    if g == True:\n",
    "        ind=pd.Series.to_numpy(specific_action_df4.period_index)\n",
    "        for i in range(0,len(ind)):\n",
    "            if ind[i] is not None and np.isfinite(ind[i]):\n",
    "        # Annotate specific actions on the heatmap\n",
    "                \n",
    "                ax1.scatter(ind[i],22,c='yellow',s=100)\n",
    "\n",
    "   # Add colorbar\n",
    "    plt.colorbar(im, cax=ax2)\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "    return specific_action_df,df,all_periods,specific_action_df5,complete_grouped_df.sum(axis=1)\n",
    "\n",
    "    \n",
    "\n",
    "# Example usage with widgets\n",
    "a = widgets.DatePicker(description='Start Date', value=datetime.date.today() - pd.Timedelta(days=365))\n",
    "b = widgets.SelectMultiple(\n",
    "    options=['Standard nighttime Seizure', 'Seizure from Wakefulness', 'Have continuous focal SE'],\n",
    "    value=['Standard nighttime Seizure', 'Seizure from Wakefulness'],\n",
    "    description='Seizures to Display',\n",
    "    disabled=False\n",
    ")\n",
    "c = widgets.DatePicker(description='End Date', value=datetime.date.today()+ datetime.timedelta(days=1))\n",
    "d = widgets.RadioButtons(\n",
    "    options=['Weekly', 'Monthly','Daily'],\n",
    "    description='Binning:',\n",
    "    disabled=False\n",
    ")\n",
    "f = widgets.RadioButtons(\n",
    "    options=['Yes', 'No'],\n",
    "    description='Show Meds:',\n",
    "    disabled=False\n",
    ")\n",
    "g = widgets.Checkbox(\n",
    "    value=False,\n",
    "    description='Needed Rescue Meds',\n",
    "    disabled=False\n",
    ")\n",
    "    \n",
    "# Suppress warnings for finite values\n",
    "with warnings.catch_warnings():\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "        \n",
    "e = widgets.interactive(multi, a=a, b=b, c=c, d=d,f=f,g=g)\n",
    "display(e)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Icon           405\n",
       "Action         405\n",
       "Time Zone      405\n",
       "City Name        0\n",
       "Address          0\n",
       "Coordinates      0\n",
       "Note             1\n",
       "datetime       405\n",
       "hour           405\n",
       "dayofweek      405\n",
       "period         405\n",
       "dtype: int64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e.result[1].count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'e' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-88b41114fb7b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpandas\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mSeries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_numpy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mperiod_index\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mstatsmodels\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgraphics\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtsaplots\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'e' is not defined"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "import pandas as pd\n",
    "pd.Series.to_numpy(e.result[3].period_index)\n",
    "\n",
    "e.result[4]\n",
    "from statsmodels.graphics import tsaplots\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#plot autocorrelation function\n",
    "fig = tsaplots.plot_acf(e.result[4], lags=31)\n",
    "plt.show()\n",
    "a1 = widgets.DatePicker(description='Period 1 Start', value=datetime.date.today()+ datetime.timedelta(days=1))\n",
    "b1 = widgets.DatePicker(description='Period 2 Start', value=datetime.date.today()+ datetime.timedelta(days=1))\n",
    "c1 = widgets.RadioButtons(\n",
    "    options=['Week','Fortnight','Month'],\n",
    "    description='Duration:',\n",
    "    disabled=False\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import Apple Watch Health Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "import xml.etree.ElementTree as ET\n",
    "# create element tree object\n",
    "tree = ET.parse('apple_health_export/export.xml') \n",
    "# for every health record, extract the attributes\n",
    "root = tree.getroot()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "\n",
    "record_list = [x.attrib for x in root.iter('Record')]\n",
    "\n",
    "# create DataFrame from a list (rows) of dictionaries (columns)\n",
    "data = pd.DataFrame(record_list)\n",
    "\n",
    "# proper type to dates\n",
    "for col in ['creationDate', 'startDate', 'endDate']:\n",
    "    data[col] = pd.to_datetime(data[col])\n",
    "\n",
    "    # value is numeric, NaN if fails\n",
    "data['value'] = pd.to_numeric(data['value'], errors='coerce')\n",
    "\n",
    "# some records do not measure anything, just count occurences\n",
    "# filling with 1.0 (= one time) makes it easier to aggregate\n",
    "data['value'] = data['value'].fillna(1.0)\n",
    "\n",
    "# shorter observation names: use vectorized replace function\n",
    "data['type'] = data['type'].str.replace('HKQuantityTypeIdentifier', '')\n",
    "data['type'] = data['type'].str.replace('HKCategoryTypeIdentifier', '')\n",
    "\n",
    "# save into feather as this is a more efficient data format\n",
    "data.to_feather(\"/Users/thomasjensen/Documents/apple_export.ftr\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": [
    "# import xml.etree.ElementTree as ET\n",
    "# # create element tree object\n",
    "# tree = ET.parse('apple_health_export/export.xml') \n",
    "# # for every health record, extract the attributes\n",
    "# root = tree.getroot()\n",
    "\n",
    "# workout_list = [x.attrib for x in root.iter('Workout')]\n",
    "\n",
    "# # create DataFrame\n",
    "# workout_data = pd.DataFrame(workout_list)\n",
    "# workout_data['workoutActivityType'] = workout_data['workoutActivityType'].str.replace('HKWorkoutActivityType', '')\n",
    "# workout_data = workout_data.rename({\"workoutActivityType\": \"Type\"}, axis=1)\n",
    "\n",
    "# # proper type to dates\n",
    "# for col in ['creationDate', 'startDate', 'endDate']:\n",
    "#     workout_data[col] = pd.to_datetime(workout_data[col])\n",
    "\n",
    "# # convert string to numeric   \n",
    "# workout_data['duration'] = pd.to_numeric(workout_data['duration'])\n",
    "# workout_data_reduced=workout_data.loc[workout_data['startDate']>a.value.isoformat()]\n",
    "# workout_data_reduced=workout_data_reduced.loc[workout_data_reduced['startDate']<c.value.isoformat()]\n",
    "\n",
    "# # record_list = [x.attrib for x in root.iter('Record')]\n",
    "# # record_data = pd.DataFrame(record_list)\n",
    "# # # proper type to dates\n",
    "# # for col in ['creationDate', 'startDate', 'endDate']:\n",
    "# #     record_data[col] = pd.to_datetime(record_data[col])\n",
    "\n",
    "# # # value is numeric, NaN if fails\n",
    "# # record_data['value'] = pd.to_numeric(record_data['value'], errors='coerce')\n",
    "\n",
    "# # # some records do not measure anything, just count occurences\n",
    "# # # filling with 1.0 (= one time) makes it easier to aggregate\n",
    "# # record_data['value'] = record_data['value'].fillna(1.0)\n",
    "\n",
    "# # # shorter observation names\n",
    "# # record_data['type'] = record_data['type'].str.replace('HKQuantityTypeIdentifier', '')\n",
    "# # record_data['type'] = record_data['type'].str.replace('HKCategoryTypeIdentifier', '')\n",
    "# workout_list = [x.attrib for x in root.iter('Workout')]\n",
    "\n",
    "# # create DataFrame\n",
    "# workout_data = pd.DataFrame(workout_list)\n",
    "# workout_data['workoutActivityType'] = workout_data['workoutActivityType'].str.replace('HKWorkoutActivityType', '')\n",
    "# workout_data = workout_data.rename({\"workoutActivityType\": \"Type\"}, axis=1)\n",
    "\n",
    "# # proper type to dates\n",
    "# for col in ['creationDate', 'startDate', 'endDate']:\n",
    "#     workout_data[col] = pd.to_datetime(workout_data[col])\n",
    "\n",
    "# # convert string to numeric   \n",
    "# workout_data['duration'] = pd.to_numeric(workout_data['duration'])\n",
    "# # workout_data['totalDistance'] = pd.to_numeric(workout_data['totalDistance'])\n",
    "# workout_data_reduced=workout_data.loc[workout_data['startDate']>a.value.isoformat()]\n",
    "# workout_data_reduced=workout_data_reduced.loc[workout_data_reduced['startDate']<c.value.isoformat()]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<seaborn.axisgrid.FacetGrid at 0x7feb09324450>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "ax1=sns.displot(data=e.result[1], \n",
    "            x='hour',\n",
    "            rug=True,\n",
    "            kind=\"hist\",\n",
    "            kde=True,\n",
    "           bins=48)\n",
    "ax1.set_ylabels(label='Seizure count')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "trusted": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax2=sns.displot(data=e.result[1], \n",
    "            x='dayofweek',\n",
    "            rug=True,\n",
    "            kind=\"hist\",\n",
    "           kde=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "trusted": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py37",
   "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.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}