"
],
"metadata": {
"id": "3hMg_zjdhZGd"
}
},
{
"cell_type": "markdown",
"source": [
"*^ A picture of the polar h10 heart rate monitor ^*"
],
"metadata": {
"id": "Te0C7dNmhnjs"
}
},
{
"cell_type": "markdown",
"source": [
"The Polar H10 is a $80 ECG chest strap heart rate monitor. It is worn attached to a strap and wrapped tight around the sternum.\n",
"\n",
"While the H10 is well known for its accuracy in measuring heart rate, it is also capable of tracking metrics like movement speed, pace, and distance traveled.\n",
"\n",
"All of the data kept and calculated by the H10 can be easily accessed via the Polar Beat app, which automatically stores the training data to the cloud.\n",
"\n",
"In the following sections, we will present what we have learned from using the Polar H10 and its associated platform for extracting data and doing simple analysis."
],
"metadata": {
"id": "wRMyhWylhpkN"
}
},
{
"cell_type": "markdown",
"source": [
"Through the API, we will be able to extract the following parameters (in bold are parameters we will be using in this notebook). Per Activity means one measurement through a single session of exercise. Per second means one measurement every second throughout an exercise."
],
"metadata": {
"id": "JJ5GcuwmjJNf"
}
},
{
"cell_type": "markdown",
"source": [
"Additionally, the H10 is capable of recording raw RR intervals. However, since the official Polar App does not use this functionality, we will be using an optional third party app EliteHRV for this purpose. This is just one way to get RR intervals from the H10, many other ways exist!"
],
"metadata": {
"id": "CoIEp-RzmUAU"
}
},
{
"cell_type": "markdown",
"source": [
"We will be able to extract the following parameters. Per Activity means one measurement through a single session of exercise. Per second means one measurement every second throughout an exercise.\n",
"\n",
"Parameter Name | Sampling Frequency\n",
"-------------------|-----------------\n",
"Calories | Per Activity\n",
"Duration | Per Activity\n",
"Sessions | Per day\n",
"Continuous Heart Rate | Per second\n",
"Heart Rate Variability | Per second"
],
"metadata": {
"id": "csAR4YlGZTOC"
}
},
{
"cell_type": "markdown",
"source": [
"In this guide, we sequentially cover the following **nine** topics:\n",
"\n",
"1. **Set up**![](\"https://i.imgur.com/CpvRIHc.png\")
"
],
"metadata": {
"id": "dbVI4KR-vUny"
}
},
{
"cell_type": "markdown",
"source": [
"This plot shows the continuous heart rate data recorded by the H10 monitor throughout the participant's workout session. This graph adds visual separation to heart rate records under and over 140 bpm. This is helpful because at lower exercise intensities, more fat calories are burned, whereas at high intensities more carbohydrate calories are burned.\n",
"\n",
"To begin plotting this chart, we want to extract the heart rates and put them into a list so they can be easily read by our plotting utility matplotlib."
],
"metadata": {
"id": "rtLPxkQdwHs6"
}
},
{
"cell_type": "code",
"source": [
"import pandas as pd\n",
"\n",
"heart_rts = list(hr_df[\"bpm\"])\n",
"#we must add in '2000-01-10' as a dummy date to help with formatting concerns\n",
"times = list(hr_df[\"time\"])"
],
"metadata": {
"id": "-bJRcCbtipgv"
},
"execution_count": 29,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"We will now graph this using the matplotlib [line plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html) function, which will give us the base graph, after which we can focus on aesthetics."
],
"metadata": {
"id": "ia_-pygZ9oMB"
}
},
{
"cell_type": "code",
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import seaborn as sns\n",
"import matplotlib.dates as mdates\n",
"from datetime import timedelta\n",
"\n",
"sns.set_style(\"whitegrid\")\n",
"fig, ax = plt.subplots(figsize=(15,5))\n",
"ax.set_facecolor('#f2f2f2')\n",
"\n",
"ax = plt.gca()\n",
"plt.plot(times, heart_rts, color='#e71735')\n",
"\n",
"#set x axis values\n",
"xts = np.arange(min(times), max(times), timedelta(minutes=10))\n",
"ax.set_xticks(xts)\n",
"ax.set_xticklabels(xts)\n",
"ax.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M:%S'))\n",
"\n",
"#set left y axis\n",
"yts = [0,140,240]\n",
"ax.set_yticks(yts)\n",
"\n",
"#ax.set_yscale('function', functions=(forward,inverse))\n",
"ax.axhspan(0, 140, facecolor='#ecaec4', alpha=0.5)\n",
"ax.axhspan(140, 240, facecolor='#c7c7c7', alpha=0.6)\n",
"ax.fill_between(times[:int(len(times)/50)], 0, 140, color='#b5164b', alpha=1)\n",
"ax.fill_between(times[:int(len(times)/50)], 140, 240, color='#636363', alpha=1)\n",
"\n",
"#cut off the edges\n",
"plt.xlim(times[0], times[len(times)-1]);"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 445
},
"id": "DJWzDFw7iq73",
"outputId": "10909244-c33e-48fe-fd9d-719db44a68b4"
},
"execution_count": 30,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"![](\"https://i.imgur.com/Pl35nrW.png\")
"
],
"metadata": {
"id": "mgukxH9HvfC3"
}
},
{
"cell_type": "markdown",
"source": [
"This chart shows the percent of the exercise in which the participant exercised at high intensity (fit) and the percent spent in low intensity exercise (fat).\n",
"\n",
"We will need to first extract the percent of time spent in each zone. Since polar defines low intensity as being below 140 bpm and high intensity being above, we can use our heart rate data to determine this information."
],
"metadata": {
"id": "gww-1mJO-LMb"
}
},
{
"cell_type": "code",
"source": [
"import pandas as pd\n",
"\n",
"heart_rts = list(hr_df[\"bpm\"])\n",
"\n",
"fat_percent = np.count_nonzero(np.array(heart_rts) < 140) / len(heart_rts)\n",
"fit_percent = int((1 - fat_percent )*100)\n",
"fat_percent = int(fat_percent*100)\n",
"\n",
"ranges = [0, 140, 240]\n",
"z1 = hr_df.groupby(pd.cut(hr_df.bpm, ranges), as_index=False).count()\n",
"z2 = pd.to_datetime(z1['bpm'], unit='s')\n",
"z2 = pd.DataFrame(z2.dt.strftime('%H:%M:%S'))\n",
"display(z2['bpm'])"
],
"metadata": {
"id": "ruANHNzQ2DcM",
"colab": {
"base_uri": "https://localhost:8080/",
"height": 69
},
"outputId": "2e62ec78-092a-4cf2-a5fe-373460855b83"
},
"execution_count": 31,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"0 00:31:58\n",
"1 00:23:02\n",
"Name: bpm, dtype: object"
]
},
"metadata": {}
}
]
},
{
"cell_type": "markdown",
"source": [
"z2 is exactly the heart rate zone data, as we wanted. Now we want to set up two more python arrays that we will use as the y-axis labels, shown here. This data is already available in our z2 series, so we can extract them as necessary."
],
"metadata": {
"id": "fzdNTQEs_PuD"
}
},
{
"cell_type": "code",
"source": [
"zones = ['1','2']\n",
"times = [e for e in z1['bpm']][::-1]\n",
"time_labels = [e for e in z2['bpm']]"
],
"metadata": {
"id": "Z8iMaMjt2-Xt"
},
"execution_count": 32,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"The zones array will be the left side y-axis label, and the times will be the actual data. We can place these in a pandas dataframe so it will be easier to plot using the python matplotlib library."
],
"metadata": {
"id": "HzDz_To4_T2r"
}
},
{
"cell_type": "code",
"source": [
"import pandas as pd\n",
"\n",
"d = {\"zones\":zones, \"times\": times}\n",
"df1 = pd.DataFrame(data=d)\n",
"df1.set_index('zones', inplace=True)"
],
"metadata": {
"id": "x8S_Ha563q_8"
},
"execution_count": 33,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"And now we can finally plot the data. We will be using the [horizontal bar plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.barh.html) from matplotlib, barh. Since we already have the data we need, we can use barh to directly plot the necessary bars, after which we can apply our desired styling to make the graph look like the one pictured."
],
"metadata": {
"id": "BwINR-L8_YZe"
}
},
{
"cell_type": "code",
"source": [
"from matplotlib import pyplot as plt, patches\n",
"import seaborn as sns\n",
"\n",
"sns.set_theme(style=\"dark\")\n",
"fig1, ax = plt.subplots(figsize=(8,6))\n",
"clrs = [\"#636363\", \"#b5164b\"] #colors array for the zones\n",
"\n",
"#plot the base graph\n",
"plt. margins(y=0)\n",
"plt.xlim(0, sum(i for i in df1[\"times\"])) #this sets the graph to have its width equal to the total session time\n",
"bar1 = ax.barh(df1.index[::-1], df1[\"times\"][::-1], align=\"center\", height=1., color = clrs[::-1]) #plot the bar graph\n",
"plt.xticks(color='w') #hide the x tick labels\n",
"plt.yticks(color='w')\n",
"ax.tick_params(axis='both', labelsize=25, pad=12.5)\n",
"\n",
"# Adding the times for each zone\n",
"for i in range(len(time_labels)):\n",
" plt.text(1.,0.3 + 0.35*i,time_labels[i],fontsize=18,transform=fig1.transFigure,\n",
" horizontalalignment='center', weight=300, color=\"gray\")\n",
"\n",
"# Adding the labels for each zone\n",
"plt.text(.2,0.35,\"Fat\",color=\"white\", fontsize=18,transform=fig1.transFigure,\n",
" horizontalalignment='center', weight=300)\n",
"plt.text(.2175,0.25, str(fat_percent)+\" %\",color=\"white\", fontsize=18,transform=fig1.transFigure,\n",
" horizontalalignment='center', weight=300)\n",
"\n",
"plt.text(.2,0.725,\"Fit\",color=\"white\", fontsize=18,transform=fig1.transFigure,\n",
" horizontalalignment='center', weight=300)\n",
"plt.text(.2175,0.625, str(fit_percent)+\" %\",color=\"white\", fontsize=18,transform=fig1.transFigure,\n",
" horizontalalignment='center', weight=300)\n",
"\n",
"#set grid lines separating bars\n",
"ax.set_yticks([0.5], minor=True)\n",
"ax.yaxis.grid(True, which='minor')"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 558
},
"id": "OTKEdK9K3v0o",
"outputId": "efb84b81-ea0e-46b6-96d1-7b1fe1ecb2c0"
},
"execution_count": 34,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"
"
],
"metadata": {
"id": "fLHKfAZYBL1J"
}
},
{
"cell_type": "markdown",
"source": [
"To start we want to extract the necessary data. This will include:\n",
"\n",
"\n",
"* Dates of exercises\n",
"* Durations of each exercise\n",
"* Average heart rates of each exercise\n",
"\n"
],
"metadata": {
"id": "iRrNAOW4BNnI"
}
},
{
"cell_type": "code",
"source": [
"import pandas as pd\n",
"import numpy as np\n",
"from datetime import datetime\n",
"\n",
"df4 = df2\n",
"if len(data.keys()) == 1:\n",
" for i in range(1,30):\n",
" tdf = pd.DataFrame([[(pd.Timestamp(list(data.keys())[0])+pd.DateOffset(days=1*i)).strftime('%Y-%m-%d'),0,0, avg_rate]],columns=['day','minutes','calories', 'avg_rate'])\n",
" df4 = df4.append(tdf)\n",
"\n",
"durations = []\n",
"avg_rates = []\n",
"dates = []\n",
"day_array = list(df4['day'])\n",
"rate_array = list(df4['avg_rate'])\n",
"duration_array = list(df4['minutes'])\n",
"for i in range(len(df4['day'])):\n",
"\n",
" if datetime.strptime(day_array[i],'%Y-%M-%d') < (datetime.strptime(start_date,'%Y-%M-%d') + timedelta(days=30)) and datetime.strptime(day_array[i],'%Y-%M-%d') >= datetime.strptime(start_date,'%Y-%M-%d'):\n",
" dates.append(np.datetime64(day_array[i]))\n",
" durations.append(duration_array[i]*60000)\n",
" avg_rates.append(rate_array[i])\n",
"\n",
"c = sorted(dates, key=lambda x: x)\n",
"s = dates[0]\n",
"dates = []\n",
"for d in c:\n",
" if d > (s+np.timedelta64(30,'D')):\n",
" break\n",
" else:\n",
" dates.append(d)\n",
"dates = dates[:30] # we will only plot a month of data just like in the original"
],
"metadata": {
"id": "lLYzJE6xnlPg"
},
"execution_count": 35,
"outputs": []
},
{
"cell_type": "markdown",
"source": [
"Now that we have everything we need, we can move on to plotting the graph!\n",
"\n",
"To do this we will start by plotting a [matplotlib bar graph](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.bar.html), which will represent the durations of each exercise. Then we will overlay this plot with a second graph, the [matplotlib line plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html). This is all we need for the base graph!\n",
"\n",
"All that remains after is to add the necessary styling to achieve the graph pictured above."
],
"metadata": {
"id": "qJC_x9ctD7Ip"
}
},
{
"cell_type": "code",
"source": [
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import matplotlib.dates as mdates\n",
"from matplotlib.ticker import AutoMinorLocator\n",
"import copy\n",
"import pandas as pd\n",
"import warnings\n",
"\n",
"# ignore unecessary warnings\n",
"warnings.filterwarnings(\"ignore\")\n",
"#set the style of the plot, initialize it\n",
"sns.set_style(\"whitegrid\")\n",
"fig, ax = plt.subplots(figsize=(21,7)) # 24, 8\n",
"ax.set_facecolor('#f2f2f2')\n",
"\n",
"#before we begin, we need to add in a buffer at either end of the data so we can extend the graph\n",
"rbound = np.datetime64((pd.Timestamp(dates[len(dates)-1])).strftime('%Y-%m-%d'))\n",
"lbound = np.datetime64((pd.Timestamp(dates[0]) - pd.DateOffset(days=1)).strftime('%Y-%m-%d'))\n",
"xdates = list(pd.date_range(start=lbound, end=rbound))\n",
"xdates.append(xdates[len(xdates)-1])\n",
"\n",
"gridticks = copy.deepcopy(xdates)\n",
"xdates += list(np.array(xdates) - timedelta(hours=12))\n",
"xdates = sorted(xdates, key=lambda x: x) # check\n",
"\n",
"#process and fill our data arrays so that they match dimensions of x axis\n",
"points = {np.datetime64(datetime.strftime(pd.to_datetime(date), '%Y-%m-%d')):(avg_rate,duration) for date, avg_rate, duration in zip(dates,avg_rates,durations)}\n",
"\n",
"data1 = []\n",
"data2 = {}\n",
"for i in range(len(xdates)):\n",
" cdate = np.datetime64(datetime.strftime(xdates[i],'%Y-%m-%d'))\n",
" if i == 0:\n",
" added = points[np.datetime64(datetime.strftime(xdates[3],'%Y-%m-%d'))][0]\n",
" # if even (is artifical)\n",
" if pd.Timestamp(xdates[i]).hour == 12:\n",
" data1.append(added)\n",
" continue\n",
" if cdate in points:\n",
" added = points[cdate][0]\n",
" data1.append(added)\n",
" data2[cdate] = points[cdate][1]/3600000\n",
" else:\n",
" data1.append(added)\n",
" data2[cdate] = 0\n",
"plt.xticks(rotation=45)\n",
"ax2 = ax.twinx()\n",
"\n",
"#plot the bar graph\n",
"ax.bar(data2.keys(),data2.values(), color ='#e71735', width=0.30)\n",
"ax.set_yticklabels(np.arange(0, 2., 0.5), weight='light')\n",
"ax.set_yticks(np.arange(0, 2., 0.5)) # 2nd param was: max(data2.values())+0.5 for adaptability\n",
"\n",
"#plot the average heart rate\n",
"plt.plot(xdates, data1, color='#e71735', linestyle='dashed')\n",
"plt.xticks(gridticks)\n",
"ax.set_xticklabels(gridticks, weight='light')\n",
"ax.xaxis.set_major_formatter(mdates.DateFormatter('%m-%d'))\n",
"\n",
"#clip the graph ends to get our desired look\n",
"axis = plt.axis()\n",
"plt.xlim(xdates[0], xdates[len(xdates)-2])\n",
"ax2.yaxis.grid(False)\n",
"ax2.set_yticks(np.arange(50,200,25))\n",
"ax2.set_yticklabels(np.arange(50, 200, 25), weight='light')\n",
"\n",
"# shift grid lines so they are in between dates\n",
"gridticks = np.array(gridticks) - timedelta(hours=12)\n",
"ax.set_xticks(gridticks, minor=True)\n",
"ax.xaxis.grid(False)\n",
"ax.grid(which='minor')\n",
"ax.tick_params(axis='x', length=10, which='minor')\n",
"\n",
"#hide ticks\n",
"ax2.tick_params(axis='y', length=0)\n",
"ax.tick_params(axis='y', length=0)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 559
},
"id": "XwQDVENUnps8",
"outputId": "0751fbf5-3872-4cfc-a016-0ea178b5a5bd"
},
"execution_count": 36,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"