{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "Q9GBydEgCv5O" }, "source": [ "# Garmin Fenix 7S: Guide to data extraction and analysis" ] }, { "cell_type": "markdown", "metadata": { "id": "8OL7u_fWDbTk" }, "source": [ "\n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "2TRGazbwEPf5" }, "source": [ "A versatile watch that is capable of tracking your heart rate, steps, and other metrics, the [Garmin Fenix 7S](https://www.garmin.com/en-US/p/735542) is a watch that stores a treasure trove of health data that we will explore in this notebook.\n", "\n", "We've used the Garmin Fenix 7S for a while now, and we'll show you how to extract its data, visualize heart rate data, and compute correlations and other statistical measures based on your data! While you will need a Garmin Fenix 7S to actually collect the data itself, the data *extraction* requires only an internet connection and your username and password.\n", "\n", "If you want to know more about the Garmin Fenix 7S, see the [README](https://github.com/alrojo/wearipedia/tree/main/wearables/garmin-fenix-7s) for a detailed analysis of performances, sensors, data privacy, and extraction pipelines.\n", "\n", "You can extract the parameters with known sampling frequencies as below:\n", "\n", "Parameter Name | Sampling Frequency \n", "-------------------|------------------\n", "Heart rate | 2 minutes\n", "Breaths per minute | 2 minutes\n", "Step Count | 15 minutes\n", "Stress (proxy for HRV) | 3 minutes\n", "Resting heart rate | 1 day\n", "\n", "Do note that the [unofficial API](https://github.com/cyberjunky/python-garminconnect/) we rely on and Garmin watch provide access to other values that may be automatically recorded:\n", "- sleep (awake vs. light vs. deep)\n", "- SpO2 levels\n", "\n", "In this guide, we sequentially cover the following **nine** topics to extract from the unofficial Garmin API:\n", "1. **Setup**\n", "2. **Authentication/Authorization**\n", " - Requires only username and password, no OAuth.\n", "3. **Data extraction**\n", " - We get data via `wearipedia` in a couple lines of code.\n", "4. **Data Exporting**\n", " - We export all of this data to file formats compatible by R, Excel, and MatLab.\n", "5. **Adherence**\n", " - We simulate non-adherence by dynamically removing datapoints from our simulated data.\n", "6. **Visualization**\n", " - We create a simple plot to visualize our data.\n", "7. **Advanced visualization**\n", " - 7.1: We plot a calendar heatmap of step counts every day, revealing which days the user has worn the watch.\n", " - 7.2: We reproduce a time series plot from the Garmin Connect website of heart rate and activity (steps) throughout a given day.\n", "8. **Outlier Detection and Data Cleaning**\n", " - We detect outliers in our data and filter them out.\n", "9. **Data analysis**\n", " - 9.1: We test whether activity (step counts) and heart rates within 15 minute intervals are correlated and find a statistically significant relationship.\n", " - 9.2: We check for a correlation between breathing rate and heart rate, and find a statistically significant link.\n", " - Note that we are not making any scientific claims here as our sample size is small and the data collection process was not rigorously vetted (it is our own data), only demonstrating that this code could potentially be used to perform rigorous analyses in the future.\n", "\n", "Disclaimer: this notebook is purely for educational purposes. All of the data currently stored in this notebook is purely *synthetic*, meaning randomly generated according to rules we created. Despite this, the end-to-end data extraction pipeline has been tested on our own data, meaning that if you enter your own email and password on your own Colab instance, you can visualize your own *real* data. That being said, we were unable to thoroughly test the timezone functionality, though, since we only have one account, so beware." ] }, { "cell_type": "markdown", "source": [ "# 1. Setup\n", "\n", "## Participant Setup\n", "\n", "Dear Participant,\n", "\n", "Once you unbox your Garmin Fenix 7S, please set up the device by following these resources:\n", "- Written guide: https://support.garmin.com/en-US/?faq=jvJTLgrDV881K1NXuC4CsA\n", "- Video guide: https://www.youtube.com/watch?v=Fgq6LM2NqNo\n", "\n", "Make sure that your phone is paired to it using the Garmin Connect login credentials (email and password) given to you by the data receiver.\n", "\n", "Best,\n", "\n", "Wearipedia\n", "\n", "## Data Receiver Setup\n", "\n", "Please follow the below steps:\n", "\n", "1. Create an email address for the participant, for example `foo@email.com`.\n", "2. Create a Garmin Connect account with the email `foo@email.com` and some random password.\n", "3. Keep `foo@email.com` and password stored somewhere safe.\n", "4. Distribute the device to the participant and instruct them to follow the participant setup letter above.\n", "5. Install the `wearipedia` Python package to easily extract data from this device via the Garmin Connect API.\n", "\n", "In this notebook, we will also install the `july` package for calendar plotting, but this is not strictly necessary." ], "metadata": { "id": "iIRMm2vOgxyK" } }, { "cell_type": "code", "source": [ "!pip install git+https://rodrigo-castellon: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@github.com/rodrigo-castellon/wearipedia.git\n", "!pip install july -q # for calendar plotting" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7CbudzE0yom8", "outputId": "4e60a69d-fd05-4961-926e-519fb7a5d868" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting git+https://rodrigo-castellon:****@github.com/rodrigo-castellon/wearipedia.git\n", " Cloning https://rodrigo-castellon:****@github.com/rodrigo-castellon/wearipedia.git to /tmp/pip-req-build-rl_ycwoi\n", " Running command git clone -q 'https://rodrigo-castellon:****@github.com/rodrigo-castellon/wearipedia.git' /tmp/pip-req-build-rl_ycwoi\n", " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", " Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n", "Requirement already satisfied: pandas<2.0,>=1.1 in /usr/local/lib/python3.8/dist-packages (from wearipedia==0.1.0) (1.3.5)\n", "Requirement already satisfied: tqdm<5.0.0,>=4.64.1 in /usr/local/lib/python3.8/dist-packages (from wearipedia==0.1.0) (4.64.1)\n", "Collecting wget<4.0,>=3.2\n", " Downloading wget-3.2.zip (10 kB)\n", "Requirement already satisfied: scipy<2.0,>=1.6 in /usr/local/lib/python3.8/dist-packages (from wearipedia==0.1.0) (1.7.3)\n", "Collecting typer[all]<0.7.0,>=0.6.1\n", " Downloading typer-0.6.1-py3-none-any.whl (38 kB)\n", "Collecting rich<13.0.0,>=12.6.0\n", " Downloading rich-12.6.0-py3-none-any.whl (237 kB)\n", "\u001b[K |████████████████████████████████| 237 kB 9.3 MB/s \n", "\u001b[?25hCollecting garminconnect<0.2.0,>=0.1.48\n", " Downloading garminconnect-0.1.49.tar.gz (17 kB)\n", "Requirement already satisfied: requests in /usr/local/lib/python3.8/dist-packages (from garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (2.23.0)\n", "Collecting cloudscraper\n", " Downloading cloudscraper-1.2.66-py2.py3-none-any.whl (98 kB)\n", "\u001b[K |████████████████████████████████| 98 kB 8.6 MB/s \n", "\u001b[?25hRequirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0,>=1.1->wearipedia==0.1.0) (2022.6)\n", "Requirement already satisfied: numpy>=1.17.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0,>=1.1->wearipedia==0.1.0) (1.21.6)\n", "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0,>=1.1->wearipedia==0.1.0) (2.8.2)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.7.3->pandas<2.0,>=1.1->wearipedia==0.1.0) (1.15.0)\n", "Requirement already satisfied: pygments<3.0.0,>=2.6.0 in /usr/local/lib/python3.8/dist-packages (from rich<13.0.0,>=12.6.0->wearipedia==0.1.0) (2.6.1)\n", "Requirement already satisfied: typing-extensions<5.0,>=4.0.0 in /usr/local/lib/python3.8/dist-packages (from rich<13.0.0,>=12.6.0->wearipedia==0.1.0) (4.4.0)\n", "Collecting commonmark<0.10.0,>=0.9.0\n", " Downloading commonmark-0.9.1-py2.py3-none-any.whl (51 kB)\n", "\u001b[K |████████████████████████████████| 51 kB 8.0 MB/s \n", "\u001b[?25hRequirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.8/dist-packages (from typer[all]<0.7.0,>=0.6.1->wearipedia==0.1.0) (7.1.2)\n", "Collecting colorama<0.5.0,>=0.4.3\n", " Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n", "Collecting shellingham<2.0.0,>=1.3.0\n", " Downloading shellingham-1.5.0-py2.py3-none-any.whl (9.3 kB)\n", "Requirement already satisfied: pyparsing>=2.4.7 in /usr/local/lib/python3.8/dist-packages (from cloudscraper->garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (3.0.9)\n", "Collecting requests-toolbelt>=0.9.1\n", " Downloading requests_toolbelt-0.10.1-py2.py3-none-any.whl (54 kB)\n", "\u001b[K |████████████████████████████████| 54 kB 3.1 MB/s \n", "\u001b[?25hRequirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests->garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (2022.9.24)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests->garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (1.24.3)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests->garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (2.10)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests->garminconnect<0.2.0,>=0.1.48->wearipedia==0.1.0) (3.0.4)\n", "Building wheels for collected packages: wearipedia, garminconnect, wget\n", " Building wheel for wearipedia (PEP 517) ... \u001b[?25l\u001b[?25hdone\n", " Created wheel for wearipedia: filename=wearipedia-0.1.0-py3-none-any.whl size=39135 sha256=26efa116fa293777e4df8e7bf4e98b8cd987f7b3eb360c45104e047e79216f95\n", " Stored in directory: /tmp/pip-ephem-wheel-cache-nemlnbvd/wheels/52/1e/f8/8f0057d6273afb20fbea2450141dd24911d2c0da1f65c1c288\n", " Building wheel for garminconnect (setup.py) ... \u001b[?25l\u001b[?25hdone\n", " Created wheel for garminconnect: filename=garminconnect-0.1.49-py3-none-any.whl size=12703 sha256=298196cc4fff0c99ff6b70dda3e3b27ae4d6952bc448cc59db2531b694d1f9ef\n", " Stored in directory: /root/.cache/pip/wheels/61/3c/19/189302584753d4b942618ca0b55da235b06389d561c8ba17fc\n", " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=f1721d4ca48da1d0b60678ce3f8b5181bf55d86fc2eec1a60fe77f89bf6e6cda\n", " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", "Successfully built wearipedia garminconnect wget\n", "Installing collected packages: requests-toolbelt, commonmark, typer, shellingham, rich, colorama, cloudscraper, wget, garminconnect, wearipedia\n", " Attempting uninstall: typer\n", " Found existing installation: typer 0.7.0\n", " Uninstalling typer-0.7.0:\n", " Successfully uninstalled typer-0.7.0\n", "Successfully installed cloudscraper-1.2.66 colorama-0.4.6 commonmark-0.9.1 garminconnect-0.1.49 requests-toolbelt-0.10.1 rich-12.6.0 shellingham-1.5.0 typer-0.6.1 wearipedia-0.1.0 wget-3.2\n" ] } ] }, { "cell_type": "markdown", "source": [ "# 2. Authentication/Authorization\n", "\n", "To obtain access to data, authorization is required. All you'll need to do here is just put in your email and password for your Garmin Fenix 7S device. We'll use this username and password to extract the data in the sections below." ], "metadata": { "id": "_wI8XzCFypXC" } }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "mAlFStFd-ZYD", "cellView": "form" }, "outputs": [], "source": [ "#@title Enter Garmin login credentials\n", "email_address = \"jadongeathers@gmail.com\" #@param {type:\"string\"}\n", "password = \"StanfordGarminD4ta\" #@param {type:\"string\"}" ] }, { "cell_type": "markdown", "metadata": { "id": "BbaKJhcbkiq8" }, "source": [ "# 3. Data Extraction\n", "\n", "Data can be extracted via [wearipedia](https://github.com/Stanford-Health/wearipedia/), our open-source Python package that unifies dozens of complex wearable device APIs into one simple, common interface.\n", "\n", "First, we'll set a date range and then extract all of the data within that date range. You can select whether you would like synthetic data or not with the checkbox." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "id": "JqfUZibhfB3L" }, "outputs": [], "source": [ "#@title Enter start and end dates (in the format yyyy-mm-dd)\n", "\n", "#set start and end dates - this will give you all the data from 2000-01-01 (January 1st, 2000) to 2100-02-03 (February 3rd, 2100), for example\n", "start_date='2022-03-01' #@param {type:\"string\"}\n", "end_date='2022-06-17' #@param {type:\"string\"}\n", "synthetic = True #@param {type:\"boolean\"}" ] }, { "cell_type": "code", "source": [ "import wearipedia\n", "\n", "device = wearipedia.get_device(\"garmin/fenix_7s\")\n", "\n", "if not synthetic:\n", " device.authenticate({\"email\": email_address, \"password\": password})\n", "\n", "params = {\"start_date\": start_date, \"end_date\": end_date}\n", "\n", "dates = device.get_data(\"dates\", params=params)\n", "steps = device.get_data(\"steps\", params=params)\n", "hrs = device.get_data(\"hrs\", params=params)\n", "brpms = device.get_data(\"brpms\", params=params)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "HRrMwqUnB1x9", "outputId": "eb461443-e53c-4c3e-81a5-9f6cb92c3a40" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "100%|██████████| 108/108 [00:24<00:00, 4.33it/s]\n", "100%|██████████| 108/108 [00:00<00:00, 2557.53it/s]\n", "100%|██████████| 108/108 [00:00<00:00, 10827.37it/s]\n" ] } ] }, { "cell_type": "markdown", "source": [ "# 4. Data Exporting\n", "\n", "In this section, we export all of this data to formats compatible with popular scientific computing software (R, Excel, Google Sheets, Matlab). Specifically, we will first export to JSON, which can be read by R and Matlab. Then, we will export to CSV, which can be consumed by Excel, Google Sheets, and every other popular programming language.\n", "\n", "## Exporting to JSON (R, Matlab, etc.)\n", "\n", "Exporting to JSON is fairly simple. We export each datatype separately and also export a complete version that includes all simultaneously." ], "metadata": { "id": "eag-47xkhUhP" } }, { "cell_type": "code", "source": [ "import json\n", "\n", "# need to process `dates` into strings because it has datetime objects\n", "dates_stringified = [d.strftime('%Y-%m-%d') for d in dates]\n", "\n", "json.dump(dates_stringified, open(\"dates.json\", \"w\"))\n", "json.dump(steps, open(\"steps.json\", \"w\"))\n", "json.dump(hrs, open(\"hrs.json\", \"w\"))\n", "json.dump(brpms, open(\"brpms.json\", \"w\"))\n", "\n", "complete = {\n", " \"dates\": dates_stringified,\n", " \"steps\": steps,\n", " \"hrs\": hrs,\n", " \"brpms\": brpms\n", "}\n", "\n", "json.dump(complete, open(\"complete.json\", \"w\"))" ], "metadata": { "id": "Gjkuim15jaqB" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "Feel free to open the file viewer (see left pane) to look at the outputs!\n", "\n", "## Exporting to CSV and XLSX (Excel, Google Sheets, R, Matlab, etc.)\n", "\n", "Exporting to CSV/XLSX requires a bit more processing, since they enforce a pretty restrictive schema.\n", "\n", "We will thus export steps, heart rates, and breath rates all as separate files." ], "metadata": { "id": "RNjuB-ssiSlI" } }, { "cell_type": "code", "source": [ "import pandas as pd\n", "\n", "steps_concat = []\n", "\n", "for steps_day in steps:\n", " steps_concat += steps_day\n", "\n", "df = pd.DataFrame(steps_concat)\n", "df.to_csv('steps.csv', index=False)\n", "df.to_excel('steps.xlsx', index=False)\n", "\n", "hrs_concat = []\n", "\n", "for hrs_day in hrs:\n", " hrs_concat += hrs_day['heartRateValues']\n", "\n", "df = pd.DataFrame(hrs_concat, columns=['timestamp', 'heart_rate'])\n", "df.to_csv('hrs.csv', index=False)\n", "df.to_excel('hrs.xlsx', index=False)\n", "\n", "brpms_concat = []\n", "\n", "for brpms_day in brpms:\n", " brpms_concat += brpms_day['respirationValuesArray']\n", "\n", "df = pd.DataFrame(brpms_concat, columns=['timestamp', 'brpm'])\n", "df.to_csv('brpms.csv', index=False)\n", "df.to_excel('brpms.xlsx', index=False)" ], "metadata": { "id": "JDy7bEkG8ZOa" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "Again, feel free to look at the output files and download them." ], "metadata": { "id": "AIMQfRczUbmm" } }, { "cell_type": "markdown", "source": [ "# 5. Adherence\n", "\n", "The device simulator already automatically randomly deletes small chunks of the day. In this section, we will simulate non-adherence over longer periods of time from the participant (day-level and week-level).\n", "\n", "Then, we will detect this non-adherence and give a Pandas DataFrame that concisely describes when the participant has had their device on and off throughout the entirety of the time period, allowing you to calculate how long they've had it on/off etc.\n", "\n", "We will first delete a certain % of blocks either at the day level or week level, with user input." ], "metadata": { "id": "L-lNQWtjo6cP" } }, { "cell_type": "code", "source": [ "#@title Non-adherence simulation\n", "block_level = \"day\" #@param [\"day\", \"week\"]\n", "adherence_percent = 0.74 #@param {type:\"slider\", min:0, max:1, step:0.01}" ], "metadata": { "cellView": "form", "id": "RrtvU6Ry4Gz2" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "import numpy as np\n", "\n", "if block_level == \"day\":\n", " block_length = 1\n", "elif block_level == \"week\":\n", " block_length = 7\n", "\n", "num_blocks = len(dates) // block_length\n", "\n", "num_blocks_to_keep = int(adherence_percent * num_blocks)\n", "\n", "idxes = np.random.choice(np.arange(num_blocks), replace=False, size=num_blocks_to_keep)\n", "\n", "adhered_dates = []\n", "adhered_steps = []\n", "adhered_hrs = []\n", "adhered_brpms = []\n", "\n", "for i in range(num_blocks):\n", " if i in idxes:\n", " start = i * block_length\n", " end = (i + 1) * block_length\n", " for j, (date, step, hr, brpm) in enumerate(zip(dates[start:end], steps[start:end], hrs[start:end], brpms[start:end])):\n", " adhered_dates.append(date)\n", " adhered_steps.append(step)\n", " adhered_hrs.append(hr)\n", " adhered_brpms.append(brpm)\n", "\n", "dates = adhered_dates\n", "steps = adhered_steps\n", "hrs = adhered_hrs\n", "brpms = adhered_brpms" ], "metadata": { "id": "gxA71QkT4p-x" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "And now we have significantly fewer datapoints! This will give us a more realistic situation, where participants may take off their device for days or weeks at a time.\n", "\n", "Now let's detect non-adherence. We will return a Pandas DataFrame sampled at every 15 minutes." ], "metadata": { "id": "l_is4pTd7iqt" } }, { "cell_type": "code", "source": [ "from datetime import datetime\n", "\n", "steps_concat = []\n", "for step in steps:\n", " steps_concat += step\n", "\n", "ts_col = pd.date_range(steps_concat[0]['startGMT'], steps_concat[-1]['endGMT'], freq=\"900s\")\n", "wearing_arr = np.zeros(len(ts_col))\n", "for i, step in enumerate(steps_concat):\n", " ts = pd.Timestamp(step['startGMT'])\n", " idxes = np.where(ts_col == ts)[0]\n", " if len(idxes) == 1:\n", " wearing_arr[idxes[0]] = 1\n", "\n", "df = pd.DataFrame()\n", "df['timestamp'] = ts_col\n", "df['is_wearing'] = wearing_arr.astype('bool')" ], "metadata": { "id": "HuPOiU9W1w9A" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "We can plot this out, and we get adherence at a 15 minute frequency throughout the entirety of the data collection period." ], "metadata": { "id": "Io8yWKi13kAu" } }, { "cell_type": "code", "source": [ "import matplotlib.pyplot as plt\n", "\n", "plt.figure(figsize=(12, 6))\n", "plt.plot(df.timestamp, df.is_wearing)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 392 }, "id": "dsVFAXJi2Ah_", "outputId": "b961e8f8-bca8-4e56-9f81-31400b128ab0" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, "metadata": {}, "execution_count": 10 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ] }, { "cell_type": "markdown", "source": [ "We can also turn this into a list of start and stop points." ], "metadata": { "id": "-w5NoNTy4EiX" } }, { "cell_type": "code", "source": [ "from itertools import groupby\n", "\n", "def contiguous_regions(a):\n", " i = 0\n", " res = []\n", "\n", " for k, g in groupby(a):\n", " l = len(list(g))\n", " if k:\n", " res.append((i,i+l))\n", " i += l\n", "\n", " return res\n", "\n", "start_stops = [(df.timestamp[x[0]], df.timestamp[x[1]]) for x in contiguous_regions(df.is_wearing)]\n", "start_stops" ], "metadata": { "id": "vK9xqV-H4Tku", "colab": { "base_uri": "https://localhost:8080/" }, "outputId": "cc44042b-7db5-4eb4-8904-2e56e6ccf006" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[(Timestamp('2022-03-01 07:00:00'), Timestamp('2022-03-02 00:45:00')),\n", " (Timestamp('2022-03-02 01:15:00'), Timestamp('2022-03-02 07:00:00')),\n", " (Timestamp('2022-03-03 07:00:00'), Timestamp('2022-03-03 10:45:00')),\n", " (Timestamp('2022-03-03 15:30:00'), Timestamp('2022-03-04 19:00:00')),\n", " (Timestamp('2022-03-04 20:45:00'), Timestamp('2022-03-05 07:00:00')),\n", " (Timestamp('2022-03-07 07:00:00'), Timestamp('2022-03-08 00:45:00')),\n", " (Timestamp('2022-03-08 01:00:00'), Timestamp('2022-03-08 11:00:00')),\n", " (Timestamp('2022-03-08 12:00:00'), Timestamp('2022-03-09 07:00:00')),\n", " (Timestamp('2022-03-11 07:00:00'), Timestamp('2022-03-12 01:45:00')),\n", " (Timestamp('2022-03-12 03:45:00'), Timestamp('2022-03-12 07:15:00')),\n", " (Timestamp('2022-03-12 08:45:00'), Timestamp('2022-03-13 17:00:00')),\n", " (Timestamp('2022-03-13 20:45:00'), Timestamp('2022-03-14 08:45:00')),\n", " (Timestamp('2022-03-14 13:15:00'), Timestamp('2022-03-16 23:00:00')),\n", " (Timestamp('2022-03-16 23:15:00'), Timestamp('2022-03-19 00:30:00')),\n", " (Timestamp('2022-03-19 04:15:00'), Timestamp('2022-03-19 16:45:00')),\n", " (Timestamp('2022-03-19 17:45:00'), Timestamp('2022-03-20 20:15:00')),\n", " (Timestamp('2022-03-20 20:30:00'), Timestamp('2022-03-21 07:00:00')),\n", " (Timestamp('2022-03-22 07:00:00'), Timestamp('2022-03-22 18:45:00')),\n", " (Timestamp('2022-03-22 21:00:00'), Timestamp('2022-03-23 11:00:00')),\n", " (Timestamp('2022-03-23 12:30:00'), Timestamp('2022-03-24 15:00:00')),\n", " (Timestamp('2022-03-24 19:15:00'), Timestamp('2022-03-25 20:30:00')),\n", " (Timestamp('2022-03-26 01:00:00'), Timestamp('2022-03-27 07:00:00')),\n", " (Timestamp('2022-03-28 07:00:00'), Timestamp('2022-03-28 15:30:00')),\n", " (Timestamp('2022-03-28 21:00:00'), Timestamp('2022-03-29 11:45:00')),\n", " (Timestamp('2022-03-29 16:00:00'), Timestamp('2022-03-30 11:15:00')),\n", " (Timestamp('2022-03-30 12:00:00'), Timestamp('2022-03-31 15:00:00')),\n", " (Timestamp('2022-03-31 17:00:00'), Timestamp('2022-04-01 09:15:00')),\n", " (Timestamp('2022-04-01 10:30:00'), Timestamp('2022-04-02 22:15:00')),\n", " (Timestamp('2022-04-03 00:30:00'), Timestamp('2022-04-03 20:00:00')),\n", " (Timestamp('2022-04-03 23:15:00'), Timestamp('2022-04-05 01:15:00')),\n", " (Timestamp('2022-04-05 01:45:00'), Timestamp('2022-04-05 21:30:00')),\n", " (Timestamp('2022-04-06 02:15:00'), Timestamp('2022-04-06 07:00:00')),\n", " (Timestamp('2022-04-07 07:00:00'), Timestamp('2022-04-07 14:30:00')),\n", " (Timestamp('2022-04-07 17:30:00'), Timestamp('2022-04-08 13:00:00')),\n", " (Timestamp('2022-04-08 16:45:00'), Timestamp('2022-04-09 13:45:00')),\n", " (Timestamp('2022-04-09 17:00:00'), Timestamp('2022-04-10 07:00:00')),\n", " (Timestamp('2022-04-13 07:00:00'), Timestamp('2022-04-13 21:00:00')),\n", " (Timestamp('2022-04-13 21:45:00'), Timestamp('2022-04-14 21:30:00')),\n", " (Timestamp('2022-04-14 22:00:00'), Timestamp('2022-04-15 09:15:00')),\n", " (Timestamp('2022-04-15 15:30:00'), Timestamp('2022-04-16 09:30:00')),\n", " (Timestamp('2022-04-16 16:00:00'), Timestamp('2022-04-17 14:00:00')),\n", " (Timestamp('2022-04-17 14:30:00'), Timestamp('2022-04-19 00:00:00')),\n", " (Timestamp('2022-04-19 02:15:00'), Timestamp('2022-04-19 21:30:00')),\n", " (Timestamp('2022-04-19 23:30:00'), Timestamp('2022-04-20 10:45:00')),\n", " (Timestamp('2022-04-20 15:15:00'), Timestamp('2022-04-21 10:15:00')),\n", " (Timestamp('2022-04-22 01:15:00'), Timestamp('2022-04-23 00:00:00')),\n", " (Timestamp('2022-04-23 04:15:00'), Timestamp('2022-04-23 07:00:00')),\n", " (Timestamp('2022-04-24 07:00:00'), Timestamp('2022-04-24 10:00:00')),\n", " (Timestamp('2022-04-24 14:15:00'), Timestamp('2022-04-25 07:15:00')),\n", " (Timestamp('2022-04-25 14:15:00'), Timestamp('2022-04-27 00:30:00')),\n", " (Timestamp('2022-04-27 01:30:00'), Timestamp('2022-04-27 12:45:00')),\n", " (Timestamp('2022-04-27 13:15:00'), Timestamp('2022-04-28 07:00:00')),\n", " (Timestamp('2022-04-29 07:00:00'), Timestamp('2022-04-29 10:45:00')),\n", " (Timestamp('2022-04-29 16:45:00'), Timestamp('2022-04-30 11:30:00')),\n", " (Timestamp('2022-04-30 13:00:00'), Timestamp('2022-05-01 15:15:00')),\n", " (Timestamp('2022-05-01 16:30:00'), Timestamp('2022-05-03 07:00:00')),\n", " (Timestamp('2022-05-04 07:00:00'), Timestamp('2022-05-04 12:30:00')),\n", " (Timestamp('2022-05-04 13:30:00'), Timestamp('2022-05-05 11:30:00')),\n", " (Timestamp('2022-05-05 18:00:00'), Timestamp('2022-05-06 07:00:00')),\n", " (Timestamp('2022-05-08 07:00:00'), Timestamp('2022-05-08 16:30:00')),\n", " (Timestamp('2022-05-08 23:30:00'), Timestamp('2022-05-09 16:45:00')),\n", " (Timestamp('2022-05-09 23:45:00'), Timestamp('2022-05-11 04:15:00')),\n", " (Timestamp('2022-05-11 06:15:00'), Timestamp('2022-05-11 07:00:00')),\n", " (Timestamp('2022-05-15 07:00:00'), Timestamp('2022-05-15 21:15:00')),\n", " (Timestamp('2022-05-15 22:45:00'), Timestamp('2022-05-16 15:30:00')),\n", " (Timestamp('2022-05-16 16:30:00'), Timestamp('2022-05-17 20:45:00')),\n", " (Timestamp('2022-05-18 00:30:00'), Timestamp('2022-05-18 07:00:00')),\n", " (Timestamp('2022-05-19 07:00:00'), Timestamp('2022-05-19 14:15:00')),\n", " (Timestamp('2022-05-19 15:45:00'), Timestamp('2022-05-20 07:00:00')),\n", " (Timestamp('2022-05-21 07:00:00'), Timestamp('2022-05-21 18:30:00')),\n", " (Timestamp('2022-05-21 23:15:00'), Timestamp('2022-05-23 03:30:00')),\n", " (Timestamp('2022-05-23 05:45:00'), Timestamp('2022-05-23 12:00:00')),\n", " (Timestamp('2022-05-23 13:30:00'), Timestamp('2022-05-24 07:00:00')),\n", " (Timestamp('2022-05-25 07:00:00'), Timestamp('2022-05-26 01:15:00')),\n", " (Timestamp('2022-05-26 02:15:00'), Timestamp('2022-05-26 07:00:00')),\n", " (Timestamp('2022-05-27 07:00:00'), Timestamp('2022-05-27 16:45:00')),\n", " (Timestamp('2022-05-27 21:00:00'), Timestamp('2022-05-28 07:00:00')),\n", " (Timestamp('2022-05-29 07:00:00'), Timestamp('2022-05-29 22:15:00')),\n", " (Timestamp('2022-05-29 23:15:00'), Timestamp('2022-05-30 13:45:00')),\n", " (Timestamp('2022-05-30 16:15:00'), Timestamp('2022-05-31 15:15:00')),\n", " (Timestamp('2022-05-31 19:45:00'), Timestamp('2022-06-01 15:30:00')),\n", " (Timestamp('2022-06-01 19:45:00'), Timestamp('2022-06-02 11:15:00')),\n", " (Timestamp('2022-06-02 22:15:00'), Timestamp('2022-06-03 21:00:00')),\n", " (Timestamp('2022-06-03 22:15:00'), Timestamp('2022-06-05 06:15:00')),\n", " (Timestamp('2022-06-05 06:30:00'), Timestamp('2022-06-05 22:30:00')),\n", " (Timestamp('2022-06-06 03:15:00'), Timestamp('2022-06-06 17:45:00')),\n", " (Timestamp('2022-06-06 18:15:00'), Timestamp('2022-06-07 10:30:00')),\n", " (Timestamp('2022-06-07 11:00:00'), Timestamp('2022-06-08 16:45:00')),\n", " (Timestamp('2022-06-08 19:45:00'), Timestamp('2022-06-09 07:00:00')),\n", " (Timestamp('2022-06-10 07:00:00'), Timestamp('2022-06-10 12:00:00')),\n", " (Timestamp('2022-06-10 13:30:00'), Timestamp('2022-06-11 07:00:00')),\n", " (Timestamp('2022-06-13 07:00:00'), Timestamp('2022-06-14 03:30:00')),\n", " (Timestamp('2022-06-14 04:15:00'), Timestamp('2022-06-14 13:30:00')),\n", " (Timestamp('2022-06-14 17:45:00'), Timestamp('2022-06-15 13:00:00')),\n", " (Timestamp('2022-06-15 18:30:00'), Timestamp('2022-06-16 07:00:00'))]" ] }, "metadata": {}, "execution_count": 11 } ] }, { "cell_type": "markdown", "source": [ "## 6. Visualization\n", "\n", "We've extracted lots of data, but what does it look like?\n", "\n", "In this section, we will be visualizing our three kinds of data in a simple, customizable plot! This plot is intended to provide a starter example for plotting, whereas later examples emphasize deep control and aesthetics." ], "metadata": { "id": "C8C0XU-npjwf" } }, { "cell_type": "code", "source": [ "#@title Basic Plot\n", "feature = \"brpms\" #@param [\"brpms\", \"hrs\", \"steps\"]\n", "start_date = \"2022-03-04\" #@param {type:\"date\"}\n", "time_interval = \"one day\" #@param [\"one day\", \"one week\", \"full time\"]\n", "smoothness = 0.03 #@param {type:\"slider\", min:0, max:1, step:0.01}\n", "smooth_plot = False #@param {type:\"boolean\"}\n", "\n", "import matplotlib.dates as mdates\n", "import matplotlib.pyplot as plt\n", "from datetime import datetime, timedelta\n", "\n", "start_date = datetime.strptime(start_date, '%Y-%m-%d')\n", "\n", "if time_interval == \"one day\":\n", " day_idxes = [i for i,d in enumerate(dates) if d == start_date]\n", " end_date = start_date + timedelta(days=1)\n", "elif time_interval == \"one week\":\n", " day_idxes = [i for i,d in enumerate(dates) if d >= start_date and d <= start_date + timedelta(days=7)]\n", " end_date = start_date + timedelta(days=7)\n", "elif time_interval == \"full time\":\n", " day_idxes = [i for i,d in enumerate(dates) if d >= start_date]\n", " end_date = dates[-1]\n", "\n", "if feature == \"brpms\":\n", " concat_brpms = []\n", "\n", " for i, brpm in enumerate(brpms):\n", " if i in day_idxes:\n", " concat_brpms += brpm['respirationValuesArray']\n", "\n", " ts = [datetime.fromtimestamp(x[0] / 1000) for x in concat_brpms]\n", " day_arr = [x[1] for x in concat_brpms]\n", "\n", " sigma = 200 * smoothness\n", "\n", " title_fillin = \"Breathing rates\"\n", "\n", "elif feature == \"hrs\":\n", " concat_hrs = []\n", "\n", " for i, hr in enumerate(hrs):\n", " if i in day_idxes:\n", " concat_hrs += hr['heartRateValues']\n", "\n", " ts = [datetime.fromtimestamp(x[0] / 1000) for x in concat_hrs]\n", " day_arr = [x[1] for x in concat_hrs]\n", "\n", " sigma = 200 * smoothness\n", "\n", " title_fillin = \"Heart rates\"\n", "\n", "elif feature == \"steps\":\n", " concat_steps = []\n", "\n", " for i, step in enumerate(steps):\n", " if i in day_idxes:\n", " concat_steps += step\n", "\n", " ts = [datetime.strptime(s['startGMT'], '%Y-%m-%dT%H:%M:%S') for s in concat_steps]\n", " day_arr = [s['steps'] for s in concat_steps]\n", "\n", " # \"steps\" has a weird quirk where instead of filling in missing\n", " # regions with None, it just doesn't fill them in with anything.\n", " # since matplotlib expects None values for parts of the line it\n", " # should not plot, we manually process this initial data so that\n", " # it contains None's\n", " spacing = timedelta(minutes=15)\n", " while True:\n", " for i, (ts1, ts2) in enumerate(zip(ts[:-1], ts[1:])):\n", " if (ts2 - ts1) != spacing:\n", " num_inserts = (ts2 - ts1) // spacing - 1\n", "\n", " new_ts = []\n", " new_data = []\n", "\n", " for j in range(1, num_inserts + 1):\n", " new_ts.append(ts1 + j * spacing)\n", " new_data.append(None)\n", "\n", " ts = ts[:i+1] + new_ts + ts[i+1:]\n", " day_arr = day_arr[:i+1] + new_data + day_arr[i+1:]\n", " else:\n", " break\n", "\n", " sigma = 10 * smoothness\n", " title_fillin = \"Step counts\"\n", "\n", "with plt.style.context('ggplot'):\n", " fig, ax = plt.subplots(figsize=(15, 8))\n", "\n", " if smooth_plot:\n", " def to_numpy(day_arr):\n", " arr_nonone = [x for x in day_arr if x is not None]\n", " mean_val = int(np.mean(arr_nonone))\n", " for i,x in enumerate(day_arr):\n", " if x is None:\n", " day_arr[i] = mean_val\n", "\n", " return np.array(day_arr)\n", "\n", " none_idxes = [i for i,x in enumerate(day_arr) if x is None]\n", " day_arr = to_numpy(day_arr)\n", " from scipy.ndimage import gaussian_filter\n", " day_arr = list(gaussian_filter(day_arr, sigma=sigma))\n", " for i, x in enumerate(day_arr):\n", " if i in none_idxes:\n", " day_arr[i] = None\n", "\n", " plt.plot(ts, day_arr)\n", " start_date_str = start_date.strftime('%Y-%m-%d')\n", " end_date_str = end_date.strftime('%Y-%m-%d')\n", " plt.title(f\"{title_fillin} from {start_date_str} to {end_date_str}\",\n", " fontsize=20)\n", " plt.xlabel(\"Time\")\n", " plt.ylabel(title_fillin[:-1])" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 521 }, "cellView": "form", "id": "1_n6PBSgpr2V", "outputId": "bcae9a19-9223-421b-9a16-3d08a5fe316d" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] }, { "cell_type": "markdown", "source": [ "This plot allows you to quickly scan your data at many different time scales (day, week, and full) and for different kinds of measurements (heart rate, breath rate, step count), which enables easy and fast data exploration.\n", "\n", "Furthermore, the smoothness parameter makes it easy to look for patterns in long-term trends." ], "metadata": { "id": "Av91ELOVTaNm" } }, { "cell_type": "markdown", "metadata": { "id": "M5KhQvViIsq6" }, "source": [ "# 7. Advanced Visualization\n", "\n", "Now we'll do some more advanced plotting that at times features hardcore matplotlib hacking with the benefit of aesthetic quality.\n", "\n", "Note that the timestamps that were extracted above correspond to days demarcated by midnight *not necessarily in UTC*, but rather where the user lives. To be precise, the timestamps themselves are in UTC, but the day element they belong to is determined by their location of residence.\n", "\n", "## 7.1. Calendar plot of usage / step counts over time\n", "\n", "First, it's important to know when the user has been wearing the device. That way, we know the high-level time frame for the measurements, and can know where to focus analysis on.\n", "\n", "To figure this out, we'll make a calendar plot. Fortunately, this idea is easy to execute with the use of [`july`](https://github.com/e-hulten/july/), a custom library that allows us to create beautiful calendar plots. We'll interpret step count as a proxy for usage and plot colors accordingly.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 322 }, "id": "B2mNQlfQKbp-", "outputId": "5a102a1e-9554-4920-ddb7-e0bf1c7e4781" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": { "needs_background": "light" } } ], "source": [ "# sum across hour axis\n", "import july\n", "import matplotlib.pyplot as plt\n", "\n", "# copy so we can restore the rcParams later on; july changes it\n", "IPython_default = plt.rcParams.copy()\n", "\n", "day_level_steps = [sum([x['steps'] for x in s]) / 1000 for s in steps]\n", "\n", "july.calendar_plot(dates, day_level_steps, value_label=True, weeknum_label=False, title=False)\n", "plt.suptitle('Step Count (in thousands)', fontsize=\"x-large\", y=1.03)\n", "plt.show() # suppress output from above line" ] }, { "cell_type": "markdown", "metadata": { "id": "5_NN1mHrP8Hn" }, "source": [ "This plot is very important because we are able to gain a high-level overview of the usage patterns, which informs all further analysis. If we discover that the participant has not worn their watch at all or has stopped wearing it for an extended period of time, then this is crucial information for figuring out why downstream analyses may be returning unexpected results.\n", "\n", "## 7.2. Heart rate, movement over a given day\n", "\n", "Now given this high-level information, we are equipped to dig into visualizing data from specific days. As a starter, let's reproduce this plot from the online Garmin Connect webapp. All of the code is hidden away, so simply enter whichever date you want to view the data for.\n", "\n", "\n", "\n", "*Above is a plot from the online webapp itself!*" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 467 }, "id": "rRTJ8xGBV30l", "outputId": "86bcf481-7256-4e68-e596-f036770f9620" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ], "image/png": "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\n" }, "metadata": {}, "execution_count": 14 } ], "source": [ "# get rid of any garbage output\n", "# https://stackoverflow.com/questions/56727370/how-to-suppress-output-in-google-colaboratory-cell-which-executes-a-command-line\n", "#%%capture\n", "\n", "#@title Choose a date to visualize (timezone is where the data was *collected*)\n", "date_to_visualize = \"2022-06-08\" #@param {type:\"date\"}\n", "timezone_name = \"US/Pacific\" #@param {type:\"string\"}\n", "\n", "import numpy as np\n", "import pandas as pd\n", "from datetime import timedelta\n", "\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "# restore rcParams\n", "plt.rcParams.update(IPython_default)\n", "\n", "\n", "# fetch the right day for heart rate\n", "from datetime import datetime\n", "idx = np.where(np.array([datetime.strftime(d, '%Y-%m-%d') for d in dates]) == date_to_visualize)[0][0]\n", "\n", "heart_rate_day = np.array(hrs[idx]['heartRateValues'])\n", "\n", "steps_day = steps[idx]\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import matplotlib.collections as mcoll\n", "import matplotlib.path as mpath\n", "import matplotlib.dates as mdates\n", "import matplotlib.ticker\n", "import matplotlib.patches as patches\n", "from scipy.interpolate import make_interp_spline\n", "from dateutil import parser\n", "\n", "from PIL import Image\n", "import io\n", "from IPython.core.interactiveshell import InteractiveShell\n", "from IPython.display import clear_output \n", "\n", "matplotlib.rcParams['timezone'] = timezone_name\n", "\n", "# change the background to the same grey\n", "plt.rcParams['figure.facecolor'] = '#f2f2f2'\n", "\n", "def colorline(\n", " x, y, z=None, cmap=plt.get_cmap('copper'), norm=plt.Normalize(0.0, 1.0),\n", " linewidth=3, alpha=1.0, ax=None):\n", " \"\"\"\n", " http://nbviewer.ipython.org/github/dpsanders/matplotlib-examples/blob/master/colorline.ipynb\n", " http://matplotlib.org/examples/pylab_examples/multicolored_line.html\n", " Plot a colored line with coordinates x and y\n", " Optionally specify colors in the array z\n", " Optionally specify a colormap, a norm function and a line width\n", " \"\"\"\n", "\n", " # Default colors equally spaced on [0,1]:\n", " if z is None:\n", " z = np.linspace(0.0, 1.0, len(x))\n", "\n", " # Special case if a single number:\n", " if not hasattr(z, \"__iter__\"): # to check for numerical input -- this is a hack\n", " z = np.array([z])\n", "\n", " z = np.asarray(z)\n", "\n", " segments = make_segments(x, y)\n", " lc = mcoll.LineCollection(segments, array=z, cmap=cmap, #norm=norm,\n", " linewidth=linewidth, alpha=alpha)\n", "\n", " ax = plt.gca()\n", "\n", " ax.add_collection(lc)\n", "\n", " return lc\n", "\n", "\n", "def make_segments(x, y):\n", " \"\"\"\n", " Create list of line segments from x and y coordinates, in the correct format\n", " for LineCollection: an array of the form numlines x (points per line) x 2 (x\n", " and y) array\n", " \"\"\"\n", "\n", " points = np.array([x, y]).T.reshape(-1, 1, 2)\n", " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", " return segments\n", "\n", "\n", "fig = plt.figure(figsize=(14,6))\n", "\n", "start = parser.parse(date_to_visualize + ' 00:00:00-07:00')\n", "\n", "heart_rate_day = np.concatenate([\n", " [[int(start.timestamp() * 1000), None]],\n", " heart_rate_day\n", "])\n", "\n", "\n", "datetimes = [datetime.fromtimestamp(x // 1000) for x in heart_rate_day[:,0]]\n", "\n", "datetimes_num = [mdates.date2num(x) for x in datetimes]\n", "\n", "heart_rate_day_imputed = [x for x in heart_rate_day[:,1]]\n", "\n", "heart_rate_day_imputed = [None] + heart_rate_day_imputed\n", "\n", "for i, x in enumerate(heart_rate_day_imputed):\n", " if x is None:\n", " heart_rate_day_imputed[i] = 0\n", "\n", "colorline(datetimes_num, heart_rate_day[:,1], np.array(heart_rate_day_imputed),\n", " cmap=plt.get_cmap('Blues'), linewidth=3)\n", "\n", "ax = plt.gca()\n", "\n", "steps_day_vals = np.array([x['steps'] for x in steps_day])\n", "\n", "# smooth out and plot out on a minute basis\n", "df = pd.DataFrame(columns=['datetime', 'steps_scaled'])\n", "\n", "df.datetime = [parser.parse(x['startGMT']) for x in steps_day]\n", "df.steps_scaled = steps_day_vals / 8 + 20\n", "\n", "index_minutely = pd.date_range(df.datetime.iloc[0], df.datetime.iloc[-1], freq='1T')\n", "spl = make_interp_spline(df.datetime, df.steps_scaled, k=3)\n", "y_smooth = spl(index_minutely)\n", "\n", "y_smooth = np.clip(y_smooth, 20, np.inf)\n", "\n", "plt.fill_between(index_minutely, y_smooth, 20, edgecolor='#aeeaff',\n", " facecolor='#d8f5ff', linewidth=1)\n", "\n", "start = mdates.date2num(parser.parse(date_to_visualize + ' 00:00:00-07:00'))\n", "end = mdates.date2num(parser.parse(date_to_visualize + ' 00:00:00-07:00') + timedelta(days=1))\n", "\n", "# phantom rectangle to create space above the plot title\n", "fig.patches.extend([patches.Rectangle((66.5, 400),\n", " 100, 60, facecolor='#f2f2f2', zorder=-999999)])\n", "\n", "# phantom rectangle to deal with the fact that the rectangle written\n", "# just below creates a huge area of space to the left, so we equalize\n", "# on the right with a phantom rectangle\n", "fig.patches.extend([patches.Rectangle((66.5, 10),\n", " 900, 50, facecolor='#f2f2f2', zorder=-999999)])\n", "\n", "# rectangle to extend white background of the axis down further\n", "# so that the ticks are not cut off\n", "fig.patches.extend([patches.Rectangle((66.5, 10),\n", " 781.5, 50, facecolor='white', zorder=-999999)])\n", "\n", "plt.xticks(ticks=np.linspace(start, end, 5), labels=['12a', '6a', '12p', '6p', '12a'])\n", "\n", "plt.tick_params(\n", " axis='x',\n", " which='both',\n", " labelsize=15,\n", " labelcolor='silver',\n", " width=0 # set width to zero so that the ticks themselves are invisible\n", ")\n", "\n", "# just don't have any y ticks\n", "ax.set_yticks(ticks=[])\n", "ax.set_yticklabels([])\n", "\n", "TICKYPOS = 4\n", "\n", "for tick_x in np.linspace(start, end, 5):\n", " r = 10\n", " # for some reason, width should be .001x of the height for it\n", " # to be a circle\n", "\n", " ax.add_patch(patches.Ellipse((tick_x,TICKYPOS), .001 * r, 1 * r,\n", " fill=True,clip_on=False, color='silver'))\n", "\n", "\n", "# pseudo-minor ticks\n", "for tick_x in np.linspace(start, end, 5 * 5):\n", " r = 5\n", " # for some reason, width should be .001x of the height for it\n", " # to be a circle\n", "\n", " ax.add_patch(patches.Ellipse((tick_x,TICKYPOS), .0015 * r, 1 * r,\n", " fill=True,clip_on=False, color='silver'))\n", "\n", "\n", "# hide the borders of the box (https://stackoverflow.com/questions/9750699/how-to-display-only-a-left-and-bottom-box-border-in-matplotlib)\n", "for side in ['left', 'right', 'top', 'bottom']:\n", " ax.spines[side].set_visible(False)\n", "\n", "plt.xlim(datetimes[0] - timedelta(hours=1),\n", " datetimes[0] + timedelta(days=1) + timedelta(hours=1))\n", "\n", "date_to_visualize_fmted = datetime.strftime(datetime.strptime(date_to_visualize, '%Y-%m-%d'), '%A, %B %-d, %Y')\n", "\n", "plt.title(f'{date_to_visualize_fmted}' + ' ' * 72, loc='left',\n", " fontsize=22, color='#095bce', pad=40)#, bbox={'facecolor':'white', 'edgecolor': 'white', 'alpha':1.0, 'pad':4})\n", "\n", "ax.set_ylim(0, 400)\n", "\n", "# ok this is super convoluted but what we're doing here is\n", "# reaching super super deep into the matplotlib stack, actually deeper than matplotlib.\n", "# we fetch the *backend renderer* (the thing that takes a fig object and turns it into pixels\n", "# to display on the interactive colab screen), run it on the fig object as would be done\n", "# when doing inline matplotlib in any other case, open the PNG bytestring, crop it,\n", "# then display this cropped image. the reason why we need to do this is because usually\n", "# as a user of matplotlib all we can control is the fig object, but not how it's rendered (which means\n", "# we can't actually crop it unfortunately).\n", "\n", "# TL;DR: can't crop via matplotlib interface, so we render the figure ourselves\n", "# manually and crop it afterwards\n", "\n", "colab_output_as_png_bytes = InteractiveShell.instance().display_formatter.formatters['image/png'](fig)\n", "\n", "img = Image.open(io.BytesIO(colab_output_as_png_bytes))\n", "\n", "# crop out the fat borders on the left and right\n", "cropped = img.crop((50, 0, 860, 450))\n", "\n", "# delete the figure used to construct the img above\n", "plt.figure(plt.get_fignums()[0]).clear()\n", "\n", "# make sure there is no garbage output\n", "plt.show()\n", "clear_output()\n", "\n", "# display the cropped image\n", "cropped" ] }, { "cell_type": "markdown", "metadata": { "id": "YMdqlfJGEJIx" }, "source": [ "*Above is a plot we created ourselves!*\n", "\n", "This plot is important because it allows us to dive deep into the fine-grained heart rates throughout a given day. This gives you a very quick at-a-glance idea of what the heart rate patterns for this user look like at the scale of a single day, which cannot be determined from an aggregate plot (such as the calendar one above).\n", "\n", "## 7.3. Breath rate over a given day\n", "\n", "Next, we will reproduce the below plot that you can see in the Garmin Connect webapp.\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": { "base_uri": "https://localhost:8080/", "height": 457 }, "id": "Dq2AuNspOEWg", "outputId": "b9d01a65-e80a-45c3-e79e-9dabedd04e65" }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "# get rid of any garbage output\n", "# https://stackoverflow.com/questions/56727370/how-to-suppress-output-in-google-colaboratory-cell-which-executes-a-command-line\n", "#%%capture\n", "\n", "#@title Choose a date to visualize (timezone is where the data was *collected*)\n", "date_to_visualize = \"2022-06-08\" #@param {type:\"date\"}\n", "timezone_name = \"US/Pacific\" #@param {type:\"string\"}\n", "\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "# restore rcParams\n", "plt.rcParams.update(IPython_default)\n", "\n", "\n", "# fetch the right day for heart rate\n", "from datetime import datetime\n", "idx = np.where(np.array([datetime.strftime(d, '%Y-%m-%d') for d in dates]) == date_to_visualize)[0][0]\n", "\n", "heart_rate_day = np.array(hrs[idx]['heartRateValues'])\n", "\n", "heart_rate_day = np.array(brpms[idx]['respirationValuesArray'])\n", "\n", "steps_day = steps[idx]\n", "\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import matplotlib.collections as mcoll\n", "import matplotlib.path as mpath\n", "import matplotlib.dates as mdates\n", "import matplotlib.ticker\n", "import matplotlib.patches as patches\n", "from scipy.interpolate import make_interp_spline\n", "from dateutil import parser\n", "\n", "from PIL import Image\n", "import io\n", "from IPython.core.interactiveshell import InteractiveShell\n", "from IPython.display import clear_output \n", "\n", "matplotlib.rcParams['timezone'] = timezone_name\n", "\n", "# change the background to the same grey\n", "plt.rcParams['figure.facecolor'] = 'white'\n", "\n", "fig = plt.figure(figsize=(14,6))\n", "\n", "start = parser.parse(date_to_visualize + ' 00:00:00-07:00')\n", "\n", "heart_rate_day = np.concatenate([\n", " [[int(start.timestamp() * 1000), None]],\n", " heart_rate_day\n", "])\n", "\n", "\n", "datetimes = [datetime.fromtimestamp(x // 1000) for x in heart_rate_day[:,0]]\n", "\n", "datetimes_num = [mdates.date2num(x) for x in datetimes]\n", "\n", "heart_rate_day_imputed = [x for x in heart_rate_day[:,1]]\n", "\n", "heart_rate_day_imputed = [None] + heart_rate_day_imputed\n", "\n", "for i, x in enumerate(heart_rate_day_imputed):\n", " if x is None:\n", " heart_rate_day_imputed[i] = 0\n", "\n", "heart_rate_day_imputed = np.array(heart_rate_day_imputed)\n", "\n", "# get the contiguous regions in heart_rate_day to plot\n", "# these separately\n", "empty_idxes = np.where(heart_rate_day_imputed[1:] >= 0)[0]\n", "\n", "regions = []\n", "\n", "cur_region_start = -1\n", "\n", "cur_region_end = -1\n", "\n", "for idx1, idx2 in zip(empty_idxes[:-1], empty_idxes[1:]):\n", " if cur_region_start == -1:\n", " cur_region_start = idx1\n", " cur_region_end = idx2\n", " \n", " if idx2 - idx1 > 1:\n", " cur_region_end = idx1\n", " # add 1 to account for extra dummy entry in heart_rate_day\n", " # at the beginning\n", " regions.append((cur_region_start+1, cur_region_end+1))\n", "\n", " cur_region_start = -1\n", " cur_region_end = -1\n", "else:\n", " # special condition for last region\n", " regions.append((cur_region_start+1, empty_idxes.shape[0]))\n", "\n", "for region_start, region_end in regions:\n", " plt.plot(datetimes_num[region_start:region_end],\n", " heart_rate_day[region_start:region_end],\n", " linewidth=3, color='#00f5f8')\n", "\n", "ax = plt.gca()\n", "\n", "steps_day_vals = np.array([x['steps'] for x in steps_day])\n", "\n", "# smooth out and plot out on a minute basis\n", "df = pd.DataFrame(columns=['datetime', 'steps_scaled'])\n", "\n", "df.datetime = [parser.parse(x['startGMT']) for x in steps_day]\n", "df.steps_scaled = steps_day_vals / 8 + 20\n", "\n", "index_minutely = pd.date_range(df.datetime.iloc[0], df.datetime.iloc[-1], freq='1T')\n", "spl = make_interp_spline(df.datetime, df.steps_scaled, k=3)\n", "y_smooth = spl(index_minutely)\n", "\n", "y_smooth = np.clip(y_smooth, 20, np.inf)\n", "\n", "#plt.fill_between(index_minutely, y_smooth, 20, edgecolor='#aeeaff',\n", " #facecolor='#d8f5ff', linewidth=1)\n", "\n", "start = mdates.date2num(parser.parse(date_to_visualize + ' 00:00:00-07:00'))\n", "end = mdates.date2num(parser.parse(date_to_visualize + ' 00:00:00-07:00') + timedelta(days=1))\n", "\n", "# phantom rectangle to create space above the plot title\n", "fig.patches.extend([patches.Rectangle((66.5, 400),\n", " 100, 60, facecolor='white', zorder=-999999)])\n", "\n", "# phantom rectangle to deal with the fact that the rectangle written\n", "# just below creates a huge area of space to the left, so we equalize\n", "# on the right with a phantom rectangle\n", "#fig.patches.extend([patches.Rectangle((66.5, 10),\n", "# 900, 50, facecolor='#f2f2f2', zorder=-999999)])\n", "\n", "# rectangle to extend white background of the axis down further\n", "# so that the ticks are not cut off\n", "#fig.patches.extend([patches.Rectangle((66.5, 10),\n", "# 781.5, 50, facecolor='white', zorder=-999999)])\n", "\n", "plt.xticks(ticks=np.linspace(start, end, 5), labels=['12a', '6a', '12p', '6p', '12a'])\n", "\n", "plt.tick_params(\n", " axis='x',\n", " which='both',\n", " labelsize=12,\n", " labelcolor='silver',\n", " width=0 # set width to zero so that the ticks themselves are invisible\n", ")\n", "\n", "# just don't have any y ticks\n", "plt.yticks(ticks=[4,8,12,16,20,24], labels=['','8','12','16','20','24'])\n", "plt.tick_params(\n", " axis='y',\n", " which='both',\n", " color='gainsboro',\n", " labelsize=12\n", ")\n", "#ax.set_yticks(ticks=[])\n", "#ax.set_yticklabels([])\n", "\n", "TICKYPOS = 1\n", "\n", "for tick_x in np.linspace(start, end, 5):\n", " r = 10\n", " # for some reason, width should be .001x of the height for it\n", " # to be a circle\n", "\n", " #ax.add_patch(patches.Rectangle((tick_x, TICKYPOS), 10, 10, linewidth=1, edgecolor='black', facecolor='black'))\n", "\n", " ax.add_patch(patches.Ellipse((tick_x,TICKYPOS), .0015 * r, .1 * r,\n", " fill=True,clip_on=False, color='silver'))\n", "\n", "\n", "# pseudo-minor ticks\n", "for tick_x in np.linspace(start, end, 5 * 5):\n", " r = 5\n", " # for some reason, width should be .001x of the height for it\n", " # to be a circle\n", "\n", " ax.add_patch(patches.Ellipse((tick_x,TICKYPOS), .0015 * r, .1 * r,\n", " fill=True,clip_on=False, color='silver'))\n", "\n", "\n", "# hide the borders of the box (https://stackoverflow.com/questions/9750699/how-to-display-only-a-left-and-bottom-box-border-in-matplotlib)\n", "for side in ['left', 'right', 'top', 'bottom']:\n", " ax.spines[side].set_visible(False)\n", "\n", "plt.xlim(datetimes[0] - timedelta(hours=1),\n", " datetimes[0] + timedelta(days=1) + timedelta(hours=1))\n", "\n", "date_to_visualize_fmted = datetime.strftime(datetime.strptime(date_to_visualize, '%Y-%m-%d'), '%A, %B %-d, %Y')\n", "\n", "plt.title(f'{date_to_visualize_fmted}' + ' ' * 72, loc='left',\n", " fontsize=22, color='#095bce', pad=40)#, bbox={'facecolor':'white', 'edgecolor': 'white', 'alpha':1.0, 'pad':4})\n", "\n", "ax.set_ylim(0, 30)\n", "\n", "#plt.grid()\n", "#ax.yaxis.grid(which=\"major\", color='r', linestyle='-', linewidth=2, zorder=999999999999)\n", "#ax.grid(b=True, which='major', color='b', linestyle='-')\n", "plt.grid(color='gainsboro', which='major', axis='y', linestyle='solid')\n", "\n", "#ax.xaxis.grid()\n", "#ax.grid(True)\n", "#ax.grid(axis='x', zorder=0)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "id": "yzlY6g0vKrKn" }, "source": [ "*Above is a plot we created ourselves!*\n", "\n", "As you can see, we're able to recover visualizations from the webapp pretty flawlessly!\n", "\n", "This plot is important for the same reason that the heart rate plot is important: it allows us to see what the participant's breathing rate is throughout a given day, which gives us a granularity of data visualization that we are otherwise unable to obtain." ] }, { "cell_type": "markdown", "source": [ "# 8. Outlier Detection and Data Cleaning\n", "\n", "In this section, we will detect outliers in our extracted data and impute them.\n", "\n", "Since there are currently no outliers (by construction, since it is simulated to have none), we will manually inject a couple." ], "metadata": { "id": "9d3KbewTtkbi" } }, { "cell_type": "code", "source": [ "hrs[0]['heartRateValues'][5][1] = 5\n", "brpms[0]['respirationValuesArray'][52][1] = 92" ], "metadata": { "id": "vE5mtbF2zM2T" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "Now that we've manually injected them, let's demonstrate that we can detect these.\n", "\n", "We will use a simple statistical method for detecting outliers. Specifically, we will rely on the assumption that heart rate and breath rate signals roughly do not change very much from one timestep to the next, and that if there is one measurement that very clearly sticks up much higher than the rest surrounding it, then it is likely an outlier.\n", "\n", "We will capture this notion by computing a convolution across both arrays with the kernel `[-1 2 -1]`. If the signal does not change at all, then this will return 0, and this is what we would expect under normal conditions. However, if there is a clear outlier, then it will return a very large number." ], "metadata": { "id": "krthBdM1zeXQ" } }, { "cell_type": "code", "source": [ "hrs_concat = []\n", "\n", "for hr in hrs:\n", " hrs_concat += hr['heartRateValues']\n", "\n", "brpms_concat = []\n", "for brpm in brpms:\n", " brpms_concat += brpm['respirationValuesArray']\n", "\n", "def get_conv_outs(concat_arr):\n", " conv_outs = []\n", "\n", " for i, (x1, x2, x3) in enumerate(zip(concat_arr[:-2], concat_arr[1:-1], concat_arr[2:])):\n", " if x2[0] - x1[0] == x3[0] - x2[0] == 120000 and all([x[1] is not None for x in [x1,x2,x3]]):\n", " conv_out = x1[1] * (-1) + x2[1] * 2 + x3[1] * (-1)\n", "\n", " conv_outs.append([i + 1, conv_out])\n", "\n", " conv_outs = np.array(conv_outs)\n", "\n", " return conv_outs\n", "\n", "conv_brpms = get_conv_outs(brpms_concat)\n", "conv_hrs = get_conv_outs(hrs_concat)" ], "metadata": { "id": "VVe-4k-j7fSC" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "Now let's fit a Gaussian to it and calculate the Z-scores for each entry." ], "metadata": { "id": "ykJf16l1-B9f" } }, { "cell_type": "code", "source": [ "res_hrs_mean = conv_hrs[:,1].mean()\n", "res_hrs_std = conv_hrs[:,1].std()\n", "\n", "res_brpms_mean = conv_brpms[:,1].mean()\n", "res_brpms_std = conv_brpms[:,1].std()" ], "metadata": { "id": "z11Ydoaj9_Wu" }, "execution_count": null, "outputs": [] }, { "cell_type": "markdown", "source": [ "We will find any elements that deviate by more than $6\\sigma$ from the mean, consider these outliers, and impute their value in the original data." ], "metadata": { "id": "vez22yq1-UO6" } }, { "cell_type": "code", "source": [ "def get_orig_idxes(conv_arr, res_mean, res_std):\n", "\n", " idxes = np.where(np.logical_or(conv_arr[:,1] > res_mean + 6 * res_std, conv_arr[:,1] < res_mean - 6 * res_std))[0]\n", "\n", " # we assume that there are always three contiguous idxes that\n", " # get flagged\n", " i = 1\n", " orig_idxes = []\n", " while i < len(idxes):\n", " orig_idx = conv_arr[idxes[i], 0]\n", " orig_idxes.append(orig_idx)\n", " i += 3\n", "\n", " return orig_idxes\n", "\n", "orig_idxes_hrs = get_orig_idxes(conv_hrs, res_hrs_mean, res_hrs_std)\n", "orig_idxes_brpms = get_orig_idxes(conv_brpms, res_brpms_mean, res_brpms_std)" ], "metadata": { "id": "S2S6HqTK-T2c" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "ts = [brpms_concat[orig_idx][0] for orig_idx in orig_idxes_brpms]\n", "\n", "ctx_length = 10\n", "\n", "for i, brpm in enumerate(brpms):\n", " cur_arr = np.array(brpm['respirationValuesArray'])\n", " idxes = np.where(np.in1d(cur_arr[:,0], ts))[0]\n", "\n", " if len(idxes) == 1:\n", " idx = idxes[0]\n", " ctx = np.concatenate((cur_arr[idx-ctx_length:idx,1], cur_arr[idx+1:idx+1+ctx_length,1]))\n", " mean_val = int(np.mean(ctx))\n", " print(f'replacing {brpms[i][\"respirationValuesArray\"][idx]} with {mean_val}, obtained by averaging around it')\n", " print(f'index in brpms array is {i} and index within that is {idx}')\n", " brpms[i]['respirationValuesArray'][idx][1] = mean_val\n", "\n", "\n", "ts = [hrs_concat[orig_idx][0] for orig_idx in orig_idxes_hrs]\n", "\n", "for i, hr in enumerate(hrs):\n", " cur_arr = np.array(hr['heartRateValues'])\n", " idxes = np.where(np.in1d(cur_arr[:,0], ts))[0]\n", "\n", " if len(idxes) == 1:\n", " idx = idxes[0]\n", " ctx = np.concatenate((cur_arr[idx-ctx_length:idx,1], cur_arr[idx+1:idx+1+ctx_length,1]))\n", " mean_val = int(np.mean(ctx))\n", " print(f'replacing {hrs[i][\"heartRateValues\"][idx]} with {mean_val}, obtained by averaging around it')\n", " print(f'index in hrs array is {i} and index within that is {idx}')\n", " hrs[i]['heartRateValues'][idx][1] = mean_val\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "ykXDpLCx-vUV", "outputId": "20fbba66-da11-4f2c-9335-b5021df3e2e5" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "replacing [1646124240000, 92] with 17, obtained by averaging around it\n", "index in brpms array is 0 and index within that is 52\n", "replacing [1646118600000, 5] with 124, obtained by averaging around it\n", "index in hrs array is 0 and index within that is 5\n" ] } ] }, { "cell_type": "markdown", "source": [ "And we have properly cleaned up this data of outliers!\n", "\n", "Disclaimer: though this code is capable of catching the outliers we injected ourselves, in your specific situation there may be outliers this does not catch." ], "metadata": { "id": "g-Ckc4VSFMcM" } }, { "cell_type": "markdown", "source": [ "# 9. Data Analysis\n", "\n", "Data isn't much without some analysis, so we're going to do some in this section.\n", "\n", "DISCLAIMER: do not use the analyses below as evidence supporting any scientific claims. These analyses are purely intended for educational purposes." ], "metadata": { "id": "F7XYmhQDtjQC" } }, { "cell_type": "markdown", "metadata": { "id": "NJZzciFLvwKO" }, "source": [ "## 9.1. Heart rate vs. activity\n", "\n", "This first analysis will be a sanity check to make sure that indeed heart rate does increase when more steps are taken (and thus there is more activity). To be more specific, we would like to test the hypothesis that a higher step count is associated with a higher heart rate.\n", "\n", "First, to get an intuitive understanding of the data, we can aggregate all of the datapoints and show a scatterplot of heart rates and step counts. This will take a bit of data manipulation, as step measurements are sampled only every 15 minutes and contain a count, whereas heart rate measurements are distinct measurements taken every 2 minutes.\n", "\n", "To do this, we'll find every instance of a 15 minute interval that has (1) a recorded step count and (2) at least 3 heart rate measurements (we choose 3 arbitrarily, but should be enough to have enough certainty about the true heart rate throughout this time period). This means that, in the end, we'll have a set of tuples $x_i$, where each tuple $x_i$ contains the step count for the given 15 minute interval and a list of heart rates. We'll choose to take the median of the list of heart rates, so we'll end up with tuples $(\\text{step count}, \\text{median heart rate})$." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1Y3rYv5IjEo7", "outputId": "dd6455ee-0aaf-47c0-ee23-7aec929839f7" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "100%|██████████| 79/79 [00:00<00:00, 1761.72it/s]\n", "100%|██████████| 79/79 [00:00<00:00, 146.93it/s]\n" ] } ], "source": [ "from tqdm import tqdm\n", "from dateutil import parser\n", "\n", "# flatten all the heart rate data\n", "\n", "all_hrs_flat = []\n", "for hr_arr in tqdm(hrs):\n", " if hr_arr['heartRateValues'] is None:\n", " continue\n", "\n", " hr_vals = np.array(hr_arr['heartRateValues'])\n", "\n", " if None in hr_vals[:,1]:\n", " while True:\n", " # keep consuming None's until we've run out\n", " idxes = np.where(hr_vals[:, 1] == None)[0]\n", "\n", " if len(idxes) == 0:\n", " break\n", " \n", " idx = idxes[0]\n", "\n", " hr_vals = np.concatenate([hr_vals[:idx], hr_vals[idx+1:]])\n", "\n", "\n", " all_hrs_flat += list(hr_vals)\n", "\n", "all_hrs_flat = np.array(all_hrs_flat)\n", "\n", "# flatten all the steps data\n", "\n", "all_steps_flat = []\n", "\n", "for step_day in tqdm(steps):\n", " all_steps_flat += [[int(parser.parse(x['startGMT']).timestamp() * 1000), x['steps']] for x in step_day]\n", "\n", "all_steps_flat = np.array(all_steps_flat)" ] }, { "cell_type": "markdown", "metadata": { "id": "wg_R8IaLozHy" }, "source": [ "Now that we have flattened step and heart rate data, we can cross-reference and find heart rate measurements corresponding to particular 15 minute intervals!" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "yqFp_S6OmMQ6", "outputId": "9691ed1e-e615-440d-da24-b317e917708b" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "100%|██████████| 6677/6677 [00:41<00:00, 162.28it/s]\n" ] } ], "source": [ "cooccurrences = []\n", "\n", "for step_start, step_count in tqdm(all_steps_flat):\n", " coreference = np.where(np.logical_and(all_hrs_flat[:,0] - step_start >= 0, all_hrs_flat[:,0] - step_start <= 15 * 60 * 1000))[0]\n", "\n", " hr_15_minutes = all_hrs_flat[coreference, 1]\n", "\n", " if len(coreference) >= 3:\n", " cooccurrences.append([step_count, hr_15_minutes])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "8NnfJEgqsjoc" }, "outputs": [], "source": [ "cooccurrences_median = np.vstack([[x[0] for x in cooccurrences], [np.median(x[1]) for x in cooccurrences]]).T\n", "df = pd.DataFrame(cooccurrences_median, columns=['Step count', 'Median heart rate'])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 459 }, "id": "uowmXKaRtNmn", "outputId": "af0a13c2-5581-4290-f3fd-ed1f57f18b79" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 24 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "import seaborn as sns\n", "\n", "sns.jointplot(x='Step count', y='Median heart rate', data=df)" ] }, { "cell_type": "markdown", "metadata": { "id": "QpHMDx1rtoxh" }, "source": [ "Looks like there is indeed a trend here, but an aggressive critic might argue that it could result from chance. To provide strong quantitative evidence in favor of our claim, which is that the null hypothesis (higher step counts do not have higher heart rates) is indeed false, we perform the Wald test, which addresses this setting precisely." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "mPeYV15Xt4nJ", "outputId": "42df6289-9766-4369-dd03-65a9d7c859bc" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Slope: 0.0299\n", "Coefficient of determination: 0.988\n", "p-value: 0\n" ] } ], "source": [ "from scipy import stats\n", "slope, intercept, r_value, p_value, std_err = stats.linregress(df['Step count'],\n", " df['Median heart rate'],\n", " alternative='greater')\n", "\n", "print(f'Slope: {slope:.3g}')\n", "print(f'Coefficient of determination: {r_value**2:.3g}')\n", "print(f'p-value: {p_value:.3g}')" ] }, { "cell_type": "markdown", "metadata": { "id": "PPER-Gq6wNmG" }, "source": [ "As we can see, the p-value, or the probability that assuming the slope is zero that we have obtained a slope of at least this magnitude, is extremely small <\\.05, so this is a significant result and we can thus reject the null hypothesis that higher step counts are not associated with higher heart rates." ] }, { "cell_type": "markdown", "metadata": { "id": "zuoC_UUwwH8e" }, "source": [ "## 9.2. Heart rate vs. breaths per minute\n", "\n", "We may also be interested in understanding the relationship between the number of breaths the user takes per minute and the corresponding heart rate. In this situation, we would probably expect higher heart rates to be associated with a higher breath rate.\n", "\n", "To get an intuitive idea of the data, we first plot it out.\n", "\n", "To do this, we cross-reference heart rates and breaths per minutes extracted earlier in a similar way to what was done for section 9.1. Specifically, we first flatten the `brpms` array we extracted earlier." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AiSkAKCp3V3E", "outputId": "1472f430-d6ae-4509-d509-623e833de934" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "100%|██████████| 79/79 [00:00<00:00, 65034.35it/s]\n" ] } ], "source": [ "brpms_flat = []\n", "\n", "for brpm_dict in tqdm(brpms):\n", " if brpm_dict['respirationValuesArray'] is not None and len(brpm_dict['respirationValuesArray']) > 0:\n", " brpms_flat += brpm_dict['respirationValuesArray']\n", "\n", "brpms_flat = np.array(brpms_flat, dtype='object')" ] }, { "cell_type": "markdown", "metadata": { "id": "Jk1UYJj_8DZG" }, "source": [ "Now that we've flattened it, we must cross-reference. Note that though the breathing rate and heart rate could be sampled at different times, complicating the analysis, we conveniently have that >99% of the heart rate measurements have a one-to-one corresponding breathing rate per minute measurement recorded at exactly the same time (see below). (Note: in the synthetic case, we just generated data that had 100% correspondence)\n", "\n", "Therefore, we can just correlate as done in the simple case." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "nHfipRZY5dPG", "outputId": "add22d00-c771-4a58-fd54-88e7737caf66" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "50102it [00:00, 467325.11it/s]" ] }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "% of heart rate measurements with no corresponding brpm: 0%\n" ] }, { "output_type": "stream", "name": "stderr", "text": [ "\n" ] } ], "source": [ "mismatch_count = 0\n", "\n", "double_list = []\n", "if synthetic:\n", " for i, (hr_timestamp, hr) in tqdm(enumerate(all_hrs_flat)):\n", " double_list.append([hr, brpms_flat[i][1]])\n", "else:\n", " for hr_timestamp, hr in tqdm(all_hrs_flat):\n", " match_idxes = np.where(np.abs(brpms_flat[:,0] - hr_timestamp) == 0)[0]\n", " if len(match_idxes) == 0:\n", " mismatch_count += 1\n", " continue\n", "\n", " assert(len(match_idxes) == 1)\n", "\n", " double_list.append([hr, brpms_flat[match_idxes[0]][1]])\n", "\n", "print(f'\\n% of heart rate measurements with no corresponding brpm: {mismatch_count / len(all_hrs_flat) * 100:.3g}%')" ] }, { "cell_type": "markdown", "metadata": { "id": "0KZeL4PdwkCR" }, "source": [ "Let's plot this out to see what it looks like." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 412 }, "id": "AgB9YC13cS5b", "outputId": "cf7a1826-c5a9-470f-b26e-7fd21e3f8e2a" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "" ] }, "metadata": {}, "execution_count": 28 }, { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "sns.set(rc = {'figure.figsize':(18,6)})\n", "\n", "df = pd.DataFrame(double_list, columns=['Heart rate', 'Breaths per minute'])\n", "\n", "# filter out seemingly missing values for breaths\n", "df = df[df['Breaths per minute'] > 0]\n", "\n", "sns.boxplot(y='Heart rate', x='Breaths per minute', data=df)" ] }, { "cell_type": "markdown", "metadata": { "id": "rLE9mZFXxB_w" }, "source": [ "Looks like there's a correlation! Let's verify that it is not due to chance now. To be precise, our null hypothesis in this situation is that heart rates do not increase as breaths per minute increase. Again, as was the case before, we use the Wald test, which addresses exactly this setting." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "x-qHvXk9wvLE", "outputId": "8712edd5-bdfd-4cab-c88a-f0bd9f36f8a9" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Slope: 0.0151\n", "Coefficient of determination: 0.0223\n", "p-value: 1.77e-247\n" ] } ], "source": [ "from scipy import stats\n", "slope, intercept, r_value, p_value, std_err = stats.linregress(df['Heart rate'],\n", " df['Breaths per minute'],\n", " alternative='greater')\n", "\n", "print(f'Slope: {slope:.3g}')\n", "print(f'Coefficient of determination: {r_value**2:.3g}')\n", "print(f'p-value: {p_value:.3g}')" ] }, { "cell_type": "markdown", "source": [ "We see that the p-value is low (\\<0.05), so we can reject the null hypothesis and conclude that higher breath rates are linked to higher heart rates." ], "metadata": { "id": "bXwChmTfTEuL" } } ], "metadata": { "colab": { "provenance": [] }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 0 }