intro_to_mimic/01-example-patient-heart-failure.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploring the trajectory of a single patient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Python libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We first need to import some tools for working with data in Python. \n",
    "- NumPy is for working with numbers\n",
    "- Pandas is for analysing data\n",
    "- MatPlotLib is for making plots\n",
    "- Sqlite3 to connect to the database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import sqlite3\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Connect to the database"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can use the sqlite3 library to connect to the MIMIC database\n",
    "- Once the connection is established, we'll run a simple SQL query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Connect to the MIMIC database\n",
    "conn = sqlite3.connect('data/mimicdata.sqlite')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Create our test query\n",
    "test_query = \"\"\"\n",
    "SELECT subject_id, hadm_id, admittime, dischtime, admission_type, diagnosis\n",
    "FROM admissions\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Run the query and assign the results to a variable\n",
    "test = pd.read_sql_query(test_query,conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Display the first few rows\n",
    "test.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load the chartevents data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The chartevents table contains data charted at the patient bedside. It includes variables such as heart rate, respiratory rate, temperature, and so on.\n",
    "- We'll begin by loading the chartevents data for a single patient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "query = \"\"\"\n",
    "SELECT de.icustay_id\n",
    "  , (strftime('%s',de.charttime)-strftime('%s',ie.intime))/60.0/60.0 as HOURS\n",
    "  , di.label\n",
    "  , de.value\n",
    "  , de.valuenum\n",
    "  , de.uom\n",
    "FROM chartevents de\n",
    "INNER join d_items di\n",
    "ON de.itemid = di.itemid\n",
    "INNER join icustays ie\n",
    "ON de.icustay_id = ie.icustay_id\n",
    "WHERE de.icustay_id = 252522\n",
    "ORDER BY charttime;\n",
    "\"\"\"\n",
    "\n",
    "ce = pd.read_sql_query(query,conn)\n",
    "\n",
    "\n",
    "# OPTION 2: load chartevents from a CSV file\n",
    "# ce = pd.read_csv('data/example_chartevents.csv', index_col='HOURSSINCEADMISSION')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Preview the data\n",
    "# Use 'head' to limit the number of rows returned\n",
    "ce.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Review the patient's heart rate"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- We can select individual columns using the column name. \n",
    "- For example, if we want to select just the label column, we write **```ce.LABEL```** or alternatively **```ce['LABEL']```**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Select a single column\n",
    "ce['LABEL']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- In a similar way, we can select rows from data using indexes. \n",
    "- For example, to select rows where the label is equal to 'Heart Rate', we would create an index using **```[ce.LABEL=='Heart Rate']```** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Select just the heart rate rows using an index\n",
    "ce[ce.LABEL=='Heart Rate']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 1: How did the patients heart rate change over time?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using the methods described above to select our data of interest, we can create our x and y axis values to create a time series plot of heart rate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Which time stamps have a corresponding heart rate measurement?\n",
    "print ce.index[ce.LABEL=='Heart Rate']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Set x equal to the times\n",
    "x_hr = ce.HOURS[ce.LABEL=='Heart Rate']\n",
    "\n",
    "# Set y equal to the heart rates\n",
    "y_hr = ce.VALUENUM[ce.LABEL=='Heart Rate']\n",
    "\n",
    "# Plot time against heart rate\n",
    "plt.figure(figsize=(14, 6))\n",
    "plt.plot(x_hr,y_hr)\n",
    "\n",
    "\n",
    "plt.xlabel('Time',fontsize=16)\n",
    "plt.ylabel('Heart rate',fontsize=16)\n",
    "plt.title('Heart rate over time from admission to the intensive care unit')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1\n",
    "\n",
    "* What is happening to this patient's heart rate?\n",
    "* Plot respiratory rate over time for the patient.\n",
    "* Is there anything unusual about the patient's respiratory rate?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Exercise 1 here\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 2: Did the patient's vital signs breach any alarm thresholds?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Alarm systems in the intensive care unit are commonly based on high and low thresholds defined by the carer.\n",
    "- False alarms are often a problem and so thresholds may be set arbitrarily to reduce alarms.\n",
    "- As a result, alarm settings carry limited information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 6))\n",
    "\n",
    "plt.plot(ce.HOURS[ce.LABEL=='Respiratory Rate'], \n",
    "         ce.VALUENUM[ce.LABEL=='Respiratory Rate'],\n",
    "         'k+', markersize=10, linewidth=4)\n",
    "\n",
    "plt.plot(ce.HOURS[ce.LABEL=='Resp Alarm - High'], \n",
    "         ce.VALUENUM[ce.LABEL=='Resp Alarm - High'],\n",
    "         'm--')\n",
    "\n",
    "plt.plot(ce.HOURS[ce.LABEL=='Resp Alarm - Low'], \n",
    "         ce.VALUENUM[ce.LABEL=='Resp Alarm - Low'],\n",
    "         'm--')\n",
    "\n",
    "plt.xlabel('Time',fontsize=16)\n",
    "plt.ylabel('Respiratory rate',fontsize=16)\n",
    "plt.title('Respiratory rate over time from admission, with upper and lower alarm thresholds')\n",
    "plt.ylim(0,55)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2\n",
    "\n",
    "- Based on the data, does it look like the alarms would have triggered for this patient?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 3: What is patient's level of consciousness?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Glasgow Coma Scale (GCS) is a measure of consciousness.\n",
    "- It is commonly used for monitoring patients in the intensive care unit. \n",
    "- It consists of three components: eye response; verbal response; motor response."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Display the first few rows of the GCS eye response data\n",
    "ce[ce.LABEL=='GCS - Eye Opening'].head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Prepare the size of the figure\n",
    "plt.figure(figsize=(18, 10))\n",
    "\n",
    "# Set x equal to the times\n",
    "x_hr = ce.HOURS[ce.LABEL=='Heart Rate']\n",
    "\n",
    "# Set y equal to the heart rates\n",
    "y_hr = ce.VALUENUM[ce.LABEL=='Heart Rate']\n",
    "\n",
    "\n",
    "plt.plot(x_hr,y_hr)\n",
    "\n",
    "plt.plot(ce.HOURS[ce.LABEL=='Respiratory Rate'], \n",
    "         ce.VALUENUM[ce.LABEL=='Respiratory Rate'],\n",
    "         'k', markersize=6)\n",
    "\n",
    "# Add a text label to the y-axis\n",
    "plt.text(-20,155,'GCS - Eye Opening',fontsize=14)\n",
    "plt.text(-20,150,'GCS - Motor Response',fontsize=14)\n",
    "plt.text(-20,145,'GCS - Verbal Response',fontsize=14)   \n",
    "\n",
    "# Iterate over list of GCS labels, plotting around 1 in 10 to avoid overlap\n",
    "for i, txt in enumerate(ce.VALUE[ce.LABEL=='GCS - Eye Opening'].values):\n",
    "    if np.mod(i,6)==0 and i < 65:\n",
    "        plt.annotate(txt, (ce.HOURS[ce.LABEL=='GCS - Eye Opening'].values[i],155),fontsize=14)\n",
    "        \n",
    "for i, txt in enumerate(ce.VALUE[ce.LABEL=='GCS - Motor Response'].values):\n",
    "    if np.mod(i,6)==0 and i < 65:\n",
    "        plt.annotate(txt, (ce.HOURS[ce.LABEL=='GCS - Motor Response'].values[i],150),fontsize=14)\n",
    "\n",
    "for i, txt in enumerate(ce.VALUE[ce.LABEL=='GCS - Verbal Response'].values):\n",
    "    if np.mod(i,6)==0 and i < 65:\n",
    "        plt.annotate(txt, (ce.HOURS[ce.LABEL=='GCS - Verbal Response'].values[i],145),fontsize=14)\n",
    "\n",
    "plt.title('Vital signs and Glasgow Coma Scale over time from admission',fontsize=16)\n",
    "\n",
    "plt.xlabel('Time (hours)',fontsize=16)\n",
    "plt.ylabel('Heart rate or GCS',fontsize=16)\n",
    "plt.ylim(10,165)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3\n",
    "\n",
    "- How is the patient's consciousness changing over time?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stop here..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 4: What other data do we have on the patient?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Using Pandas 'read_csv function' again, we'll now load the outputevents data - this table contains all information about patient outputs (urine output, drains, dialysis)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# OPTION 1: load outputs from the patient\n",
    "query = \"\"\"\n",
    "select de.icustay_id\n",
    "  , (strftime('%s',de.charttime)-strftime('%s',ie.intime))/60.0/60.0 as HOURS\n",
    "  , di.label\n",
    "  , de.value\n",
    "  , de.valueuom\n",
    "from outputevents de \n",
    "inner join icustays ie\n",
    "  on de.icustay_id = ie.icustay_id\n",
    "inner join d_items di\n",
    "  on de.itemid = di.itemid\n",
    "where de.subject_id = 40080\n",
    "order by charttime;\n",
    "\"\"\"\n",
    "\n",
    "oe = pd.read_sql_query(query,conn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "oe.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "\n",
    "plt.figure(figsize=(14, 6))\n",
    "plt.title('Fluid output over time')\n",
    "\n",
    "plt.plot(oe.HOURS, \n",
    "         oe.VALUE.cumsum()/1000, \n",
    "         'ro', markersize=8, label='Output volume, L')\n",
    "\n",
    "plt.xlim(0,72)\n",
    "plt.ylim(0,10)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To provide necessary context to this plot, it would help to include patient input data. This provides the necessary context to determine a patient's fluid balance - a key indicator in patient health."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# OPTION 1: load inputs given to the patient (usually intravenously) using the database connection\n",
    "query = \"\"\"\n",
    "select de.icustay_id\n",
    "  , (strftime('%s',de.starttime)-strftime('%s',ie.intime))/60.0/60.0 as HOURS_START\n",
    "  , (strftime('%s',de.endtime)-strftime('%s',ie.intime))/60.0/60.0 as HOURS_END\n",
    "  , de.linkorderid\n",
    "  , di.label\n",
    "  , de.amount\n",
    "  , de.amountuom\n",
    "  , de.rate\n",
    "  , de.rateuom\n",
    "from inputevents_mv de \n",
    "inner join icustays ie\n",
    "  on de.icustay_id = ie.icustay_id\n",
    "inner join d_items di\n",
    "  on de.itemid = di.itemid\n",
    "where de.subject_id = 40080\n",
    "order by endtime;\n",
    "\"\"\"\n",
    "\n",
    "ie = pd.read_sql_query(query,conn)\n",
    "\n",
    "# # OPTION 2: load ioevents using the CSV file with endtime as the index\n",
    "# ioe = pd.read_csv('inputevents.csv'\n",
    "#                   ,header=None\n",
    "#                   ,names=['subject_id','itemid','label','starttime','endtime','amount','amountuom','rate','rateuom']\n",
    "#                   ,parse_dates=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ie.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the column headers are different: we have \"HOURS_START\" and \"HOURS_END\". This is because inputs are administered over a fixed period of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ie['LABEL'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "\n",
    "# Plot the cumulative input against the cumulative output\n",
    "plt.plot(ie.HOURS_END[ie.AMOUNTUOM=='mL'], \n",
    "         ie.AMOUNT[ie.AMOUNTUOM=='mL'].cumsum()/1000, \n",
    "         'go', markersize=8, label='Intake volume, L')\n",
    "\n",
    "plt.plot(oe.HOURS, \n",
    "         oe.VALUE.cumsum()/1000, \n",
    "         'ro', markersize=8, label='Output volume, L')\n",
    "\n",
    "plt.title('Fluid balance over time',fontsize=16)\n",
    "plt.xlabel('Hours',fontsize=16)\n",
    "plt.ylabel('Volume (litres)',fontsize=16)\n",
    "# plt.ylim(0,38)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "As the plot shows, the patient's intake tends to be above their output (as one would expect!) - but there are periods where they are almost one to one. One of the biggest challenges of working with ICU data is that context is everything - let's look at a treatment (lasix) that we know will affect this graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "\n",
    "# Plot the cumulative input against the cumulative output\n",
    "plt.plot(ie.HOURS_END[ie.AMOUNTUOM=='mL'], \n",
    "         ie.AMOUNT[ie.AMOUNTUOM=='mL'].cumsum()/1000, \n",
    "         'go', markersize=8, label='Intake volume, L')\n",
    "\n",
    "plt.plot(oe.HOURS, \n",
    "         oe.VALUE.cumsum()/1000, \n",
    "         'ro', markersize=8, label='Output volume, L')\n",
    "\n",
    "# example on getting two columns from a dataframe: ie[['HOURS_START','HOURS_END']].head()\n",
    "\n",
    "for i, idx in enumerate(ie.index[ie.LABEL=='Furosemide (Lasix)']):\n",
    "    plt.plot([ie.HOURS_START[ie.LABEL=='Furosemide (Lasix)'][idx],\n",
    "             ie.HOURS_END[ie.LABEL=='Furosemide (Lasix)'][idx]],\n",
    "            [ie.RATE[ie.LABEL=='Furosemide (Lasix)'][idx],\n",
    "             ie.RATE[ie.LABEL=='Furosemide (Lasix)'][idx]],\n",
    "            'b-',linewidth=4)\n",
    "    \n",
    "\n",
    "plt.title('Fluid balance over time',fontsize=16)\n",
    "plt.xlabel('Hours',fontsize=16)\n",
    "plt.ylabel('Volume (litres)',fontsize=16)\n",
    "# plt.ylim(0,38)\n",
    "plt.legend()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ie['LABEL'].unique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "* Plot the alarms for the mean arterial pressure ('```Arterial Blood Pressure mean```')\n",
    "* HINT: you can use ```ce.LABEL.unique()``` to find a list of variable names\n",
    "* Were the alarm thresholds breached?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Exercise 2 here\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 3: Were the patient's other vital signs stable?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "\n",
    "plt.plot(ce.index[ce.LABEL=='Heart Rate'], \n",
    "         ce.VALUENUM[ce.LABEL=='Heart Rate'],\n",
    "         'rx', markersize=8, label='HR')\n",
    "\n",
    "plt.plot(ce.index[ce.LABEL=='O2 saturation pulseoxymetry'], \n",
    "         ce.VALUENUM[ce.LABEL=='O2 saturation pulseoxymetry'], \n",
    "         'g.', markersize=8, label='O2')\n",
    "\n",
    "plt.plot(ce.index[ce.LABEL=='Arterial Blood Pressure mean'], \n",
    "         ce.VALUENUM[ce.LABEL=='Arterial Blood Pressure mean'], \n",
    "         'bv', markersize=8, label='MAP')\n",
    "\n",
    "plt.plot(ce.index[ce.LABEL=='Respiratory Rate'], \n",
    "         ce.VALUENUM[ce.LABEL=='Respiratory Rate'], \n",
    "         'k+', markersize=8, label='RR')\n",
    "\n",
    "plt.title('Vital signs over time from admission')\n",
    "plt.ylim(0,130)\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plot 5: Laboratory measurements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using Pandas 'read_csv function' again, we'll now load the labevents data.\n",
    "This data corresponds to measurements made in a laboratory - usually on a sample of patient blood. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# OPTION 1: load labevents data using the database connection\n",
    "query = \"\"\"\n",
    "SELECT de.subject_id\n",
    "  , de.charttime\n",
    "  , di.label, de.value, de.valuenum\n",
    "  , de.uom\n",
    "FROM labevents de\n",
    "INNER JOIN d_labitems di\n",
    "  ON de.itemid = di.itemid\n",
    "where de.subject_id = 40080\n",
    "\"\"\"\n",
    "\n",
    "le = pd.read_sql_query(query,conn)\n",
    "\n",
    "# OPTION 2: load labevents from the CSV file\n",
    "# le = pd.read_csv('data/example_labevents.csv', index_col='HOURSSINCEADMISSION')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# preview the labevents data\n",
    "le.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# preview the ioevents data\n",
    "le[le.LABEL=='HEMOGLOBIN']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(14, 10))\n",
    "\n",
    "plt.plot(le.index[le.LABEL=='HEMATOCRIT'], \n",
    "         le.VALUENUM[le.LABEL=='HEMATOCRIT'], \n",
    "         'go', markersize=6, label='Haematocrit')\n",
    "\n",
    "plt.plot(le.index[le.LABEL=='HEMOGLOBIN'], \n",
    "         le.VALUENUM[le.LABEL=='HEMOGLOBIN'], \n",
    "         'bv', markersize=8, label='Hemoglobin')\n",
    "\n",
    "plt.title('Laboratory measurements over time from admission')\n",
    "plt.ylim(0,38)\n",
    "plt.legend()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}