project-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dc34c21d-7d25-445b-b2be-8eea06fec296",
   "metadata": {},
   "source": [
    "# Project 1: Processing health and activity data [40 marks]\n",
    "\n",
    "---\n",
    "\n",
    "Make sure you read the instructions in `README.md` before starting! In particular, make sure your code is well-commented, with sensible structure, and easy to read throughout your notebook.\n",
    "\n",
    "---\n",
    "\n",
    "The MMASH dataset [1, 2] is is a dataset of health- and activity-related measurements taken on 22 different people, over a continuous period of 24 hours, using wearable devices.\n",
    "\n",
    "In this project, we have provided you with some of this data for **10** of those individuals. In the `dataset` folder, you will find:\n",
    "\n",
    "- a file `subject_info.txt` which summarises the age (in years), height (in cm), and weight (in kg) of all 10 study participants,\n",
    "- 10 folders named `subject_X`, which each contain two files:\n",
    "    - `heartbeats.txt` contains data on all individual heartbeats detected over the 24-hour study period,\n",
    "    - `actigraph.txt` contains heart rate and other activity data measured with another device, over the same 24-hour period.\n",
    "\n",
    "The tasks below will guide you through using your Python skills to process some of this data. Note that the data was reformatted slightly for the purpose of the assignment (to make your life a bit easier!), but the values are all the original ones from the real dataset.\n",
    "\n",
    "### Getting stuck\n",
    "\n",
    "Tasks 3 to 8 follow directly from each other. There is a `testing` folder provided for you with `.npy` files and a supplementary `actigraph.txt` dataset. The `.npy` files are NumPy arrays, which you can load directly using `np.load()`, containing an example of what the data should look like after each task. You will be able to use this example data to keep working on the later tasks, even if you get stuck on an earlier task. Look out for the 💾 instructions under each task.\n",
    "\n",
    "These were produced using the data for another person which is not part of the 10 you have in your dataset.\n",
    "\n",
    "\n",
    "### References\n",
    "\n",
    "[1] Rossi, A., Da Pozzo, E., Menicagli, D., Tremolanti, C., Priami, C., Sirbu, A., Clifton, D., Martini, C., & Morelli, D. (2020). Multilevel Monitoring of Activity and Sleep in Healthy People (version 1.0.0). PhysioNet. https://doi.org/10.13026/cerq-fc86\n",
    "\n",
    "[2] Rossi, A., Da Pozzo, E., Menicagli, D., Tremolanti, C., Priami, C., Sirbu, A., Clifton, D., Martini, C., & Morelli, D. (2020). A Public Dataset of 24-h Multi-Levels Psycho-Physiological Responses in Young Healthy Adults. Data, 5(4), 91. https://doi.org/10.3390/data5040091.\n",
    "\n",
    "---\n",
    "## Task 1: Reading the subject information\n",
    "\n",
    "The file `subject_info.txt` in your `dataset` folder summarises the age (in years), height (in cm), and weight (in kg) of all 10 study participants.\n",
    "\n",
    "---\n",
    "🚩 ***Task 1:*** Write a function `read_subject_info()` which reads in the information in `subject_info.txt`, and returns two outputs:\n",
    "\n",
    "- a list `headers` containing the four column headers as strings, read from the first line in the file;\n",
    "- a NumPy array `info` containing the numerical information for each person (i.e. it should have 10 rows and 4 columns).\n",
    "\n",
    "**Important:** the height of each subject should be given in **metres** in your `info` array.\n",
    "\n",
    "**[3 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05c5d7f2-364a-4bbf-9829-4caebd9c3f7e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_subject_info():\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5145e0d1-4dda-415f-9b05-cfd12e69523a",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 2: Charting the Body Mass Index (BMI) for all participants\n",
    "\n",
    "The Body Mass Index (BMI) can be used to indicate whether someone is at a healthy body weight. [The NHS website](https://www.nhs.uk/common-health-questions/lifestyle/what-is-the-body-mass-index-bmi/) describes it as follows:\n",
    "\n",
    "> The body mass index (BMI) is a measure that uses your height and weight to work out if your weight is healthy.\n",
    ">\n",
    "> The BMI calculation divides an adult's weight in kilograms by their height in metres, squared. For example, a BMI of $25$ means $25 \\text{kg/m}^2$.\n",
    ">\n",
    "> For most adults, an ideal BMI is in the $18.5$ to $24.9$ range.\n",
    "\n",
    "This means that the BMI is calculated as follows:\n",
    "\n",
    "$$\n",
    "\\text{BMI} = \\frac{\\text{weight}}{\\text{height}^2}.\n",
    "$$\n",
    "\n",
    "---\n",
    "🚩 ***Task 2:*** Write a function `bmi_chart(info)` which takes as input the `info` array returned by `read_subject_info()`, produces a visualisation showing all subjects' heights and weights on a graph, and clearly indicates whether they are within the \"healthy weight\" range as described above (i.e. their BMI is in the $18.5$ to $24.9$ range).\n",
    "\n",
    "Your function should not return anything, but calling it with `bmi_chart(info)` must be sufficient to display the visualisation.\n",
    "\n",
    "You should choose carefully how to lay out your plot so that it is easy to interpret and understand.\n",
    "\n",
    "**[4 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b98dd64c-4224-4825-9b99-ddd58836aac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bmi_chart(info):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e3f39ce-0767-4ef3-b920-6cc16a2038e6",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 3: Instantaneous heart rate data\n",
    "\n",
    "For each subject, the file `heartbeats.txt` contains data on all individual heartbeats detected over the 24-hour study period. Specifically, the two columns record the time at which each heartbeat was detected, and the interval (in seconds) between the current heartbeat and the previous one.\n",
    "\n",
    "### Handling timestamp data\n",
    "\n",
    "For the next tasks, you will use NumPy's `datetime64[s]` and `timedelta64[s]` object types, respectively used to represent times (as if read on a clock) and time intervals. You should [consult the relevant documentation](https://numpy.org/doc/stable/reference/arrays.datetime.html#datetimes-and-timedeltas).\n",
    "\n",
    "Here are a few illustrative examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f0cafb7-2e0f-4e2e-a743-738ad05e7aea",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Create two datetime objects and a vector of dates\n",
    "start_time = np.datetime64('2022-10-20 12:00:00')\n",
    "end_time = np.datetime64('2022-11-10 12:00:00')\n",
    "time_vector = np.array(['2022-10-20', '2022-10-23', '2022-10-28'], dtype='datetime64[s]')\n",
    "print(time_vector)\n",
    "\n",
    "# Get time interval between the two times\n",
    "time_elapsed = end_time - start_time\n",
    "print(time_elapsed)\n",
    "print(type(time_elapsed))\n",
    "\n",
    "# Divide by the duration of 1 second to get number of seconds (as a number object)\n",
    "seconds_elapsed = time_elapsed / np.timedelta64(1, 's')\n",
    "print(seconds_elapsed)\n",
    "print(type(time_elapsed))\n",
    "\n",
    "# Divide by the duration of 1 day to get number of days\n",
    "days_elapsed = time_elapsed / np.timedelta64(1, 'D')\n",
    "print(days_elapsed)\n",
    "\n",
    "# Create a range of datetimes spaced by 1 day\n",
    "step = np.timedelta64(1, 'D')\n",
    "days = np.arange(start_time, end_time + step, step)\n",
    "\n",
    "# Plot something using days as the x-axis\n",
    "fig, ax = plt.subplots(figsize=(12, 4))\n",
    "value = np.random.randint(1, 11, size=len(days))\n",
    "ax.plot(days, value, 'ro-')\n",
    "ax.set(ylim=[0, 11], xlabel='Date', ylabel='Value')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b3fb407-85ac-43c1-aa7a-c1576a046c24",
   "metadata": {},
   "source": [
    "---\n",
    "🚩 ***Task 3a:*** Write a function `read_heartbeat_data(subject)` which takes as input an integer `subject` between 1 and 10, reads the data in `heartbeats.txt` for the given `subject`, and returns it as two NumPy vectors:\n",
    "\n",
    "- `times`, containing the recorded times of each heartbeat (as `datetime64[s]` objects),\n",
    "- `intervals`, containing the recorded intervals between heartbeats (in seconds, as `float` numbers).\n",
    "\n",
    "**[3 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51816505-65e8-465b-ab8d-15d0850c1e56",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_heartbeat_data(subject):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5173463b-7095-4b12-8d04-fbe5535938ba",
   "metadata": {},
   "source": [
    "---\n",
    "🚩 ***Task 3b:*** Write a function `hr_from_intervals(intervals)` which takes as input a NumPy vector containing heartbeat interval data (such as that returned by `read_heartbeat_data()`), and returns a NumPy vector of the same length, containing the instantaneous heart rates, in **beats per minute (BPM)**, calculated from the intervals between heartbeats. You should return the heart rates as floating-point numbers.\n",
    "\n",
    "For instance, an interval of 1 second between heartbeats should correspond to a heart rate of 60 BPM.\n",
    "\n",
    "**[2 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "401e15eb-a242-4727-a983-0e27e16b7460",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hr_from_intervals(intervals):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c2e0930-da31-4412-a370-9bbeb0899021",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 4: Data cleaning\n",
    "\n",
    "There are gaps and measurement errors in the heartbeat data provided by the device. These errors will likely appear as outliers in the data, which we will now try to remove.\n",
    "\n",
    "One possible method is to remove data points which correspond to values above and below certain **percentiles** of the data. Removing the data below the $p$th percentile means removing the $p\\%$ lowest values in the dataset. (Note that, for instance, the 50th percentile is the median.)\n",
    "\n",
    "---\n",
    "🚩 ***Task 4a:*** Write a function `clean_data(times_raw, hr_raw, prc_low, prc_high)` which takes 4 inputs:\n",
    "\n",
    "- `times_raw` is the NumPy array of timestamps returned by `read_heartbeat_data()`,\n",
    "- `hr_raw` is the NumPy array of computed heart rate values returned by `hr_from_intervals()`,\n",
    "- `prc_low` and `prc_high` are two numbers such that $0\\leq$ `prc_low` $<$ `prc_high` $\\leq 100$.\n",
    "\n",
    "Your function should return two NumPy arrays of the same length, `times` and `hr`, which are the original arrays `times_raw` and `hr_raw` where all the measurements (heart rate and associated time stamp) below the `prc_low`th percentile and above the `prc_high`th percentile of the heart rate data have been removed.\n",
    "\n",
    "You may wish to make use of NumPy functionality to calculate percentiles.\n",
    "\n",
    "**[4 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33b85ad3-dd7f-4349-a26f-e80dacaaa2f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_data(times_raw, hr_raw, prc_low, prc_high):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1bb9835-9262-49cd-acdb-8d7d1a0ecdd9",
   "metadata": {},
   "source": [
    "---\n",
    "🚩 ***Task 4b:*** Write a function `evaluate_cleaning(subject)`, which takes as input an integer `subject` between 1 and 10 indicating the subject number, and plots the following two histograms for that subject:\n",
    "\n",
    "- a histogram of the raw heart rate data,\n",
    "- a histogram of the heart rate data after cleaning with `clean_data()`, where the bottom 1% and the top 1% of the values have been removed.\n",
    "\n",
    "Your histograms should use a logarithmic scale on the y-axis, and be clearly labelled. You should consider carefully how to lay out the histogram to best present the information.\n",
    "\n",
    "Your function `evaluate_cleaning()` should call the functions `read_heartbeat_data()`, `hr_from_intervals()`, and `clean_data()` you wrote above, in order to obtain the raw and cleaned heart rate data for a given `subject`.\n",
    "\n",
    "Then, use your function to display the histograms of the raw and cleaned data for Subject 3. Given that heart rates in adults can typically range from about 40 to 160 beats per minute, and given your histograms, explain why this is a suitable method to remove likely measurement errors in the heart rate data.\n",
    "\n",
    "**[3 marks]**\n",
    "\n",
    "---\n",
    "\n",
    "💾 *If you are stuck on Task 3 or on the task above, you can load the data provided in the `testing` folder to produce your histograms, by running the following commands:*\n",
    "\n",
    "```python\n",
    "times_raw = np.load('testing/times_raw.npy')\n",
    "hr_raw = np.load('testing/hr_raw.npy')\n",
    "times = np.load('testing/times.npy')\n",
    "hr = np.load('testing/hr.npy')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1123864e-b439-4601-861f-ff281aa41faa",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_cleaning(subject):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404b3e53-31b6-4e60-9a7d-51076732baf7",
   "metadata": {},
   "source": [
    "*Use this Markdown cell to write your explanation for Task 4.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adef4ebc-7397-4bd7-b044-5f8aa149699c",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 5: Interpolating the data\n",
    "\n",
    "Although the device detecting heartbeats was able to measure intervals between beats with millisecond precision, the recorded timestamps could only record the second at which a heartbeat occurred. This means that there are not only time gaps in the data (due to the device missing heartbeats), but also several heartbeats usually recorded in the same second.\n",
    "\n",
    "For example, this is an excerpt from Subject 7's data, showing a 9-second time gap between `09:19:57` and `09:20:06`, as well as 3 different heartbeats detected at `09:20:06`:\n",
    "\n",
    "```\n",
    "59,2022-07-21 09:19:56,1.033\n",
    "60,2022-07-21 09:19:57,0.942\n",
    "61,2022-07-21 09:20:06,0.307\n",
    "62,2022-07-21 09:20:06,0.439\n",
    "63,2022-07-21 09:20:06,0.297\n",
    "64,2022-07-21 09:20:07,0.427\n",
    "```\n",
    "\n",
    "The goal of this next task is to **interpolate** the recorded data, in order to produce a new dataset containing values of the heart rate at regular time intervals. We will use **linear interpolation**, with the help of SciPy's `interp1d()` function (from the `interpolate` module) which we saw in Week 5.\n",
    "\n",
    "---\n",
    "🚩 ***Task 5a:*** The `interp1d()` function from SciPy can only be used with numeric data, and not timestamps. Two functions are provided for you below.\n",
    "\n",
    "- Explain, in your own words, what both functions do and how.\n",
    "- Write a few lines of test code which clearly demonstrate how the functions work.\n",
    "\n",
    "**[2 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "798c9283-d9ae-4c2f-b833-1005d9150f84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def datetime_to_seconds(times):\n",
    "    return (times - times[0]) / np.timedelta64(1, 's')\n",
    "\n",
    "def seconds_to_datetime(seconds_elapsed, start_time):\n",
    "    return seconds_elapsed * np.timedelta64(1, 's') + start_time\n",
    "\n",
    "\n",
    "# Demonstrating usage\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e189a50b-1c12-4b5a-a5a4-349d4fcec9fc",
   "metadata": {},
   "source": [
    "*Use this Markdown cell to explain how the functions `datetime_to_seconds()` and `seconds_to_datetime()` work.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cf94950-5b39-40f1-9d25-60a717803802",
   "metadata": {
    "tags": []
   },
   "source": [
    "---\n",
    "🚩 ***Task 5b:*** Write a function `generate_interpolated_hr(times, hr, time_delta)` which takes as inputs:\n",
    "\n",
    "- two NumPy vectors `times` and `hr` such as those returned by `clean_data()`,\n",
    "- a `timedelta64[s]` object representing a time interval in seconds,\n",
    "\n",
    "and returns two new NumPy vectors, `times_interp` and `hr_interp`, such that:\n",
    "\n",
    "- `times_interp` contains regularly spaced `datetime64[s]` timestamps, starting at `times[0]`, ending on or less than `time_delta` seconds before `times[-1]`, and with an interval of `time_delta` between consecutive times.\n",
    "- `hr_interp` contains the heart rate data obtained using **linear interpolation** and evaluated at each time in `times_interp`, for example with the help of the `interp1d()` function from `scipy.interpolate`.\n",
    "\n",
    "For example, if `times` starts at `10:20:00` and ends at `10:20:09` with a `time_delta` of two seconds, then your `times_interp` vector should contain `10:20:00`, `10:20:02`, `10:20:04`, `10:20:06`, `10:20:08`, and `hr_interp` should consist of the corresponding interpolated heart rate values at each of those times.\n",
    "\n",
    "**[4 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6eb44333-22b3-40cf-b541-00accda05f9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.interpolate import interp1d\n",
    "\n",
    "def generate_interpolated_hr(times, hr, time_delta):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1c7e1b7-e4ff-4be9-82d4-842a3306c15e",
   "metadata": {},
   "source": [
    "---\n",
    "🚩 ***Task 5c:*** Check your `generate_interpolated_hr()` function by generating interpolated heart rate data for Subject 1 for just the first 100 measurements (after cleaning). You should generate interpolated data with a time interval of 5 seconds. Plot the data points, as well as your interpolated data, and discuss in the Markdown cell below whether your plot is what you expected, and why.\n",
    "\n",
    "**[2 marks]**\n",
    "\n",
    "---\n",
    "💾 *If you are stuck on Task 4, you can use the cleaned data provided in the `testing` folder to check your code, by running the following commands:*\n",
    "\n",
    "```python\n",
    "times = np.load('testing/times.npy')\n",
    "hr = np.load('testing/hr.npy')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bea3a45-6a60-4b7a-a3da-83fea3155690",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "82ddbcdf-6769-4df9-b112-3b913b12ac78",
   "metadata": {},
   "source": [
    "*Use this Markdown cell for discussing your interpolation results.*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eb04723-bf01-414e-ae1f-bc220e1a347c",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 6: Smoothing the data with a rolling average\n",
    "\n",
    "A rolling average is simply an average of the heart rate data, calculated over a given window of time. For example:\n",
    "\n",
    "- The 20-second rolling average of the heart rate at a time `10:20:00` is the average heart rate over the 20 seconds leading up to that time, i.e. the average of all the heart rates between `10:19:41` and `10:20:00` (inclusive). If we have measurements of the heart rate every 5 seconds, then this would be the average of the heart rates measured at `10:19:45`, `10:19:50`, `10:19:55`, and `10:20:00`.\n",
    "- We can similarly calculate the 20-second rolling average at the next measurement time, `10:20:05`, as the average heart rate over the 20-second period from `10:19:46` to `10:20:05` (inclusive).\n",
    "\n",
    "The rolling average essentially smoothes out the sudden jumps in the measured (or interpolated) heart rate data, allowing us to see the longer-term variations more clearly.\n",
    "\n",
    "---\n",
    "🚩 ***Task 6:*** Write a function `rolling_average()` which takes as inputs:\n",
    "\n",
    "- two NumPy vectors `times` and `hr` such as those returned by `clean_data()`,\n",
    "- a `timedelta64[s]` object `time_delta` representing a time interval in seconds,\n",
    "- a `timedelta64[s]` object `window`, representing the window duration in seconds (with `window` assumed to be an integer multiple of `time_delta`),\n",
    "\n",
    "and returns a NumPy vector `hr_rolling` containing values for the rolling average of the heart rate over time, with the given window size.\n",
    "\n",
    "Your `rolling_average()` function should call `generate_interpolated_hr()` to generate regularly-spaced heart rate data with a time interval `time_delta`, before computing and returning the averaged heart rate data.\n",
    "\n",
    "Note that `hr_rolling` will be shorter than the length of your interpolated heart rate data, because you can only start computing rolling averages after one window of time has elapsed. (For instance, if your data starts at `10:20:00`, with a 30-second window, the first value of the rolling average you can obtain is at `10:20:29`.)\n",
    "\n",
    "**[4 marks]**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71fe07ed-ecfb-4e9c-b96c-8143f74305a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rolling_average(times, hr, time_delta, window):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03478d6e-c11f-4413-8ffc-822f4e14df7d",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 7: Putting it all together\n",
    "\n",
    "You should now have a series of functions which allow you to:\n",
    "\n",
    "- read data on measured heartbeart-to-heartbeat intervals for a given subject,\n",
    "- transform this data into heart rate measurements and clean out the outliers,\n",
    "- interpolate the data to generate measurements at regular time intervals,\n",
    "- compute a rolling average of the heart rate data over time, to smooth out the data.\n",
    "\n",
    "For each subject, there is another file `actigraph.txt`, containing activity data recorded by a separate device. In particular, this data provides another independent measurement of the subjects' heart rate. We can use this to check our work.\n",
    "\n",
    "---\n",
    "🚩 ***Task 7:*** Write a function `display_heart_rate(subject)` which takes as input an integer `subject` between 1 and 10, and produces one single graph, containing two plots on the same set of axes:\n",
    "\n",
    "- a plot of the heart rate data found in `actigraph.txt` over time,\n",
    "- a plot of the smoothed heart rate data computed by you from the data in `heartbeats.txt`, using interpolated measurements of the heart rate every 3 seconds, and a 30-second window size for the averaging.\n",
    "\n",
    "Your plot should show good agreement between the two sets of data. Instead of showing the full 24 hours of data, you should choose a period of time over which to plot the heart rate (say, approximately 1 hour), in order to better visualise the results.\n",
    "\n",
    "Show an example by using your function to display the results for 3 subjects of your choice.\n",
    "\n",
    "**[4 marks]**\n",
    "\n",
    "---\n",
    "💾 *If you are stuck on Task 5 or 6, you can use the actigraph heart rate data provided in the `testing` folder in `actigraph.txt`, and compare this to the smoothed heart rate data provided in the `testing` folder, which you can load by running the following command:*\n",
    "\n",
    "```python\n",
    "hr_rolling = np.load('testing/hr_rolling.npy')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "50e2a283-4a8d-445b-aa5f-9ec16fd5a589",
   "metadata": {},
   "outputs": [],
   "source": [
    "def display_heart_rate(subject):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b620b919-6a2b-4616-8f2b-1ec2dbb75a53",
   "metadata": {},
   "source": [
    "---\n",
    "## Task 8: relating to other data\n",
    "\n",
    "The data in `actigraph.txt` also contains the following columns:\n",
    "\n",
    "- `Steps` indicates the number of steps detected per second (using a pedometer).\n",
    "- `Inclinometer Standing`/`Sitting`/`Lying` indicates the position of the subject, automatically detected by the device.\n",
    "- `Inclinometer Off` indicates when the device didn't record a position.\n",
    "\n",
    "In particular, the `Inclinometer ...` columns record either `0` or `1`, and they are mutually exclusive over each row. This means that, for example, a subject can't be recorded simultaneously sitting and standing.\n",
    "\n",
    "---\n",
    "🚩 ***Task 8:*** Using the results of your data processing work in previous tasks, can you relate some of this additional data (and/or some of the data in `subject_info.txt`) to the heart rate estimates that you have obtained?\n",
    "\n",
    "You are free to choose how you complete this task. You will be assessed on the correctness of your code and analysis, the quality of your code (readability, commenting/documentation, structure), and the presentation of your results.\n",
    "\n",
    "Note that you do not have to use **all** of the extra data to obtain full marks.\n",
    "\n",
    "**[5 marks]**\n",
    "\n",
    "---\n",
    "💾 *If you are using `hr_rolling.npy` and the actigraph data in the `testing` folder, this is the information for this person:*\n",
    "\n",
    "| Weight | Height | Age |\n",
    "|:-:|:-:|:-:|\n",
    "| 85 | 180 | 27 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7113552b-8f6e-4789-8b30-aa63d10f9f00",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}