tsk_20190318_experiment2-p2-preprocessing+bootstrap_logistic_regression.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis 2-2: Preprocessing + bootstrap algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Intitializing Scala interpreter ..."
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Spark Web UI available at http://localhost:4040\n",
       "SparkContext available as 'sc' (version = 2.3.2, master = local[*], app id = local-1558865537078)\n",
       "SparkSession available as 'spark'\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "res0: org.apache.spark.sql.SparkSession = org.apache.spark.sql.SparkSession@32dc6701\n"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "//%load src/scala/spark_imports.scala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "import org.apache.spark.sql._\n",
       "import org.apache.spark.sql.DataFrame\n",
       "import org.apache.spark.sql.functions._\n",
       "import org.apache.spark.sql.types._\n",
       "import spark.implicits._\n"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import org.apache.spark.sql._\n",
    "import org.apache.spark.sql.DataFrame\n",
    "import org.apache.spark.sql.functions._\n",
    "import org.apache.spark.sql.types._\n",
    "import spark.implicits._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the datasets into Spark\n",
    "## This analysis is currently only implemented on the male group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "basedir: String = spark-warehouse/experiment2-data/\n"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "val basedir = \"spark-warehouse/experiment2-data/\"\n",
    "\n",
    "// prescription data for unhospitalized patients\n",
    "spark.read.parquet(basedir+\"male/unhosp_pres\")\n",
    "    .createOrReplaceTempView(\"e2_healthy_pres\")\n",
    "\n",
    "// prescription data hospitalized patients\n",
    "spark.read.parquet(basedir+\"male/hosp_pres\")\n",
    "    .createOrReplaceTempView(\"e2_hosp_pres\")\n",
    "\n",
    "// hospitalization data for elders \n",
    "spark.read.parquet(basedir+\"male/hosp_npr\")\n",
    "    .createOrReplaceTempView(\"e2_hosp_npr\")\n",
    "\n",
    "// prescription duration estimates for all elders\n",
    "spark.read\n",
    "    .parquet(\"spark-warehouse/experiment2-data/elders_drug_duration/\")\n",
    "    .createOrReplaceTempView(\"e2_drug_duration\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get the intersection between Drugs in healthy and hospitalized patients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(# drugs in healthy population: ,1039)\n",
      "(# drugs in hosp population:,1040)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "drugs_in_unhosp: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [drugcode: string]\n",
       "drugs_in_hosp: org.apache.spark.sql.Dataset[org.apache.spark.sql.Row] = [drugcode: string]\n",
       "get_drug_intersection: (a: org.apache.spark.sql.DataFrame, b: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame\n",
       "drug_intersection: org.apache.spark.sql.DataFrame = [drugcode: string]\n"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "val drugs_in_unhosp = spark.sql(\"select * from e2_healthy_pres\")\n",
    "    .select(\"drugcode\").distinct//.count\n",
    "val drugs_in_hosp = spark.sql(\"select * from e2_hosp_pres\")\n",
    "    .select(\"drugcode\").distinct//.count\n",
    "// We may want to look at occurrence of each drug for the two populations\n",
    "// However this will be kept in mind for later\n",
    "println(\"# drugs in healthy population: \",drugs_in_unhosp.count)\n",
    "println(\"# drugs in hosp population:\",drugs_in_hosp.count)\n",
    "\n",
    "//\n",
    "def get_drug_intersection(a:DataFrame, b:DataFrame):DataFrame = {\n",
    "    a.select($\"drugcode\".as(\"drugcode2\"))\n",
    "    .join(b, $\"drugcode\"===$\"drugcode2\").select(\"drugcode\")\n",
    "    .sort(asc(\"drugcode\")).distinct\n",
    "}\n",
    "\n",
    "val drug_intersection = get_drug_intersection(drugs_in_unhosp, drugs_in_hosp)\n",
    "drug_intersection.createOrReplaceTempView(\"e2_drugcodes\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Drugs in intersection : ,949)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "hosp_except_healthy: Long = 91\n",
       "healthy_except_hosp: Long = 90\n"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "/*\n",
    "    Counts of drugs in each subpopulation ( can be commented out )\n",
    "*/\n",
    "println(\"Drugs in intersection : \", drug_intersection.count)\n",
    "\n",
    "//println(\"hospitalized only\")\n",
    "val hosp_except_healthy = drugs_in_hosp\n",
    "    .join(drugs_in_unhosp.select($\"drugcode\".as(\"drugcode2\"))\n",
    "          , $\"drugcode\"===$\"drugcode2\", \"leftanti\")\n",
    "    .sort(asc(\"drugcode\")).count//.show\n",
    "\n",
    "//println(\"healthy only\")\n",
    "val healthy_except_hosp = drugs_in_unhosp\n",
    "    .join(drugs_in_hosp.select($\"drugcode\".as(\"drugcode2\"))\n",
    "          , $\"drugcode\"===$\"drugcode2\", \"leftanti\")\n",
    "    .sort(asc(\"drugcode\")).count//.show\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "//%load src/python/e2_imports.py\n",
    "//add %%python as first line since we're in spylon kernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "import sklearn.preprocessing\n",
    "from sklearn.preprocessing import MultiLabelBinarizer\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pyspark.sql.functions import collect_list, struct, col, explode, rand\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We create a drug encoder using the drugs from intersection\n",
    "* We use sklearn's MultiLabelBinarizer\n",
    "* Using all levels in the ATC system we get 938 drugs overlapping between the two populations, we will attempt to use all levels with the full population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "drug-array shape: (949, 1)\n",
      "sample transformed:\n",
      " [[1 0 0 0 0 0 0 0 0 0]\n",
      " [0 1 0 0 0 0 0 0 0 0]\n",
      " [0 0 1 0 0 0 0 0 0 0]]\n",
      "sample inv-transformed (first 10 indices) [('A01AA01', 'A01AB03', 'A01AB04')]\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "drugs = np.array([d[0] for d in spark.sql(\"select * from e2_drugcodes\") \\\n",
    "              .collect()]).reshape(-1)[None].T\n",
    "print(\"drug-array shape:\", drugs.shape)\n",
    "\n",
    "\n",
    "def create_multilabelbinarizer_from_np_arr(elements):\n",
    "    drugencoder = MultiLabelBinarizer()\n",
    "    drugencoder.fit_transform(drugs)\n",
    "    return drugencoder\n",
    "\n",
    "drugencoder = create_multilabelbinarizer_from_np_arr(drugs)\n",
    "\n",
    "transformed = drugencoder.transform(drugs[:3])\n",
    "test_sample =  transformed[0:1]+transformed[1:2]+transformed[2:3]\n",
    "inverse = drugencoder.inverse_transform(test_sample)\n",
    "\n",
    "print(\"sample transformed:\\n\", transformed[:,:10])\n",
    "print(\"sample inv-transformed (first 10 indices)\", inverse)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create an ATC to description map using a helper function\n",
    "* This allows us to go from ATC-code to drug name (chemical substance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "from src.python.csv_to_dict import csv_to_dict\n",
    "atc_to_description = csv_to_dict(\"datasets/atc_to_descr/2014_atc.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conversion of prescription data takes place in multiple stages\n",
    "### We need a method to look up which drugs are currently in use from new dataset\n",
    "1. We intersected the drugs in each patient group, and created an encoder which produces a vector given a set of drugs, or a matrix if given a sample with multiple sets of drugs:  [drug 1, drug 3] => [0, 1, 0, 1, 0...]\n",
    "___\n",
    "### Healthy patients \n",
    "1. Sample IDs with replacement from the set of IDs in healthy population\n",
    "2. Take a random date in (0,365) for each sampled ID => DF(\"id\") becomes DF(\"id\", \"randomdate\".as(\"date\")\n",
    "3. Join with Drug Duration dataset on conditions: \n",
    "    \n",
    "    * healthy[id]===drug_dur[id]\n",
    "    \n",
    "    * healthy[date] > drug_dur[treatment_start]\n",
    "    \n",
    "    * healthy[date] < drug_dur[treatment_end]\n",
    "\n",
    "4. GroupBy (Id, date) and aggregate with collect_list. This returns a set of drugs per  patient-date selection\n",
    "___\n",
    "\n",
    "### Hospitalized patients\n",
    "1. Convert hospitalizations to windows between hospitalizations\n",
    "2. select the N longest windows\n",
    "3. take a point in time X days prior to the hospitalization (10-30 days?)\n",
    "4. Lookup all active drugs at point in time in active drugs dataset\n",
    "___ \n",
    "### Now convert healthy patient's data to vector format by dividing their time series into 30-day windows\n",
    "* This may have to be done in chunks if the data doesn't fit python's memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How do we preprocess healthy patients?\n",
    "1. We need the healthy patients\n",
    "2. Take all drug durations from healthy population joining drug duration set with healthy patients\n",
    "3. Limit them between day 0 and day 365\n",
    "#### To sample from the healthy patients we do the following\n",
    "1. Sample a fraction of the patients from healthy_patients\n",
    "2. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "spark.sql(\"show tables\").show()\n",
    "val drug_durations = spark.sql(\"select * from e2_drug_duration\").as(\"t1\")\n",
    "    .join(spark.sql(\"select distinct id from e2_healthy_pres\").as(\"t2\"), \n",
    "          $\"t1.id\" === $\"t2.id\")\n",
    "    .select(\"t1.*\")\n",
    "\n",
    "val frac = 0.4\n",
    "spark.sql(\"select distinct id from e2_healthy_pres\")\n",
    "    // False is without replacement, we want with\n",
    "    .sample(false, frac)\n",
    "    .select($\"id\".as(\"id2\"), (rand()*365).as(\"timestamp\").cast(\"int\"))\n",
    "    .join(drug_durations)\n",
    "    .where(\n",
    "        $\"id\" === $\"id2\"\n",
    "        &&\n",
    "        $\"timestamp\" >= $\"treatment_start\"\n",
    "        &&\n",
    "        $\"timestamp\" <= $\"treatment_end\"\n",
    "          )\n",
    "    .drop(\"id2\")\n",
    "    .groupBy(\"id\")\n",
    "    .agg(collect_list($\"drugcode\").as(\"active_drugs\"))\n",
    "//    .withColumn(\"len\", size($\"active_drugs\"))\n",
    "//    .sort(desc(\"len\"))\n",
    "    .show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+----------------+-----------+\n",
      "|database|       tableName|isTemporary|\n",
      "+--------+----------------+-----------+\n",
      "|        |e2_drug_duration|       true|\n",
      "|        |    e2_drugcodes|       true|\n",
      "|        | e2_healthy_pres|       true|\n",
      "|        |     e2_hosp_npr|       true|\n",
      "|        |    e2_hosp_pres|       true|\n",
      "+--------+----------------+-----------+\n",
      "\n",
      "root\n",
      " |-- id: string (nullable = true)\n",
      " |-- drugcode: string (nullable = true)\n",
      " |-- treatment_start: integer (nullable = true)\n",
      " |-- treatment_end: integer (nullable = true)\n",
      "\n",
      "root\n",
      " |-- id: string (nullable = true)\n",
      " |-- birthyear: integer (nullable = true)\n",
      " |-- drugcode: string (nullable = true)\n",
      " |-- diff_utleveringdato: integer (nullable = true)\n",
      " |-- gender: integer (nullable = true)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql(\"show tables\").show\n",
    "spark.sql(\"select * from e2_drug_duration\").printSchema\n",
    "spark.sql(\"select * from e2_hosp_pres\").printSchema"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hospitalized patients\n",
    "1. Convert hospitalizations to windows between hospitalizations\n",
    "2. select the N longest windows\n",
    "3. take a point in time X days prior to the hospitalization (10-30 days?)\n",
    "4. Lookup all active drugs at point in time in active drugs dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n\\ndef get_timestamp_from_n_longest_windows(hosp_list, n=1, days_prior=30):\\n    if True:\\n        print(\"DEPRECATED, import from src/python/npr_hospitalization_to_timestamp.py\")\\n        return\\n    tstamps = []\\n    i=0\\n    #-270 is the hard limit for dates in the hospitalized dataset\\n    #pre_first_hosp_end is the timestamp of the first hospitalization of the patient\\n    #Thus we obtain min duration without hospitalization as ..\\n    # diff(-270, first_hospitalization)\\n    pre_first_hosp_start = -270\\n    pre_first_hosp_end = hosp_list[i][0]\\n    duration = pre_first_hosp_end-pre_first_hosp_start\\n    if duration > 2*days_prior:\\n        tstamps.append([pre_first_hosp_end-days_prior, duration])\\n        \\n    while i<(len(hosp_list) - 1):\\n        end = hosp_list[i+1][0]\\n        start = hosp_list[i][1]\\n        duration = end-start\\n        tstamp = end-days_prior\\n        tstamps.append([tstamp, duration])\\n        i+=1\\n    return list(\\n                map(lambda x:[x[0]],\\n                    filter(lambda x: x[1]>days_prior,\\n                           #Sort and take only the N longest windows per patient\\n                           sorted(tstamps, key=lambda x: x[1], reverse=True)[:n])\\n                   )\\n               )\\n'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%python\n",
    "#This function is refactored into the utility file: \n",
    "# src/python/npr_hospitalization_to_timestamp_prior_to_hosp.py\n",
    "#We impose a limitation that the previous hospitalization must be more than \"days_prior\"\n",
    "#days before the timestamp we collect\n",
    "\"\"\"\n",
    "\n",
    "def get_timestamp_from_n_longest_windows(hosp_list, n=1, days_prior=30):\n",
    "    if True:\n",
    "        print(\"DEPRECATED, import from src/python/npr_hospitalization_to_timestamp.py\")\n",
    "        return\n",
    "    tstamps = []\n",
    "    i=0\n",
    "    #-270 is the hard limit for dates in the hospitalized dataset\n",
    "    #pre_first_hosp_end is the timestamp of the first hospitalization of the patient\n",
    "    #Thus we obtain min duration without hospitalization as ..\n",
    "    # diff(-270, first_hospitalization)\n",
    "    pre_first_hosp_start = -270\n",
    "    pre_first_hosp_end = hosp_list[i][0]\n",
    "    duration = pre_first_hosp_end-pre_first_hosp_start\n",
    "    if duration > 2*days_prior:\n",
    "        tstamps.append([pre_first_hosp_end-days_prior, duration])\n",
    "        \n",
    "    while i<(len(hosp_list) - 1):\n",
    "        end = hosp_list[i+1][0]\n",
    "        start = hosp_list[i][1]\n",
    "        duration = end-start\n",
    "        tstamp = end-days_prior\n",
    "        tstamps.append([tstamp, duration])\n",
    "        i+=1\n",
    "    return list(\n",
    "                map(lambda x:[x[0]],\n",
    "                    filter(lambda x: x[1]>days_prior,\n",
    "                           #Sort and take only the N longest windows per patient\n",
    "                           sorted(tstamps, key=lambda x: x[1], reverse=True)[:n])\n",
    "                   )\n",
    "               )\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "# Much of the functionality above and below is refactored into helper functions in the following package\n",
    "from src.python.npr_hospitalization_to_timestamp_prior_to_hosp import get_timestamp_from_n_longest_windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "from pyspark.sql.functions import collect_list, struct\n",
    "#Fetch the list of hospitalizations\n",
    "spark_hospitalization_list = spark.sql(\"\"\"select * from e2_hosp_npr\"\"\")\\\n",
    "    .groupBy(\"id\")\\\n",
    "    .agg(collect_list(struct(\"diffdager_inn\", \"diffdager_ut\")))\n",
    "\n",
    "# Get two fields: ID and hospitalization list created from aggregate above\n",
    "col_labels = spark_hospitalization_list.schema.names\n",
    "spark_hospitalization_list = spark_hospitalization_list\\\n",
    "    .select(col(col_labels[0]),col(col_labels[1]).alias(\"hospitalization_list\"))\n",
    "\n",
    "# Load the lists into pandas\n",
    "singleListOfHospitalizations = spark_hospitalization_list.toPandas()\n",
    "\n",
    "# Sort chronologically\n",
    "lhosp = singleListOfHospitalizations\n",
    "sorter = lambda l: sorted(l, key=lambda tup: tup[1])\n",
    "lhosp[lhosp.columns[1]] = lhosp[lhosp.columns[1]].apply(sorter)\n",
    "print(\"Sorted list of hospitalizations per patient: \")\n",
    "print(lhosp[:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# From lists of hospitalizations per patient we now take up to 3 hospitalizations per patient"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "%%python\n",
    "from pyspark.sql.functions import explode\n",
    "\n",
    "# Apply function to the list of hospitalization\n",
    "# This should return a list of timestamps per-patient\n",
    "windows = (lhosp[lhosp.columns[1]].map(\n",
    "    lambda x: list(\n",
    "        filter(\n",
    "            lambda y: len(y)>0, \n",
    "            get_timestamp_from_n_longest_windows(x, n=3, days_prior = 30)\n",
    "        )\n",
    "    )\n",
    "))\n",
    "\n",
    "ids_with_windows = pd.DataFrame([lhosp[lhosp.columns[0]], windows]).T\n",
    "#print(ids_with_windows[:3])\n",
    "\n",
    "### We \"explode\" the list of hospitalizations, \n",
    "### basically a flatmap where each element\n",
    "### in the list has its own (id, timestamp) row created\n",
    "explodeDf  = spark.createDataFrame(ids_with_windows)\n",
    "\n",
    "\n",
    "explodedDf2 = explodeDf.select(\"id\",explode(\"hospitalization_list\"))\n",
    "explodedDf2.select(\\\n",
    "                   col(\"id\"),\\\n",
    "                   col(\"col\")[0].alias(\"timestamp\")\\\n",
    "                  )\\\n",
    ".persist()\\\n",
    ".createOrReplaceTempView(\"e2_hosp_windows\")\n",
    "\n",
    "print(spark.sql(\"select * from e2_hosp_windows\").count())\n",
    "print(spark.sql(\"select distinct id from e2_hosp_windows\").count())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NOTE: scala/elders_lookup_active_drugs.scala is deprecated, use python/e2_drug_lookup.py or equivalent instead\n"
     ]
    }
   ],
   "source": [
    "%run src/scala/elders_lookup_active_drugs.scala"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create temp table of all unique healthy patients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+----------------+-----------+\n",
      "|database|       tableName|isTemporary|\n",
      "+--------+----------------+-----------+\n",
      "|        |e2_drug_duration|       true|\n",
      "|        |    e2_drugcodes|       true|\n",
      "|        |  e2_healthy_pat|       true|\n",
      "|        | e2_healthy_pres|       true|\n",
      "|        |     e2_hosp_npr|       true|\n",
      "|        |    e2_hosp_pres|       true|\n",
      "|        | e2_hosp_windows|       true|\n",
      "+--------+----------------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "spark.sql(\"select distinct id from e2_healthy_pres\").createOrReplaceTempView(\"e2_healthy_pat\")\n",
    "spark.sql(\"show tables\").show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Helper functions and imports for Classifier training\n",
    "_____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python \n",
    "import mlflow\n",
    "from src.python.e2_drug_lookup import *\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "import matplotlib.pyplot as plt\n",
    "from src.python.helpers import plotfig_magic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "def compute_roc(clf, Y_test, X_test):\n",
    "    Y_score = clf.predict_proba(X_test)[:,1].reshape(-1)\n",
    "    Y_truths = Y_test.reshape(-1)\n",
    "    fpr, tpr, thresholds = roc_curve(Y_truths, Y_score, pos_label=1)\n",
    "    return fpr, tpr\n",
    "\n",
    "\n",
    "def log_classifier(clf):\n",
    "    a = clf.coef_.T\n",
    "    b = drugencoder.inverse_transform(np.ones((1,clf.coef_.shape[1])))[0]\n",
    "    l = [t for t in zip(b,a)]\n",
    "    for e in l:\n",
    "        mlflow.log_param(e[0], e[1][0]) \n",
    "\n",
    "    \n",
    "#log_classifier(clf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------+----------------+-----------+\n",
      "|database|       tableName|isTemporary|\n",
      "+--------+----------------+-----------+\n",
      "|        |e2_drug_duration|       true|\n",
      "|        |    e2_drugcodes|       true|\n",
      "|        |  e2_healthy_pat|       true|\n",
      "|        | e2_healthy_pres|       true|\n",
      "|        |     e2_hosp_npr|       true|\n",
      "|        |    e2_hosp_pres|       true|\n",
      "|        | e2_hosp_windows|       true|\n",
      "+--------+----------------+-----------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "spark.sql(\"show tables\").show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-26 12:12:51 WARN  TaskSetManager:66 - Stage 56 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "Time: 9.294887781143188 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "def experiment2_generate_dataset( frac_hosp=0.8, frac_healthy=0.8):\n",
    "    # generate a random sample from the datasets\n",
    "    sample_hosp_df, sample_healthy_df = sample_and_get_drugs_from_both(\n",
    "        spark.sql(\"select * from e2_hosp_windows\")\n",
    "        ,spark.sql(\"select * from e2_healthy_pat\")\n",
    "        ,spark.sql(\"select * from e2_drug_duration\")\n",
    "        ,frac_hosp\n",
    "        ,frac_healthy\n",
    "    )\n",
    "\n",
    "    sample_hosp = sample_hosp_df.collect()\n",
    "    hosp_encoded = drugencoder.transform([d[\"active_drugs\"] for d in sample_hosp])\n",
    "\n",
    "    sample_healthy = sample_healthy_df.collect()\n",
    "    healthy_encoded =  drugencoder.transform([d[\"active_drugs\"] for d in sample_healthy])\n",
    "\n",
    "    healthy_X, healthy_Y = healthy_encoded, np.zeros((healthy_encoded.shape[0], 1))\n",
    "    hosp_X, hosp_Y = hosp_encoded, np.ones((hosp_encoded.shape[0], 1) )\n",
    "    \n",
    "    #Stack training vectors and labels\n",
    "    e2_dset_X = np.vstack((healthy_X, hosp_X ))\n",
    "    e2_dset_Y = np.vstack((healthy_Y, hosp_Y))\n",
    "\n",
    "    X_train, X_test, Y_train, Y_test =\\\n",
    "        train_test_split(e2_dset_X, e2_dset_Y, test_size=0.33)\n",
    "   \n",
    "    return X_train, X_test, Y_train, Y_test\n",
    "if True:\n",
    "    experiment2_generate_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "\n",
    "def bootstrap_iteration(dataset, C=1e40, solver=\"liblinear\"):\n",
    "    X_train, X_test, Y_train, Y_test = dataset\n",
    "    clf = LogisticRegression(C=C, solver=solver, n_jobs=4, penalty=\"l2\")\n",
    "    clf.fit(X_train, Y_train)\n",
    "    \n",
    "    metrics = {}\n",
    "    metrics[\"train_accuracy\"] = clf.score(X_train,Y_train)\n",
    "    metrics[\"train_confusion\"] = confusion_matrix(Y_train, clf.predict(X_train))\n",
    "    metrics[\"test_accuracy\"] = clf.score(X_test,Y_test)\n",
    "    metrics[\"test_confusion\"] = confusion_matrix(Y_test, clf.predict(X_test))\n",
    "    metrics[\"model_coefficients\"] = clf.coef_\n",
    "    metrics[\"model_intercept\"] = clf.intercept_\n",
    "    metrics[\"data_train_shape\"] = X_train.shape\n",
    "    metrics[\"data_test_shape\"] = X_test.shape\n",
    "    return clf, X_test, Y_test, metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-26 12:13:00 WARN  TaskSetManager:66 - Stage 62 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "#Test dataset generation\n",
    "sample = experiment2_generate_dataset(frac_hosp=0.99, frac_healthy=0.99)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(210300, 949), (103582, 949), (210300, 1), (103582, 1)]\n",
      "training observations\n",
      "210300\n",
      "total indices in training set\n",
      "199574700\n",
      "total number of drugs prescribed\n",
      "833395\n",
      "Sparsity = 0.995824145044437\n",
      "Mean prescriptions per observation = 3.9628863528292917\n",
      "Hospitalized percentage of data = 37.67%\n",
      "28\n",
      "[516, 35505, 36433, 34703, 30056, 23466, 16941, 11837, 7827, 5079, 3182, 1913, 1229, 737, 388, 208, 140, 66, 33, 18, 11, 6, 3, 1, 1, 0, 0, 0, 1]\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "print([e.shape for e in sample])\n",
    "# Compute sparsity of the training matrix\n",
    "trainingset = sample[0]\n",
    "total_variables = trainingset.shape[0]*trainingset.shape[1]\n",
    "total_active_drugs = trainingset.sum()\n",
    "print(\"training observations\")\n",
    "print(trainingset.shape[0])\n",
    "print(\"total indices in training set\")\n",
    "print(total_variables)\n",
    "print(\"total number of drugs prescribed\")\n",
    "print(total_active_drugs)\n",
    "\n",
    "\n",
    "density = total_active_drugs/total_variables\n",
    "sparsity = 1.0-density\n",
    "print(\"Sparsity = {0}\".format(sparsity))\n",
    "print(\"Mean prescriptions per observation = {0}\".format(density*trainingset.shape[1]))\n",
    "\n",
    "\n",
    "traininglabels = sample[2]\n",
    "n_hosp = traininglabels.sum()\n",
    "print(\"Hospitalized percentage of data = %.2f\" % (100*n_hosp/trainingset.shape[0]) + \"%\")\n",
    "\n",
    "max_n_active_treatments = np.max(trainingset.sum(axis=1))\n",
    "print(max_n_active_treatments)\n",
    "n_treatment_distribution  =  list(map((lambda i : np.sum(trainingset.sum(axis=1) == i)), range(0,max_n_active_treatments+1)))\n",
    "print(n_treatment_distribution)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%python\n",
    "plt.clf()\n",
    "left_of_first_bin = -0.5\n",
    "bins = max_n_active_treatments-6\n",
    "right_of_last_bin = bins + 0.5\n",
    "plt.hist( trainingset.sum(axis=1), np.arange(left_of_first_bin,right_of_last_bin, 1),\n",
    "         alpha=0.75, rwidth=0.85\n",
    "        )\n",
    "plt.grid(axis=\"y\")\n",
    "#plt.grid(axis=\"x\")\n",
    "plt.xticks( np.arange(0, bins+1) )\n",
    "plt.xlabel(\"Number of active treatments in observation\")\n",
    "plt.ylabel(\"Number of Observations\")\n",
    "plt.title(\n",
    "    \"Observed active treatments in training dataset - {:,} observations\".format(\n",
    "        int(trainingset.shape[0])\n",
    "        )\n",
    "    )\n",
    "retval = plotfig_magic()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Setup variables for experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "import time\n",
    "import datetime\n",
    "import os\n",
    "\n",
    "metrics_savedir = \"spark-warehouse/numpy/e2/runs/FINAL/\"\n",
    "bootstrap_samples = 2000\n",
    "\n",
    "if not os.path.exists(metrics_savedir):\n",
    "    try:\n",
    "        os.mkdir(metrics_savedir)\n",
    "        print(\"made directory:\", metrics_savedir)\n",
    "    except OSError as e:\n",
    "        if e.errno != errno.EEXIST:\n",
    "            raise\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python\n",
    "X_train, X_test, Y_train, Y_test = sample\n",
    "X_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run the bootstrap logistic regressions\n",
    "* The metrics and models are stored at the metrics_savedir path\n",
    "## Note: Output is omitted because it contained 2000 lines of status messages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%%python\n",
    "\n",
    "start_time = datetime.datetime.now()\n",
    "np.save(metrics_savedir+\"encoder\", drugencoder)\n",
    "\n",
    "i=0\n",
    "est_single_iter = None\n",
    "with open(metrics_savedir+\"runs.csv\", \"w\") as f:\n",
    "        f.writelines(\n",
    "            [\"run;runtime;\\n\"]\n",
    "        )\n",
    "while i<bootstrap_samples:      \n",
    "    print(\"run {0} of {1}\".format(i+1, bootstrap_samples))\n",
    "    iter_start_time = datetime.datetime.now()\n",
    "    sample = experiment2_generate_dataset(frac_hosp=0.99, frac_healthy=0.99)\n",
    "    clf, X_test, Y_test, metrics = bootstrap_iteration(sample)\n",
    "\n",
    "    fpr, tpr = compute_roc(clf, Y_test, X_test)\n",
    "    metrics[\"concordance\"] = {}\n",
    "    metrics[\"concordance\"][\"fpr\"]=fpr \n",
    "    metrics[\"concordance\"][\"tpr\"]=tpr\n",
    "    np.save(metrics_savedir+str(i), metrics)\n",
    "    \n",
    "    #Write status of run (Notebook may be closed if the code is run in tmux)\n",
    "    with open(metrics_savedir+\"_BootstrapStatus.txt\", \"w\") as f:\n",
    "        curr_time = datetime.datetime.now()\n",
    "        f.writelines(\n",
    "            [\n",
    "                \"Start_time:\"+str(start_time)+\"\\n\",\n",
    "                \"Current_time:\"+str(curr_time)+\"\\n\",\n",
    "                \"Total_runtime:\"+str(curr_time-start_time)+\"\\n\",\n",
    "                \"Current_run: \"+str(i)+\"\\n\",\n",
    "                \"Current_run_runtime_seconds:\"+str(curr_time.timestamp()-iter_start_time.timestamp()),\n",
    "                \"Target_runs:\"+str(bootstrap_samples)+\"\\n\"\n",
    "            ]\n",
    "        )\n",
    "        if est_single_iter == None:\n",
    "            est_single_iter = curr_time-start_time\n",
    "        est_eta = est_single_iter*(bootstrap_samples-i)\n",
    "        f.write(\"ETA:\"+str(est_eta)+\"\\n\")\n",
    "        f.write(\"EET:\"+str(curr_time+est_eta)+\"\\n\")\n",
    "        \n",
    "    with open(metrics_savedir+\"runs.csv\", \"a\") as f:\n",
    "        f.writelines(\n",
    "            [\"{0};{1:.2f}\\n\".format(i, curr_time.timestamp()-iter_start_time.timestamp())]\n",
    "        )\n",
    "    i+=1\n",
    "\n",
    "\n",
    "end = time.time()\n",
    "with open(metrics_savedir+\"_BootstrapSuccess.txt\", \"w\") as f:\n",
    "        end_time = datetime.datetime.now()\n",
    "        f.writelines(\n",
    "            [\n",
    "                \"Start_time:\"+str(start_time)+\"\\n\",\n",
    "                \"End_time:\"+str(end_time)+\"\\n\",\n",
    "                \"Total_runtime:\"+str(end_time-start_time)+\"\\n\",\n",
    "                \"Current_run: \"+str(i)+\"\\n\",\n",
    "                \"Target_runs:\"+str(bootstrap_samples)+\"\\n\"\n",
    "            ]\n",
    "        )\n",
    "print(\"finished in..\")\n",
    "print(end_time-start_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 03:19:57 WARN  TaskSetManager:66 - Stage 12068 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "Total samples\n",
      "103600\n",
      "Hospitalized samples\n",
      "39209.0\n",
      "Unhospitalized samples\n",
      "64391.0\n",
      "----\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "sample = experiment2_generate_dataset(frac_hosp=0.99, frac_healthy=0.99)\n",
    "X_train, X_test, Y_train, Y_test = sample\n",
    "print(\"Total samples\")\n",
    "print(Y_test.shape[0])\n",
    "print(\"Hospitalized samples\")\n",
    "print(Y_test.sum())\n",
    "print(\"Unhospitalized samples\")\n",
    "print(Y_test.shape[0]-Y_test.sum())\n",
    "print(\"----\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bootstrap sampling time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 16:15:52 WARN  TaskSetManager:66 - Stage 12099 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "Time: 8.998230457305908 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "dataset = experiment2_generate_dataset( frac_hosp = 0.99, frac_healthy = 0.99)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logistic regression training time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time: 19.695088624954224 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "def time_logreg(dataset, C=1e40, solver=\"liblinear\"):\n",
    "    X_train, X_test, Y_train, Y_test = dataset\n",
    "    clf = LogisticRegression(C=C, solver=solver, n_jobs=4, penalty=\"l2\")\n",
    "    clf.fit(X_train, Y_train)\n",
    "time_logreg(dataset)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Total time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 03:20:05 WARN  TaskSetManager:66 - Stage 12074 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "Time: 29.625468015670776 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "dataset = experiment2_generate_dataset( frac_hosp = 0.99, frac_healthy = 0.99)\n",
    "clf, X_test, Y_test, metrics = bootstrap_iteration(dataset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7307726800961463\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%python\n",
    "fpr, tpr = compute_roc(clf, Y_test, X_test)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "print(roc_auc)\n",
    "\n",
    "plt.clf()\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.plot(fpr, tpr, color=\"lightgreen\")\n",
    "plt.plot([0,1],[0,1], linestyle=\":\", color=\"black\")\n",
    "plt.xlabel(\"FP\")\n",
    "plt.ylabel(\"TP\")\n",
    "retval = plotfig_magic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 03:20:35 WARN  TaskSetManager:66 - Stage 12080 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "In-sample mean training accuracy\n",
      "0.7071096710041317\n",
      "Confusion matrix\n",
      "[[93379 12206]\n",
      " [39046 30356]]\n",
      "Test set mean training accuracy\n",
      "0.7043590249335762\n",
      "Confusion matrix\n",
      "[[45621  6160]\n",
      " [19321 15087]]\n",
      "Time: 22.119540452957153 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "X_train, X_test, Y_train, Y_test = experiment2_generate_dataset()\n",
    "\n",
    "\n",
    "\n",
    "clf = LogisticRegression(C=1e7)\n",
    "clf.fit(X_train, Y_train)\n",
    "\n",
    "print(\"In-sample mean training accuracy\")\n",
    "print(clf.score(X_train,Y_train))\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(Y_train, clf.predict(X_train)))\n",
    "print(\"Test set mean training accuracy\")\n",
    "print(clf.score(X_test,Y_test))\n",
    "print(\"Confusion matrix\")\n",
    "print(confusion_matrix(Y_test, clf.predict(X_test)))\n",
    "\n",
    "\n",
    "#model_params.append(clf.coef_)\n",
    "#model_intercepts.append(clf.intercept_)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.7944149  0.2055851 ]\n",
      " [0.73902961 0.26097039]\n",
      " [0.77396895 0.22603105]\n",
      " [0.7122187  0.2877813 ]\n",
      " [0.79794542 0.20205458]\n",
      " [0.81329486 0.18670514]\n",
      " [0.73705469 0.26294531]]\n",
      "[0.2055851]\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "print(clf.predict_proba(X_test[1303:1310]))\n",
    "def sigmoid(x):\n",
    "    return (1 / (1 + np.exp(-x)))\n",
    "print(sigmoid(np.multiply(clf.coef_,X_test[1303:1304]).sum()+clf.intercept_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example of repeated random number draws"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "val tdf = spark.range(100).toDF\n",
    "val selection = tdf.select($\"id\", (rand()*365))\n",
    "selection\n",
    "    .unionAll(tdf.select($\"id\", (rand()*365)))\n",
    "    .unionAll(tdf.select($\"id\", (rand()*365)))\n",
    "    .sort(asc(\"id\")).show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ROC / AUC of 1 bootstrap logistic regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 03:20:58 WARN  TaskSetManager:66 - Stage 12087 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "0.7326584018997117\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%python\n",
    "sample = experiment2_generate_dataset(frac_hosp=0.99, frac_healthy=0.99)\n",
    "#print(sample)\n",
    "clf, X_test, Y_test, metrics = bootstrap_iteration(sample)\n",
    "fpr, tpr = compute_roc(clf, Y_test, X_test)\n",
    "roc_auc = auc(fpr, tpr)\n",
    "print(roc_auc)\n",
    "\n",
    "plt.clf()\n",
    "plt.xlim([0, 1])\n",
    "plt.ylim([0, 1])\n",
    "plt.plot(fpr, tpr, color=\"blue\")\n",
    "plt.plot([0,1],[0,1], linestyle=\":\", color=\"black\")\n",
    "plt.title(\"ROC Curve, Logistic regression with 5-level ATC, AUC={0:.3f}\".format(roc_auc))\n",
    "plt.xlabel(\"False Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "plt.savefig(\"plots/ml_alg2_auc.pdf\")\n",
    "retval = plotfig_magic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(210356, 949), (103609, 949), (210356, 1), (103609, 1)]\n",
      "0.3775837152256175\n",
      "0.3787508807149958\n"
     ]
    }
   ],
   "source": [
    "%%python\n",
    "print([s.shape for s in sample])\n",
    "print(sample[2].sum()/sample[2].shape[0])\n",
    "print(sample[3].sum()/sample[3].shape[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Time taken for 1 bootstrap iteration with sampling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2019-05-27 03:21:19 WARN  TaskSetManager:66 - Stage 12093 contains a task of very large size (525 KB). The maximum recommended task size is 100 KB.\n",
      "Time: 28.083719968795776 seconds.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "%%python\n",
    "sample = experiment2_generate_dataset(frac_hosp=0.99, frac_healthy=0.99)\n",
    "clf, X_test, Y_test, metrics = bootstrap_iteration(sample)\n",
    "\n",
    "fpr, tpr = compute_roc(clf, Y_test, X_test)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "spylon-kernel",
   "language": "scala",
   "name": "spylon-kernel"
  },
  "language_info": {
   "codemirror_mode": "text/x-scala",
   "file_extension": ".scala",
   "help_links": [
    {
     "text": "MetaKernel Magics",
     "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
    }
   ],
   "mimetype": "text/x-scala",
   "name": "scala",
   "pygments_lexer": "scala",
   "version": "0.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}