time_series_data_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SHARP Time Series Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Background\n",
    "Over the summer, I have been working on analyzing SHARP time series data to understand what conditions lead to solar flares, and why this occurs on a physical level. There is much previous literature about flare prediction, but much of this literature fails to interpret the results in a physically meaningful manner. Furthermore, a time series approach has not been taken before to study this problem.\n",
    "\n",
    "The magnetic time series data used in this notebook is taken from Helioseismic and Magnetic Imager (HMI) instrument on NASA's Solar Dynamics Observatory (SDO) satellite, which takes magnetic images of the sun at a 12 minute cadence. From these data, [SHARP variables](http://jsoc.stanford.edu/doc/data/hmi/sharp/sharp.htm) are extracted that describe magnetic conditions on the sun. \n",
    "\n",
    "Flaring data for the sun is provided by the [NOAA GOES](https://www.swpc.noaa.gov/products/goes-x-ray-flux) database, which keeps track of soft x-ray flux on the sun, which is the metric used to determine whether an active region has flared."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "First let's import the general utility modules that we will need:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import csv\n",
    "import json\n",
    "import requests\n",
    "import math\n",
    "import random\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And load scientific packages [scipy](http://www.scipy.org), [sunpy](https://sunpy.org), and [numpy](https://www.numpy.org)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy.stats\n",
    "import sunpy\n",
    "import sunpy.instr.goes\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Downloading Data\n",
    "\n",
    "JSOC (Joint Science Operations Center) keeps an up-to-date catalog of all the active regions observed on the sun. This can be found here: `http://jsoc.stanford.edu/doc/data/hmi/harpnum_to_noaa/all_harps_with_noaa_ars.txt`. The code block below takes a file `./data/all_harps_with_noaa_ars.txt` (which is a downloaded version of the aforementioned link) and extracts the harp_ids, as well as a dictionary of harp_ids corresponding to noaa_ids.\n",
    "\n",
    "To download the newest version of the file, one could use a tool such as `wget`: `wget http://jsoc.stanford.edu/doc/data/hmi/harpnum_to_noaa/all_harps_with_noaa_ars.txt`\n",
    "\n",
    "I will first list the functions for downloading data, then have a cell that runs the functions and saves the relevant data output to variables that are accessible in other methods. Here are the functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_harp_ids_and_harp_noaa_dict(filename='./data/all_harps_with_noaa_ars.txt'):\n",
    "    '''This method requires there to be a file filename with two columns: HARP IDs\n",
    "    and NOAA IDs. This method returns a list of HARP IDs and a dictionary of HARP\n",
    "    IDs corresponding to a list of NOAA IDs.\n",
    "    '''\n",
    "    harp_ids = []\n",
    "    harp_noaa_dict = {}\n",
    "    with open(filename) as f:\n",
    "        content = f.readlines()[1:] # Disregard the header line\n",
    "        for line in content:\n",
    "            harp_id = line.split()[0]\n",
    "            noaa_ids = line.split()[1].split(',')\n",
    "            harp_ids.append(int(harp_id))\n",
    "            harp_noaa_dict[int(harp_id)] = noaa_ids\n",
    "    return harp_ids, harp_noaa_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are the variables that we will query from the HMI database:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "QUERY_VARIABLES = ('T_REC,USFLUX,MEANGAM,MEANGBT,MEANGBZ,MEANGBH,MEANJZD,TOTUSJZ,MEANJZH,'\n",
    "                    'TOTUSJH,ABSNJZH,SAVNCPP,MEANPOT,TOTPOT,MEANSHR,SHRGT45,R_VALUE,AREA_ACR'\n",
    "                   )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas\n",
    "\n",
    "def query_data(harp_id):\n",
    "    '''This method grabs data from the JSOC database. It queries four variables: time,\n",
    "    unsigned flux, polarity inversion line flux, and area. This method also makes sure\n",
    "    that the data received is high-quality and accurate.\n",
    "    '''\n",
    "    url_base = 'http://jsoc.stanford.edu/cgi-bin/ajax/jsoc_info?ds=hmi.sharp_cea_720s'\n",
    "    harp_id_string = '[' + str(harp_id) + ']'\n",
    "    param_string = '[? (abs(OBS_VR)< 3500) and (QUALITY<65536) ?]'\n",
    "    keys_string = '&op=rs_list&key=' + QUERY_VARIABLES + ',CRVAL1,CRLN_OBS'\n",
    "    url = url_base + harp_id_string + param_string + keys_string\n",
    "    r = requests.get(url)\n",
    "    assert r.status_code == 200\n",
    "    data = json.loads(r.text)\n",
    "    keys = pandas.DataFrame()\n",
    "    for keyword_data in data['keywords']:\n",
    "        keyword = keyword_data['name']\n",
    "        vals = keyword_data['values']\n",
    "        keys[keyword] = vals\n",
    "    return keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_tai_to_datetime(t_str):\n",
    "    '''Helper method to convert a JSOC T_REC object into a python datetime object.'''\n",
    "    year   = int(t_str[:4])\n",
    "    month  = int(t_str[5:7])\n",
    "    day    = int(t_str[8:10])\n",
    "    hour   = int(t_str[11:13])\n",
    "    minute = int(t_str[14:16])\n",
    "    return datetime(year, month, day, hour, minute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_datetime_to_tai(t_obj):\n",
    "    '''Helper method to convert a datetime object into a JSOC T_REC object.'''\n",
    "    return str(t_obj.year) + '.' + str(t_obj.month) + '.' + str(t_obj.day) + '_' \\\n",
    "            + str(t_obj.hour) + ':' + str(t_obj.minute) + '_TAI'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_time_delta(start_time, end_time):\n",
    "    '''This method returns the time difference between two given datetime objects in\n",
    "    hours.\n",
    "    '''\n",
    "    return (end_time - start_time).total_seconds() / (60 * 60) # Convert to hours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_time_data(keys):\n",
    "    '''This method takes a keys object returned from query_data and converts and returns\n",
    "    the time data from keys.T_REC into a list of relative times, such that the first time\n",
    "    is zero and the last time is the range of keys.T_REC in hours.\n",
    "    '''\n",
    "    start_time = convert_tai_to_datetime(keys.T_REC[0])\n",
    "    time_data = []\n",
    "    for i in range(keys.T_REC.size):\n",
    "        time = convert_tai_to_datetime(keys.T_REC[i])\n",
    "        time_data.append(get_time_delta(start_time, time))\n",
    "    return time_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_csv(keys, time_data, harp_id):\n",
    "    '''Given a keys object from query_data, a time_data list, and a harp_id, this method\n",
    "    creates a csv file in ./data/[harp_id].csv with six columns: true time (keys.T_REC),\n",
    "    relative time, unsigned flux, free energy, polarity inversion line flux, and area.\n",
    "    This method will not write any data that occurs outside the range of +/- 70 degrees\n",
    "    longitude from the meridian.\n",
    "    \n",
    "    The purpose of this method is to write local data so that it is easy and fast to\n",
    "    access data in the future, since GOES and SHARP data access take a long time, and\n",
    "    querying every test would be inefficient.\n",
    "    '''\n",
    "    data_dir = './data/'\n",
    "    filename = data_dir + str(harp_id) + '.csv'\n",
    "    with open(filename, 'w') as csv_file:\n",
    "        writer = csv.writer(csv_file, delimiter=',', quoting=csv.QUOTE_MINIMAL)\n",
    "        writer.writerow(['TRUE_TIME', 'TIME'] + QUERY_VARIABLES.split(',')[1:])\n",
    "        for i in range(len(keys.USFLUX)):\n",
    "            if abs(float(keys.CRVAL1[i]) - float(keys.CRLN_OBS[i])) < 70.0:\n",
    "                writer.writerow([keys.T_REC[i], time_data[i], keys.USFLUX[i],\n",
    "                                 keys.MEANGAM[i], keys.MEANGBT[i], keys.MEANGBZ[i],\n",
    "                                 keys.MEANGBH[i], keys.MEANJZD[i], keys.TOTUSJZ[i],\n",
    "                                 keys.MEANJZH[i], keys.TOTUSJH[i], keys.ABSNJZH[i],\n",
    "                                 keys.SAVNCPP[i], keys.MEANPOT[i], keys.TOTPOT[i],\n",
    "                                 keys.MEANSHR[i], keys.SHRGT45[i], keys.R_VALUE[i],\n",
    "                                 keys.AREA_ACR[i]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_all_csvs(harp_ids):\n",
    "    '''This method creates a csv file with time and unsigned flux for all the HARP IDs\n",
    "    in the inputted harp_ids.\n",
    "    '''\n",
    "    count = 0\n",
    "    for harp_id in harp_ids:\n",
    "        count += 1\n",
    "        print(count, harp_id)\n",
    "        if count % 100 == 0: print(count)\n",
    "        keys = query_data(harp_id)\n",
    "        time_data = get_time_data(keys)\n",
    "        create_csv(keys, time_data, harp_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data(harp_id):\n",
    "    '''This method reads the data from ./data/[harp_id].csv, and returns a pandas\n",
    "    DataFrame with two columns: time since the beginning of the active region data,\n",
    "    and unsigned flux.\n",
    "    '''\n",
    "    filename = './data/' + str(harp_id) + '.csv'\n",
    "    df = pandas.read_csv(filename)\n",
    "    df.TRUE_TIME = df.TRUE_TIME.map(convert_tai_to_datetime)\n",
    "    for i, row in df.iterrows():\n",
    "        if 'MISSING' in row.values:\n",
    "            df = df.drop(i)\n",
    "    df = df.reset_index()\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_flare_data_from_database(t_start, t_end, min_event):\n",
    "    '''This helper method accesses data from the GOES database. It returns\n",
    "    the metadata associated with each flaring active region greater in event\n",
    "    size than min_event and between time t_start and t_end.\n",
    "    '''\n",
    "    time_range = sunpy.time.TimeRange(t_start, t_end)\n",
    "    results = sunpy.instr.goes.get_goes_event_list(time_range, min_event)\n",
    "    return results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_flare_data(harp_ids, min_event):\n",
    "    '''This method accesses the GOES database to get the flare data for the maximum \n",
    "    time range of the inputted harp ids.\n",
    "    '''\n",
    "    first_keys = query_data(harp_ids[0])\n",
    "    t_start = first_keys.T_REC[0]\n",
    "    last_keys = query_data(harp_ids[-1])\n",
    "    t_end = last_keys.T_REC[len(last_keys.T_REC) - 1]\n",
    "    print('Time range:', t_start, 'to', t_end)\n",
    "\n",
    "    return get_flare_data_from_database(t_start, t_end, min_event)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def write_noaa_data_to_csv(flare_data):\n",
    "    '''This method writes the NOAA flare data to \"./data/noaa_data.csv\". This makes\n",
    "    loading the flaring data fast for future runs.\n",
    "    '''\n",
    "    with open('./data/noaa_data.csv', 'w') as csv_file:\n",
    "        field_names = flare_data[0].keys()\n",
    "        writer = csv.DictWriter(csv_file, fieldnames=field_names)\n",
    "        writer.writeheader()\n",
    "        for flare in flare_data:\n",
    "            writer.writerow(flare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_noaa_data_from_csv():\n",
    "    '''This method loads the NOAA data from \"./data/noaa_data.csv\".'''\n",
    "    noaa_flare_set = []\n",
    "    with open('./data/noaa_data.csv', 'r') as csv_file:\n",
    "        reader = csv.DictReader(csv_file)\n",
    "        for row in reader:\n",
    "            noaa_flare_set.append(dict(row))\n",
    "    return noaa_flare_set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will run the code from the functions above to create `harp_ids`, `harp_noaa_dict`, and `flare_data`:\n",
    "- `harp_ids`: a list of all HARP IDs\n",
    "- `harp_noaa_dict`: a dictionary mapping the HARP IDs to the NOAA IDs\n",
    "- `flare_data`: the flare data downloaded from GOES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of active regions: 1335\n",
      "Number of flares: 8029\n"
     ]
    }
   ],
   "source": [
    "# Set recreate_data to True if you want to redownload all the data (takes 30+ minutes)\n",
    "recreate_data = False\n",
    "\n",
    "harp_ids, harp_noaa_dict = get_harp_ids_and_harp_noaa_dict()\n",
    "\n",
    "if recreate_data:\n",
    "    create_all_csvs(harp_ids)\n",
    "    flare_data = get_flare_data(harp_ids, 'C1.0')\n",
    "    write_noaa_data_to_csv(flare_data)\n",
    "else:\n",
    "    flare_data = get_noaa_data_from_csv()\n",
    "\n",
    "print('Number of active regions:', len(harp_ids))\n",
    "print('Number of flares:', len(flare_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Data Processing\n",
    "\n",
    "In the next blocks of code, we will process the data in various ways to extract information and relate the data described above to each other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_flared_noaa_id_set(flare_data):\n",
    "    '''This method returns a list of all the NOAA IDs that have flared, based\n",
    "    on the data passed in from flare_data.\n",
    "    '''\n",
    "    noaa_flare_set = set()\n",
    "    for flare in flare_data:\n",
    "        noaa_flare_set.add(int(flare['noaa_active_region']))\n",
    "    return noaa_flare_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def has_flared(harp_id, harp_noaa_dict, noaa_flare_set):\n",
    "    '''This method returns a boolean corresponding to whether the active region\n",
    "    corresponding to the harp_id has flared or not within its lifespan.\n",
    "    '''\n",
    "    for noaa_id in harp_noaa_dict[harp_id]:\n",
    "        if int(noaa_id) in noaa_flare_set:\n",
    "            return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_harp_id_to_flaring_times_dict(harp_ids, harp_noaa_dict, flare_data):\n",
    "    '''This method returns a dictionary where the keys are HARP IDs and\n",
    "    the values are a list of peak times where the given active region flared.\n",
    "    Times are given in units of hours after the first time in the harp_id data.\n",
    "    If the active region corresponding to the HARP IDs did not flare, then\n",
    "    the list will be empty.\n",
    "    '''\n",
    "    # Make a dictionary of NOAA ids as keys and flare times as values\n",
    "    noaa_id_flare_time_dict = {}\n",
    "    for flare in flare_data:\n",
    "        time = flare['peak_time']\n",
    "        noaa_id = int(flare['noaa_active_region'])\n",
    "        if noaa_id in noaa_id_flare_time_dict.keys():\n",
    "            noaa_id_flare_time_dict[noaa_id] += [time]\n",
    "        else:\n",
    "            noaa_id_flare_time_dict[noaa_id] = [time]\n",
    "\n",
    "    # Make a dictionary with HARP ids as keys and flare times as values\n",
    "    flare_time_dict = {}\n",
    "    noaa_ids = noaa_id_flare_time_dict.keys()\n",
    "    for harp_id in harp_ids:\n",
    "        keys = read_data(harp_id)\n",
    "        if len(keys.TRUE_TIME) == 0:\n",
    "            flare_time_dict[harp_id] = []\n",
    "            continue\n",
    "\n",
    "        flare_time_dict[harp_id] = []\n",
    "        datetime_start = keys.TRUE_TIME[0]\n",
    "        hour_start = keys.TIME[0]\n",
    "        for noaa_id in harp_noaa_dict[harp_id]:\n",
    "            if int(noaa_id) not in noaa_ids: continue\n",
    "            time_array = []\n",
    "            for time in noaa_id_flare_time_dict[int(noaa_id)]:\n",
    "                time_array.append(hour_start +\n",
    "                                  get_time_delta(datetime_start,\n",
    "                                                 convert_tai_to_datetime(str(time))))\n",
    "            flare_time_dict[int(harp_id)] += time_array\n",
    "    return flare_time_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_unlabeled_flares_above_minimum(flare_data, min_class='M5.0'):\n",
    "    '''While looking at the NOAA data, I noticed that the NOAA ID of some flares\n",
    "    were labeled as 0. This method finds and returns flare_data entries that have\n",
    "    an NOAA ID of 0, and have a GOES class above min_class. This is used to see\n",
    "    if any of the unlabeled flares interfere with the learning algorithm.\n",
    "    '''\n",
    "    unlabeled_flare_list = []\n",
    "    for flare in flare_data:\n",
    "        if flare['noaa_active_region'] == '0':\n",
    "            goes_class = flare['goes_class']\n",
    "            classes = ['c', 'm', 'x']\n",
    "            if (\n",
    "                classes.index(goes_class[0].lower()) > classes.index(min_class[0].lower()) or\n",
    "                (classes.index(goes_class[0].lower()) == classes.index(min_class[0].lower()) and\n",
    "                float(goes_class[1:]) > float(min_class[1:]))\n",
    "            ):\n",
    "                unlabeled_flare_list.append(flare)\n",
    "    return unlabeled_flare_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_flared_num(harp_ids, harp_noaa_dict, noaa_flare_set):\n",
    "    '''This method returns the number of active regions in the inputted\n",
    "    harp_ids that have flared.\n",
    "    '''\n",
    "    number_flared = 0\n",
    "    for harp_id in harp_ids:\n",
    "        if has_flared(harp_id, harp_noaa_dict, noaa_flare_set): number_flared += 1\n",
    "    return number_flared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_segmented_data(harp_ids, flare_data, flare_time_dict, n=None,\n",
    "                       return_harp_ids=False, num_hours=24):\n",
    "    '''This method returns two arrays: x and y. The x array includes time series\n",
    "    data, while y represents whether the corresponding active region in x flared.\n",
    "    \n",
    "    The x and y arrays are built according to the following rule:\n",
    "        - If a flare occurs within num_hours hours after sample time t, it is \n",
    "        considered to belong to the positive case (i.e. the corresponding y entry\n",
    "        will be True).\n",
    "        - If no flare occurs within num_hours hours, it is considered to belong to \n",
    "        the negative case.\n",
    "    \n",
    "    The x array is an array of arrays, where each array represents a num_hours-hour\n",
    "    set of data corresponding to an active region. Each of these num_hours-hour \n",
    "    arrays are arrays of dictionaries representing the data at each recorded interval \n",
    "    within the num_hours hours.\n",
    "    \n",
    "    The n parameter refers to how many negative data points. If n is set to \n",
    "    None (default), then the number of negative data points = the number of positive\n",
    "    data points.\n",
    "    '''\n",
    "    num_flares = len(flare_data)\n",
    "    if n:\n",
    "        num_samples_per_datapoint = int(20 * n / num_flares)\n",
    "    else:\n",
    "        n = len(flare_data) * 5  # Pick a large number\n",
    "        num_samples_per_datapoint = 10 # Number of negative samples from each region\n",
    "    \n",
    "    def get_data_point(keys, flare_time):\n",
    "        '''Given the keys data and a flare time, returns a dictionary with SHARP\n",
    "        variables as keys, mapping each to the values corresponding to the harp_id.\n",
    "        The data is given for all data points num_hours before the flare_time.\n",
    "        '''\n",
    "        data_point = []\n",
    "        for i, time in enumerate(keys.TIME):\n",
    "            if time <= flare_time and time >= flare_time - num_hours:\n",
    "                data_point.append(keys.iloc[i])\n",
    "        if not data_point or data_point[-1]['TIME'] - data_point[0]['TIME'] < num_hours - 1:\n",
    "            return None\n",
    "        return data_point\n",
    "\n",
    "    def contains_nonflaring_24hrs(time_data, flare_data):\n",
    "        '''Given flaring data flare_data for an active region, returns True if the\n",
    "        flare_data contains a 24 hour period without flares, and False otherwise.\n",
    "        '''\n",
    "        previous_flare_time = time_data[0]\n",
    "        for flare_time in flare_data + time_data[0]:\n",
    "            if flare_time - previous_flare_time > num_hours:\n",
    "                return True\n",
    "            previous_flare_time = flare_time\n",
    "        return False\n",
    "\n",
    "    def get_random_flare_time(time_data, flare_data):\n",
    "        '''Returns a random valid flare time for the given time_data and flare_data.\n",
    "        This method ensures that there is no flaring in the num_hours before the\n",
    "        returned flare time.\n",
    "        '''\n",
    "        c = 0\n",
    "        while True:\n",
    "            c += 1\n",
    "            is_valid_before, does_flare = False, False\n",
    "            end_time = time_data[random.randrange(len(time_data))]\n",
    "            for flare_time in flare_data + [time_data[0]]:\n",
    "                if end_time - flare_time > num_hours: is_valid_before = True\n",
    "                if abs(end_time - flare_time) < num_hours: does_flare = True\n",
    "            if is_valid_before and not does_flare: break\n",
    "            if c > 200: return None\n",
    "        return end_time\n",
    "\n",
    "    x_data = []\n",
    "    y_data = []\n",
    "    harp_list = []\n",
    "    num_negative = 0\n",
    "\n",
    "    for harp_id in harp_ids:\n",
    "        keys = read_data(harp_id)\n",
    "        flare_data = flare_time_dict[harp_id]\n",
    "        if not flare_data: continue\n",
    "\n",
    "        # Positive samples\n",
    "        for flare_time in flare_data:\n",
    "            # Throw out flare data with less than num_hours hours of preceding data or\n",
    "            # data that has flare outside of the dataset since the data was cleaned in\n",
    "            # the downloading data section.\n",
    "            if flare_time - keys.TIME[0] < num_hours or flare_time > keys.TIME.iloc[-1]: continue\n",
    "            data_point = get_data_point(keys, flare_time)\n",
    "            if data_point:\n",
    "                harp_list.append(harp_id)\n",
    "                x_data.append(data_point)\n",
    "                y_data.append(True) # True => flare is present\n",
    "\n",
    "        # Negative samples\n",
    "        if num_negative >= n: continue\n",
    "        for _ in range(num_samples_per_datapoint):\n",
    "            if not contains_nonflaring_24hrs(keys.TIME, flare_data): break\n",
    "            flare_time = get_random_flare_time(keys.TIME, flare_data)\n",
    "            if not flare_time: break\n",
    "            data_point = get_data_point(keys, flare_time)\n",
    "            if not data_point: break\n",
    "\n",
    "            harp_list.append(harp_id)\n",
    "            x_data.append(data_point)\n",
    "            y_data.append(False) # False => flare is not present\n",
    "            num_negative += 1\n",
    "    if return_harp_ids:\n",
    "        return x_data, y_data, harp_list\n",
    "    else:\n",
    "        return x_data, y_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "flare_time_dict = get_harp_id_to_flaring_times_dict(harp_ids, harp_noaa_dict, flare_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# Positive: 4550 --- # Negative: 4503\n"
     ]
    }
   ],
   "source": [
    "seg_x, seg_y, harp_list = get_segmented_data(harp_ids, flare_data, flare_time_dict,\n",
    "                                             n=4500, return_harp_ids=True)\n",
    "positive_count, negative_count = 0, 0\n",
    "for has_flare in seg_y:\n",
    "    if has_flare: positive_count += 1\n",
    "    else: negative_count += 1\n",
    "print('# Positive:', positive_count, '--- # Negative:', negative_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's print the first couple terms of the first element of `seg_x` to get a good understanding of what the data looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[index                        121\n",
      "TRUE_TIME    2010-05-03 16:36:00\n",
      "TIME                          26\n",
      "USFLUX                 5.217e+20\n",
      "MEANGAM                   30.896\n",
      "MEANGBT                  118.462\n",
      "MEANGBZ                  119.494\n",
      "MEANGBH                    45.12\n",
      "MEANJZD               -0.0636397\n",
      "TOTUSJZ              7.49646e+11\n",
      "MEANJZH              -0.00472015\n",
      "TOTUSJH                   33.182\n",
      "ABSNJZH                    3.861\n",
      "SAVNCPP              1.14898e+11\n",
      "MEANPOT                  2051.63\n",
      "TOTPOT               2.22877e+21\n",
      "MEANSHR                   24.309\n",
      "SHRGT45                    5.501\n",
      "R_VALUE                    2.358\n",
      "AREA_ACR                 19.6372\n",
      "Name: 121, dtype: object, index                        122\n",
      "TRUE_TIME    2010-05-03 16:48:00\n",
      "TIME                        26.2\n",
      "USFLUX               5.15725e+20\n",
      "MEANGAM                   34.583\n",
      "MEANGBT                  113.826\n",
      "MEANGBZ                  116.839\n",
      "MEANGBH                    45.51\n",
      "MEANJZD                -0.171338\n",
      "TOTUSJZ              7.10778e+11\n",
      "MEANJZH              -0.00544223\n",
      "TOTUSJH                   30.977\n",
      "ABSNJZH                    4.577\n",
      "SAVNCPP              1.76321e+11\n",
      "MEANPOT                  2167.05\n",
      "TOTPOT               2.42035e+21\n",
      "MEANSHR                    26.45\n",
      "SHRGT45                    7.729\n",
      "R_VALUE                    2.363\n",
      "AREA_ACR                 18.2257\n",
      "Name: 122, dtype: object]\n"
     ]
    }
   ],
   "source": [
    "print(seg_x[0][0:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Plotting Variables over Time\n",
    "\n",
    "It is useful to create graphs in order to visually understand the relationship between variables over time.\n",
    "\n",
    "Below are many methods for creating different types of graphs. Many of the functions are flexible, allowing one to manipulate the graphs.\n",
    "\n",
    "First, let's import `matplotlib` methods useful for graphing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_graph(x, y, x_label, y_label, title, clr=None, scatter=False,\n",
    "               line=None, vertical_lines=None, formula=None, label=None):\n",
    "    '''This method uses matplotlib to create a graph of x vs. y with many different\n",
    "    parameters to customize the graph. This method is a base method for many of the\n",
    "    other graphing methods.\n",
    "    '''\n",
    "    # Style elements\n",
    "    text_style = dict(fontsize=12, fontdict={'family': 'monospace'})\n",
    "\n",
    "    # Add data to graph\n",
    "    if scatter:\n",
    "        plt.scatter(x, y, color=clr, label=label, alpha=0.8, s=5)\n",
    "    else:\n",
    "        plot = plt.plot(x, y, '.', color=clr, linestyle=line, label=label)\n",
    "    \n",
    "    if vertical_lines:\n",
    "        for x_val in vertical_lines:\n",
    "            plt.axvline(x=x_val, color=clr)\n",
    "    plt.axhline(y=0, color='black', linewidth=1)\n",
    "    \n",
    "    if formula:\n",
    "        x_vals = np.array(x)\n",
    "        y_vals = formula(x_vals)\n",
    "        plt.plot(x, y_vals, color=clr)\n",
    "\n",
    "    # Label the axes and the plot\n",
    "    ax = plt.gca()\n",
    "    ax.tick_params(labelsize=12)\n",
    "    ax.set_xlabel(x_label, **text_style)\n",
    "    ax.set_ylabel(y_label, **text_style)\n",
    "    ax.set_title(title, **text_style)\n",
    "    if label: plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_segmented_graphs(seg_x, seg_y, variables=['US_FLUX'], flare=True, n=5,\n",
    "                          color=None, delta=True, scale=False):\n",
    "    '''This method plots n random graphs that correspond to flaring active regions\n",
    "    if flare is True, and non-flaring active regions if flare is False.\n",
    "    If delta is True, it normalizes the graph (variables at time=0 are set to 0).\n",
    "    If scale is True, it normalizes the graph to be in the range [-1, 1].\n",
    "    '''\n",
    "    for _ in range(n):\n",
    "        i = random.randrange(len(seg_y))\n",
    "        while seg_y[i] != flare:\n",
    "            i = random.randrange(len(seg_y))\n",
    "        seg_data = seg_x[i]\n",
    "        for variable in variables:\n",
    "            x_data, y_data = [], []\n",
    "            start_data = seg_data[0][variable]\n",
    "            var_data = []\n",
    "            for data_pt in seg_data:\n",
    "                var_data.append(data_pt[variable])\n",
    "            if delta:\n",
    "                max_data = max(max(var_data - start_data),\n",
    "                                abs(min(var_data - start_data))) / 1e22\n",
    "            else:\n",
    "                max_data = max(max(var_data), abs(min(var_data))) / 1e22\n",
    "            for data_pt in seg_data:\n",
    "                x_data.append(data_pt['TIME'])\n",
    "                y_pt = data_pt[variable] / 1e22\n",
    "                if delta:\n",
    "                    y_pt -= start_data / 1e22\n",
    "                if scale:\n",
    "                    y_pt /= max_data\n",
    "                y_data.append(y_pt)\n",
    "            variable_names = map(lambda x : x.title().replace('_', ' '), variables)\n",
    "            plot_graph(x_data, y_data, 'Hours Since Active Region Detected',\n",
    "                        'Units relative to maximum value',\n",
    "                        ', '.join(variable_names) + ' vs. Time for Active Region',\n",
    "                        clr=color, label=variable)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_graphs = 2\n",
    "plot_segmented_graphs(seg_x, seg_y, scale=True, flare=False, n=num_graphs,\n",
    "                      variables=['USFLUX', 'TOTPOT', 'AREA_ACR', 'R_VALUE'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Machine Learning"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(from [Wikipedia](https://en.wikipedia.org/wiki/Spearman%27s_rank_correlation_coefficient)): Spearman's correlation assesses monotonic relationships (whether linear or not). If there are no repeated data values, a perfect Spearman correlation of +1 or −1 occurs when each of the variables is a perfect monotone function of the other."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_spearman(seg_x, first_var, second_var):\n",
    "    '''Calculate the Spearman coefficient between two variables. This method calculates\n",
    "    the coefficient between the two variables for every time series data series, then\n",
    "    returns the mean and standard deviation of the coefficients.\n",
    "    '''\n",
    "    s_coeff_list = []\n",
    "    for data in seg_x:\n",
    "        first_var_data = []\n",
    "        second_var_data = []\n",
    "        for data_pt in data:\n",
    "            if not data_pt[first_var] or not data_pt[second_var]: continue\n",
    "            first_var_data.append(data_pt[first_var])\n",
    "            second_var_data.append(data_pt[second_var])\n",
    "        s_coeff = scipy.stats.spearmanr(first_var_data, second_var_data).correlation\n",
    "        if not math.isnan(s_coeff): s_coeff_list.append(s_coeff)\n",
    "    return np.mean(s_coeff_list), np.std(s_coeff_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S_coefficient for flux vs. TOTPOT. mean: 0.5000805312052466  std: 0.5162491250288466\n",
      "S_coefficient for flux vs. AREA_ACR. mean: 0.13016976753477166  std: 0.632886617916731\n"
     ]
    }
   ],
   "source": [
    "for var in ['TOTPOT', 'AREA_ACR']:\n",
    "    s_coeff, s_dev = calculate_spearman(seg_x, 'USFLUX', var)\n",
    "    print('S_coefficient for flux vs.', var + '. mean:', s_coeff, ' std:', s_dev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def regression_helper(function, time_data, variable_data):\n",
    "    popt, _ = scipy.optimize.curve_fit(function, time_data, variable_data)\n",
    "    residuals = variable_data - function(time_data, *popt)\n",
    "    ss_res = np.sum(residuals ** 2)\n",
    "    ss_tot = np.sum((variable_data - np.mean(variable_data)) ** 2)\n",
    "    r_squared = 1 - (ss_res / ss_tot)\n",
    "    return popt, r_squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following methods take `time_data` and some `variable_data`, then return different kinds of features based on the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_features(time_data, variable_data, feature_names=False):\n",
    "    def f_linear(x, a, b):\n",
    "        return a * x + b\n",
    "    popt, r_squared = regression_helper(f_linear, time_data, variable_data)\n",
    "    if feature_names:\n",
    "        return np.array([*popt, r_squared]), ['slope', 'intercept', 'r^2_linear']\n",
    "    return np.array([*popt, r_squared])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def exponential_features(time_data, variable_data, feature_names=False):\n",
    "    def f_exponential(x, a, b):\n",
    "        return a * b ** x\n",
    "    popt, r_squared = regression_helper(f_exponential, time_data, variable_data)\n",
    "    if feature_names:\n",
    "        return np.array([popt[1], r_squared]), ['exp_val', 'r^2_exp']\n",
    "    return np.array([popt[1], r_squared])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadratic_features(time_data, variable_data, feature_names=False):\n",
    "    def f_quad(x, a, b, c):\n",
    "        return a * x ** 2 + b * x + c\n",
    "    popt, r_squared = regression_helper(f_quad, time_data, variable_data)\n",
    "    if feature_names:\n",
    "        return np.array([*popt, r_squared]), ['quad_1', 'quad_2', 'quad_3', 'r^2_quad']\n",
    "    return np.array([*popt, r_squared])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cubic_features(time_data, variable_data, feature_names=False):\n",
    "    def f_cubic(x, a, b, c, d):\n",
    "        return a * x ** 3 + b * x ** 2 + c * x + d\n",
    "    popt, r_squared = regression_helper(f_cubic, time_data, variable_data)\n",
    "    if feature_names:\n",
    "        return np.array([*popt, r_squared]), ['cube_1', 'cube_2', 'cube_3', 'cube_4', 'r^2_cube']\n",
    "    return np.array([*popt, r_squared])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.interpolate import make_lsq_spline\n",
    "from scipy.interpolate import CubicSpline\n",
    "\n",
    "def spline_features(time_data, variable_data, feature_names=False):\n",
    "    elapsed_time = time_data[-1] - time_data[0]\n",
    "    t = [time_data[0] + elapsed_time / 4, time_data[0] + elapsed_time * 2 / 4,\n",
    "         time_data[0] + elapsed_time * 3 / 4]\n",
    "    k = 3\n",
    "    t = np.r_[(time_data[0],)*(k+1), t, (time_data[-1],)*(k+1)]\n",
    "    try:\n",
    "        formula = make_lsq_spline(time_data, variable_data, t, k)\n",
    "    except np.linalg.LinAlgError: # Not enough time data in each quadrant of the data\n",
    "        if feature_names: return None, None\n",
    "        return None\n",
    "    if feature_names:\n",
    "        return np.array(formula.c.flatten()), ['spline_1', 'spline_2', 'spline_3', 'spline_4',\n",
    "                                    'spline_5', 'spline_6', 'spline_7']\n",
    "    return np.array(formula.c.flatten())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def discrete_features(time_data, variable_data, feature_names=False):\n",
    "    features = []\n",
    "    features.append(np.mean(variable_data))\n",
    "    features.append(np.std(variable_data))\n",
    "    if feature_names:\n",
    "        return features, ['mean', 'std']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "def extract_time_series_features(time_data, variable_data, features):\n",
    "    feature_list = np.array([])\n",
    "    feature_names = []\n",
    "    for feature in features:\n",
    "        # Each feature is a function\n",
    "        data, names = feature(time_data, variable_data, feature_names=True)\n",
    "        if data is None or not any(data): return [], []\n",
    "        feature_list = np.append(feature_list, data)\n",
    "        feature_names += names\n",
    "    return feature_list, feature_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_learning_dataset(seg_x, seg_y, variable, features):\n",
    "    '''Creates learning dataset with time series data.\n",
    "    '''\n",
    "    x_data, y_data = [], []\n",
    "    for i, data in enumerate(seg_x):\n",
    "        if len(data) < 4: continue\n",
    "        time_data, variable_data = [], []\n",
    "        for data_pt in data:\n",
    "            time_data.append(data_pt['TIME'])\n",
    "            if variable in ['USFLUX', 'TOTPOT']:\n",
    "                variable_data.append(data_pt[variable] / 1e22)\n",
    "            else:\n",
    "                variable_data.append(data_pt[variable])\n",
    "        time_data = np.array(time_data)\n",
    "        variable_data = np.array(variable_data)\n",
    "        if not any(variable_data): continue\n",
    "        series_data, names = extract_time_series_features(time_data, variable_data, features)\n",
    "        if not any(series_data): continue\n",
    "        x_data.append(series_data)\n",
    "        y_data.append(seg_y[i])\n",
    "    names = list(map(lambda x : variable + ' ' + x, names))\n",
    "    return x_data, y_data, names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Features used: ['USFLUX slope', 'USFLUX intercept', 'USFLUX r^2_linear']\n"
     ]
    }
   ],
   "source": [
    "features = [linear_features]\n",
    "raw_x_data = np.array([])\n",
    "y_data = []\n",
    "feature_names = []\n",
    "variables = ['USFLUX']\n",
    "for variable in variables:\n",
    "    x, y, names = create_learning_dataset(seg_x, seg_y, variable, features)\n",
    "    feature_names += names\n",
    "    if raw_x_data.size == 0: raw_x_data = np.array(x)\n",
    "    else: raw_x_data = np.hstack((raw_x_data, np.array(x)))\n",
    "    y_data = y\n",
    "print('Features used:', feature_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "def scale_x_data(x):\n",
    "    '''Method to scale each feature in the inputted x data to a range of 0 to 1.\n",
    "    Returns the scaled data.\n",
    "    '''\n",
    "    scaler = MinMaxScaler()\n",
    "    return scaler.fit_transform(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9053 9053\n"
     ]
    }
   ],
   "source": [
    "x_data = scale_x_data(raw_x_data)\n",
    "print(len(x_data), len(y_data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following two methods are helper functions to help run machine learning algorithms."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "def fit_algorithm(clf, x, y, n=1):\n",
    "    '''This method will fit the given classifier clf to the input x, y data\n",
    "    and will return the training and test accuracy of the model.\n",
    "    This method will randomize the train/test split n number of times and will\n",
    "    return the average train/test accuracy.\n",
    "    '''\n",
    "    avg_train, avg_test = 0, 0\n",
    "    for _ in range(n):\n",
    "        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)\n",
    "        clf.fit(x_train, y_train)\n",
    "        avg_train += clf.score(x_train, y_train)\n",
    "        avg_test += clf.score(x_test, y_test)\n",
    "    return avg_train / n, avg_test / n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_info(clf, x, y, algorithm_name, best_accuracy=0, best_algorithm=None):\n",
    "    '''This method streamlines the code required to fit the given clf to the \n",
    "    model, as well as print out important statistics. This method returns the new\n",
    "    best algorithm and best accuracy, based on the test accuracy.\n",
    "    '''\n",
    "    print(algorithm_name + ':')\n",
    "    train_accuracy, test_accuracy = fit_algorithm(clf, x, y, 50)\n",
    "    print('> Train accuracy:', train_accuracy)\n",
    "    print('> Test accuracy:', test_accuracy)\n",
    "    result_vals_dict = {'TP': 0, 'FP': 0, 'TN': 0, 'FN':0}\n",
    "    for i, data_pt in enumerate(x):\n",
    "        prediction = clf.predict([data_pt])\n",
    "        if prediction == y[i]:\n",
    "            if prediction == 1:\n",
    "                result_vals_dict['TP'] += 1\n",
    "            else:\n",
    "                result_vals_dict['TN'] += 1\n",
    "        else:\n",
    "            if prediction == 1:\n",
    "                result_vals_dict['FP'] += 1\n",
    "            else:\n",
    "                result_vals_dict['FN'] += 1\n",
    "    precision = result_vals_dict['TP'] / (result_vals_dict['TP'] + result_vals_dict['FP'] + 1)\n",
    "    recall = result_vals_dict['TP'] / (result_vals_dict['TP'] + result_vals_dict['FN'] + 1)\n",
    "    tss_score = recall - result_vals_dict['FP'] / (result_vals_dict['FP'] + result_vals_dict['TN'])\n",
    "    print('> Precision:', precision)\n",
    "    print('> Recall:', recall)\n",
    "    print('> TSS Score:', tss_score)\n",
    "    if test_accuracy > best_accuracy:\n",
    "        best_accuracy = test_accuracy\n",
    "        best_algorithm = algorithm_name\n",
    "    return best_algorithm, best_accuracy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Different Classification Algorithms and Their Pros and Cons\n",
    "\n",
    "1. Suppport Vector Machines (SVMs)\n",
    "  * SVMs work by constructing hyper-planes in higher dimensional space. This can be used for classification by maximizing the distance between the hyper-plane and the training data of any class.\n",
    "  * This is a good choice because it is a versatile classification algorithm.\n",
    "2. Stochastic Gradient Descent\n",
    "  * Creates a linear classifier to minimize loss.\n",
    "  * Less versatile than SVMs (this should not be an issue for the binary classification, however).\n",
    "  * Scikitlearn has the following built-in loss functions: hinge loss, modified Huber, and logistic.\n",
    "3. Multi-layer Perceptron\n",
    "  * Can learn non-linear models.\n",
    "  * Doesn't necessarily find global optimum: different initial weights can alter validation accuracy.\n",
    "  * Needs tweaking of hyperparameters such as the number of hidden neurons, layers, and iterations to work well.\n",
    "4. AdaBoost (Boosting algorithm)\n",
    "  * Principle is to combine many weak learners to create one strong model.\n",
    "  * Each weak learner concentrates on the examples that are missed by the previous learners.\n",
    "5. Random Forest\n",
    "  * Each tree is built from a random sample of the total data (with replacement).\n",
    "  * This tends to reduce the overall bias."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's import all the learning algorithms we need from the scikit learn library:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.svm import SVC\n",
    "from sklearn.linear_model import SGDClassifier\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_learning_algorithms(x, y):\n",
    "    '''This method runs different machine learning (ML) algorithms and prints \n",
    "    statements indicated the accuracy, finally printing the best overall algorithm \n",
    "    in terms of test accuracy.\n",
    "    \n",
    "    Current ML algorithms:\n",
    "        Support Vector Machine\n",
    "        Stochastic Gradient Descent\n",
    "        Multi-layer Perceptron\n",
    "        AdaBoost\n",
    "        Random Forest\n",
    "    '''\n",
    "    best_accuracy = 0\n",
    "    best_algorithm = None\n",
    "\n",
    "    #algorithm_name = 'Support Vector Machine'\n",
    "    #clf = SVC(gamma='scale')\n",
    "    #best_algorithm, best_accuracy = print_info(clf, x, y, algorithm_name, best_accuracy, best_algorithm)\n",
    "    #print('>', clf.support_vectors_, '\\n')\n",
    "\n",
    "    algorithm_name = 'Stochastic Gradient Descent'\n",
    "    clf = SGDClassifier(loss='hinge', penalty='l2')\n",
    "    best_algorithm, best_accuracy = print_info(clf, x, y, algorithm_name, best_accuracy, best_algorithm)\n",
    "    print('>', clf.coef_, '\\n')\n",
    "\n",
    "    #algorithm_name = 'Multi-layer Perceptron'\n",
    "    #clf = MLPClassifier(max_iter=500)\n",
    "    #best_algorithm, best_accuracy = print_info(clf, x, y, algorithm_name, best_accuracy, best_algorithm)\n",
    "    #print('>', clf.loss_, '\\n')\n",
    "\n",
    "    algorithm_name = 'AdaBoost'\n",
    "    clf = AdaBoostClassifier(n_estimators=25, random_state=0)\n",
    "    best_algorithm, best_accuracy = print_info(clf, x, y, algorithm_name, best_accuracy, best_algorithm)\n",
    "    print('>', clf.feature_importances_, '\\n')\n",
    "\n",
    "    algorithm_name = 'Random Forest'\n",
    "    clf = RandomForestClassifier(n_estimators=25, max_depth=2, random_state=0)\n",
    "    best_algorithm, best_accuracy = print_info(clf, x, y, algorithm_name, best_accuracy, best_algorithm)\n",
    "    print('>', clf.feature_importances_, '\\n')\n",
    "\n",
    "    print('The best algorithm is', best_algorithm, 'with a test accuracy of', best_accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stochastic Gradient Descent:\n",
      "> Train accuracy: 0.6651760200324055\n",
      "> Test accuracy: 0.6653091872791521\n",
      "> Precision: 0.7482311320754716\n",
      "> Recall: 0.5576796308503625\n",
      "> TSS Score: 0.36825036147439094\n",
      "> [[22.72788494 22.68873512  0.77658469]] \n",
      "\n",
      "AdaBoost:\n",
      "> Train accuracy: 0.7375460303432024\n",
      "> Test accuracy: 0.7306978798586573\n",
      "> Precision: 0.752422704199354\n",
      "> Recall: 0.7165458141067897\n",
      "> TSS Score: 0.47848230089337646\n",
      "> [0.36 0.56 0.08] \n",
      "\n",
      "Random Forest:\n",
      "> Train accuracy: 0.6444454264250994\n",
      "> Test accuracy: 0.6404858657243815\n",
      "> Precision: 0.787215411558669\n",
      "> Recall: 0.3950780048341024\n",
      "> TSS Score: 0.2873720310388548\n",
      "> [0.49189188 0.40427832 0.1038298 ] \n",
      "\n",
      "The best algorithm is AdaBoost with a test accuracy of 0.7306978798586573\n"
     ]
    }
   ],
   "source": [
    "run_learning_algorithms(x_data, y_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def graph_features(x, y, feature_names, max_num_graphs=float('inf')):\n",
    "    '''Given the feature data as x, this function will graph features versus each other.\n",
    "    Different outputs in y will be displayed in different colors. The function will graph\n",
    "    every combination of features, and print them.\n",
    "    '''\n",
    "    single_feature_vectors = [[] for _ in range(len(x[0]))]\n",
    "    colors = []\n",
    "    color_map = {True: 'r', False: 'b'}\n",
    "    for i, data_pt in enumerate(x):\n",
    "        colors.append(color_map[y[i]])\n",
    "        for j in range(len(data_pt)):\n",
    "            single_feature_vectors[j].append(data_pt[j])\n",
    "    count = 0\n",
    "    for i in range(len(x[0])):\n",
    "        for j in range(i + 1, len(x[0])):\n",
    "            count += 1\n",
    "            plot_graph(single_feature_vectors[i], single_feature_vectors[j],\n",
    "                       feature_names[i], feature_names[j],\n",
    "                       feature_names[i] + ' vs. ' + feature_names[j],\n",
    "                       clr=colors, scatter=True)\n",
    "            plt.show()\n",
    "            if count >= max_num_graphs: break\n",
    "        if count >= max_num_graphs: break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "graph_features(x_data, y_data, feature_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "## Plotting Metadata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section, I will include a few functions for graphing the results outputted from the machine learning modeling. Specifically, there is a method to understand the relationship between lag time and accuracy and a method to understand the importance of the coefficients in the models as lag time changes.\n",
    "\n",
    "The following two functions are used to get run the algorithms to get the data ready to be plotted and analyzed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lag_vs_accuracy_data(harp_ids, flare_time_dict, seg_x, seg_y, hour_range=range(2, 25),\n",
    "                         ada=False, tss=False, features=[spline_features],\n",
    "                         variables=['USFLUX', 'TOTPOT', 'AREA_ACR', 'R_VALUE']):\n",
    "    '''This function outputs lag time vs coefficient data in the form of a dictionary.\n",
    "    The dictionary keys are the variables in the variables parameter, and the values are\n",
    "    a list of three-tuples (lag time, accuracy, accuracy error) for all lag times in the\n",
    "    hour_range parameter. Note: the model is trained on a single variable with the learning\n",
    "    algorithm, so there will be len(variables) separate data series.\n",
    "    \n",
    "    This function normalizes the data before learning by ensuring that the data at the\n",
    "    beginning of the time series is set to zero. This makes sure that the algorithm learns\n",
    "    on time series instead of discrete features.\n",
    "\n",
    "    By default, the function will return accuracy data (i.e. accuracy over time). If tss is\n",
    "    set to true, it will return TSS data instead of accuracy data.\n",
    "\n",
    "    The default model used is stochastic gradient descent. If the ada parameter is set to\n",
    "    True, then an AdaBoost model will be used instead.\n",
    "\n",
    "    This function takes harp_ids, flare_time_dict, seg_x, and seg_y as inputs.\n",
    "\n",
    "    Note: The default range does not include hour 1. This is by design: for many of the\n",
    "    fitting features such as spline_features and cubic_features, it does not make sense to\n",
    "    fit on one hour (i.e. 5 data points) of data.\n",
    "    '''\n",
    "    data_dict = {}\n",
    "    for variable in variables: data_dict[variable] = [] # List of (time, accuracy, error)\n",
    "\n",
    "    # Preprocessing to ensure that all the values in new_seg_x are floats (not strings)\n",
    "    new_seg_x = []\n",
    "    for data in seg_x:\n",
    "        def map_to_float(series):\n",
    "            '''Function to map the elements of a series to floats.'''\n",
    "            def to_float(x):\n",
    "                '''Converts x to float unless x is a timestamp.'''\n",
    "                if type(x) is pandas.Timestamp: return x\n",
    "                return float(x)\n",
    "            return series.map(to_float)\n",
    "        new_seg_x.append(list(map(map_to_float, data)))\n",
    "\n",
    "    for lag in hour_range:\n",
    "        modified_seg_x = []\n",
    "        # Convert data into difference data\n",
    "        for data in new_seg_x:\n",
    "            end_time = data[-1]['TIME']\n",
    "            for i, point in enumerate(data):\n",
    "                if end_time - point['TIME'] < lag:\n",
    "                    data_tail = data[i:]\n",
    "                    data_tail = list(map(lambda x : x - data_tail[0], data_tail))\n",
    "                    modified_seg_x.append(data_tail)\n",
    "                    break\n",
    "        lag_time = round(modified_seg_x[0][-1]['TIME'] - modified_seg_x[0][0]['TIME'])\n",
    "        for variable in variables:\n",
    "            # Get data ready for model\n",
    "            x, y_data, feature_names = create_learning_dataset(modified_seg_x, seg_y, variable, features)\n",
    "            raw_x_data = np.array(x)\n",
    "            x_data = scale_x_data(raw_x_data)\n",
    "            assert(len(x_data) == len(y_data))\n",
    "\n",
    "            # Run model n times, and take the standard deviation to determine the error\n",
    "            n = 100\n",
    "            if ada: clf = AdaBoostClassifier(n_estimators=25, random_state=0)\n",
    "            else: clf = SGDClassifier(loss='hinge', penalty='l2')\n",
    "            accuracies = []\n",
    "            for _ in range(n):\n",
    "                x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.25)\n",
    "                clf.fit(x_train, y_train)\n",
    "                TP, TN, FP, FN = 0, 0, 0, 0\n",
    "                for i, data_pt in enumerate(x_test):\n",
    "                    prediction = clf.predict([data_pt])\n",
    "                    if prediction == y_test[i]:\n",
    "                        if prediction: TP += 1\n",
    "                        else: TN += 1\n",
    "                    else:\n",
    "                        if prediction: FP += 1\n",
    "                        else: FN += 1\n",
    "                if tss:\n",
    "                    accuracies.append(TP/(TP+FN) - FP/(FP+TN))\n",
    "                else:\n",
    "                    accuracies.append((TP + TN)/(TP + TN + FP + FN))\n",
    "            print(np.mean(accuracies))\n",
    "            mean_var = np.mean(accuracies)\n",
    "            var_error = np.std(accuracies)\n",
    "            data_dict[variable].append((lag_time, mean_var, var_error))\n",
    "    return data_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to create lag vs. accuracy graphs for every SHARP variable (except time; QUERY_VARIABLES includes a `time` variable as its first element):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['USFLUX', 'MEANGAM', 'MEANGBT', 'MEANGBZ', 'MEANGBH', 'MEANJZD', 'TOTUSJZ', 'MEANJZH', 'TOTUSJH', 'ABSNJZH', 'SAVNCPP', 'MEANPOT', 'TOTPOT', 'MEANSHR', 'SHRGT45', 'R_VALUE', 'AREA_ACR']\n"
     ]
    }
   ],
   "source": [
    "print(QUERY_VARIABLES.split(',')[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "accuracy_data_dict = lag_vs_accuracy_data(harp_ids, flare_time_dict, seg_x, seg_y,\n",
    "                                          ada=False, variables=QUERY_VARIABLES.split(',')[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lag_vs_coefficient_data(harp_ids, flare_time_dict, seg_x, seg_y, hour_range=range(2, 25),\n",
    "                            ada=False, features=[spline_features],\n",
    "                            f_score=False, variables=['USFLUX']):\n",
    "    '''This function outputs data of lag time vs. coefficient values for a machine learning\n",
    "    fit. This allows one to see how the relative importance of coefficients changes over time.\n",
    "    The function returns two lists: coef_data, which is the values of the coefficients at each\n",
    "    timestep, and time_data, which specifies the timesteps.\n",
    "\n",
    "    This function also has a f_score parameter. When this is set to true, the coefficient data\n",
    "    will be the ANOVA F-value computed for each feature for the data. By default this is false,\n",
    "    and the function returns the parameters of the machine learning fit.\n",
    "\n",
    "    (The paragraphs below are identical to lag_vs_accuracy_data)\n",
    "    The default model used is stochastic gradient descent. If the ada parameter is set to\n",
    "    True, then an AdaBoost model will be used instead.\n",
    "\n",
    "    This function takes harp_ids, flare_time_dict, seg_x, and seg_y as inputs.\n",
    "\n",
    "    Note: The default range does not include hour 1. This is by design: for many of the\n",
    "    fitting features such as spline_features and cubic_features, it does not make sense to\n",
    "    fit on one hour (i.e. 5 data points) of data.\n",
    "    '''\n",
    "    coef_data = {}\n",
    "    time_data = []\n",
    "    for variable in variables: coef_data[variable] = []\n",
    "\n",
    "    # Preprocessing to ensure that all the values in new_seg_x are floats (not strings)\n",
    "    new_seg_x = []\n",
    "    for data in seg_x:\n",
    "        def map_to_float(series):\n",
    "            '''Function to map the elements of a series to floats.'''\n",
    "            def to_float(x):\n",
    "                '''Converts x to float unless x is a timestamp.'''\n",
    "                if type(x) is pandas.Timestamp: return x\n",
    "                return float(x)\n",
    "            return series.map(to_float)\n",
    "        new_seg_x.append(list(map(map_to_float, data)))\n",
    "\n",
    "    for lag in hour_range:\n",
    "        modified_seg_x = []\n",
    "        # Take time off of the start\n",
    "        for data in new_seg_x:\n",
    "            end_time = data[-1]['TIME']\n",
    "            for i, point in enumerate(data):\n",
    "                if end_time - point['TIME'] < lag:\n",
    "                    data_tail = data[i:]\n",
    "                    data_tail = list(map(lambda x : x - data_tail[0], data_tail))\n",
    "                    modified_seg_x.append(data_tail)\n",
    "                    break\n",
    "        lag_time = round(modified_seg_x[0][-1]['TIME'] - modified_seg_x[0][0]['TIME'])\n",
    "        time_data.append(lag_time)\n",
    "        for variable in variables:\n",
    "            x, y_data, feature_names = create_learning_dataset(modified_seg_x, seg_y, variable, features)\n",
    "            raw_x_data = np.array(x)\n",
    "            x_data = scale_x_data(raw_x_data)\n",
    "            assert(len(x_data) == len(y_data))\n",
    "\n",
    "            # ANOVA F-value does not depend on a machine learning algorithm, so we can save\n",
    "            # time by not running the ML fit if f_score is True\n",
    "            if f_score:\n",
    "                selector = SelectKBest(f_classif, k='all')\n",
    "                selector.fit(x_data, y_data)\n",
    "                scores = selector.scores_\n",
    "                order = np.argsort(selector.scores_)\n",
    "                ordered_scores = list(map(lambda x : scores[x], order))\n",
    "                coef_data.append(ordered_scores)\n",
    "                continue\n",
    "\n",
    "            # Run model n times, and take the standard deviation to determine the error\n",
    "            n = 10\n",
    "            if ada: clf = AdaBoostClassifier(n_estimators=25, random_state=0)\n",
    "            else: clf = SGDClassifier(loss='hinge', penalty='l2')\n",
    "            coefs = []\n",
    "            for _ in range(n):\n",
    "                _, test_accuracy = fit_algorithm(clf, x_data, y_data, 1)\n",
    "                if ada: coefs.append(clf.feature_importances_)\n",
    "                else: coefs.append(clf.coef_[0])\n",
    "            coef_data[variable].append(sum(coefs) / len(coefs)) # Average coefficients\n",
    "    return coef_data, time_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "coef_data, time_data = lag_vs_coefficient_data(harp_ids, flare_time_dict, seg_x, seg_y,\n",
    "                                               variables=QUERY_VARIABLES.split(',')[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's import methods from the `bokeh` graphing module that we will use to plot data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div class=\"bk-root\">\n",
       "        <a href=\"https://bokeh.pydata.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n",
       "        <span id=\"1001\">Loading BokehJS ...</span>\n",
       "    </div>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/javascript": [
       "\n",
       "(function(root) {\n",
       "  function now() {\n",
       "    return new Date();\n",
       "  }\n",
       "\n",
       "  var force = true;\n",
       "\n",
       "  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n",
       "    root._bokeh_onload_callbacks = [];\n",
       "    root._bokeh_is_loading = undefined;\n",
       "  }\n",
       "\n",
       "  var JS_MIME_TYPE = 'application/javascript';\n",
       "  var HTML_MIME_TYPE = 'text/html';\n",
       "  var EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n",
       "  var CLASS_NAME = 'output_bokeh rendered_html';\n",
       "\n",
       "  /**\n",
       "   * Render data to the DOM node\n",
       "   */\n",
       "  function render(props, node) {\n",
       "    var script = document.createElement(\"script\");\n",
       "    node.appendChild(script);\n",
       "  }\n",
       "\n",
       "  /**\n",
       "   * Handle when an output is cleared or removed\n",
       "   */\n",
       "  function handleClearOutput(event, handle) {\n",
       "    var cell = handle.cell;\n",
       "\n",
       "    var id = cell.output_area._bokeh_element_id;\n",
       "    var server_id = cell.output_area._bokeh_server_id;\n",
       "    // Clean up Bokeh references\n",
       "    if (id != null && id in Bokeh.index) {\n",
       "      Bokeh.index[id].model.document.clear();\n",
       "      delete Bokeh.index[id];\n",
       "    }\n",
       "\n",
       "    if (server_id !== undefined) {\n",
       "      // Clean up Bokeh references\n",
       "      var cmd = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n",
       "      cell.notebook.kernel.execute(cmd, {\n",
       "        iopub: {\n",
       "          output: function(msg) {\n",
       "            var id = msg.content.text.trim();\n",
       "            if (id in Bokeh.index) {\n",
       "              Bokeh.index[id].model.document.clear();\n",
       "              delete Bokeh.index[id];\n",
       "            }\n",
       "          }\n",
       "        }\n",
       "      });\n",
       "      // Destroy server and session\n",
       "      var cmd = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n",
       "      cell.notebook.kernel.execute(cmd);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  /**\n",
       "   * Handle when a new output is added\n",
       "   */\n",
       "  function handleAddOutput(event, handle) {\n",
       "    var output_area = handle.output_area;\n",
       "    var output = handle.output;\n",
       "\n",
       "    // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n",
       "    if ((output.output_type != \"display_data\") || (!output.data.hasOwnProperty(EXEC_MIME_TYPE))) {\n",
       "      return\n",
       "    }\n",
       "\n",
       "    var toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n",
       "\n",
       "    if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n",
       "      toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n",
       "      // store reference to embed id on output_area\n",
       "      output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n",
       "    }\n",
       "    if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n",
       "      var bk_div = document.createElement(\"div\");\n",
       "      bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n",
       "      var script_attrs = bk_div.children[0].attributes;\n",
       "      for (var i = 0; i < script_attrs.length; i++) {\n",
       "        toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n",
       "      }\n",
       "      // store reference to server id on output_area\n",
       "      output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n",
       "    }\n",
       "  }\n",
       "\n",
       "  function register_renderer(events, OutputArea) {\n",
       "\n",
       "    function append_mime(data, metadata, element) {\n",
       "      // create a DOM node to render to\n",
       "      var toinsert = this.create_output_subarea(\n",
       "        metadata,\n",
       "        CLASS_NAME,\n",
       "        EXEC_MIME_TYPE\n",
       "      );\n",
       "      this.keyboard_manager.register_events(toinsert);\n",
       "      // Render to node\n",
       "      var props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n",
       "      render(props, toinsert[toinsert.length - 1]);\n",
       "      element.append(toinsert);\n",
       "      return toinsert\n",
       "    }\n",
       "\n",
       "    /* Handle when an output is cleared or removed */\n",
       "    events.on('clear_output.CodeCell', handleClearOutput);\n",
       "    events.on('delete.Cell', handleClearOutput);\n",
       "\n",
       "    /* Handle when a new output is added */\n",
       "    events.on('output_added.OutputArea', handleAddOutput);\n",
       "\n",
       "    /**\n",
       "     * Register the mime type and append_mime function with output_area\n",
       "     */\n",
       "    OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n",
       "      /* Is output safe? */\n",
       "      safe: true,\n",
       "      /* Index of renderer in `output_area.display_order` */\n",
       "      index: 0\n",
       "    });\n",
       "  }\n",
       "\n",
       "  // register the mime type if in Jupyter Notebook environment and previously unregistered\n",
       "  if (root.Jupyter !== undefined) {\n",
       "    var events = require('base/js/events');\n",
       "    var OutputArea = require('notebook/js/outputarea').OutputArea;\n",
       "\n",
       "    if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n",
       "      register_renderer(events, OutputArea);\n",
       "    }\n",
       "  }\n",
       "\n",
       "  \n",
       "  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n",
       "    root._bokeh_timeout = Date.now() + 5000;\n",
       "    root._bokeh_failed_load = false;\n",
       "  }\n",
       "\n",
       "  var NB_LOAD_WARNING = {'data': {'text/html':\n",
       "     \"<div style='background-color: #fdd'>\\n\"+\n",
       "     \"<p>\\n\"+\n",
       "     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n",
       "     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n",
       "     \"</p>\\n\"+\n",
       "     \"<ul>\\n\"+\n",
       "     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n",
       "     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n",
       "     \"</ul>\\n\"+\n",
       "     \"<code>\\n\"+\n",
       "     \"from bokeh.resources import INLINE\\n\"+\n",
       "     \"output_notebook(resources=INLINE)\\n\"+\n",
       "     \"</code>\\n\"+\n",
       "     \"</div>\"}};\n",
       "\n",
       "  function display_loaded() {\n",
       "    var el = document.getElementById(\"1001\");\n",
       "    if (el != null) {\n",
       "      el.textContent = \"BokehJS is loading...\";\n",
       "    }\n",
       "    if (root.Bokeh !== undefined) {\n",
       "      if (el != null) {\n",
       "        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n",
       "      }\n",
       "    } else if (Date.now() < root._bokeh_timeout) {\n",
       "      setTimeout(display_loaded, 100)\n",
       "    }\n",
       "  }\n",
       "\n",
       "\n",
       "  function run_callbacks() {\n",
       "    try {\n",
       "      root._bokeh_onload_callbacks.forEach(function(callback) {\n",
       "        if (callback != null)\n",
       "          callback();\n",
       "      });\n",
       "    } finally {\n",
       "      delete root._bokeh_onload_callbacks\n",
       "    }\n",
       "    console.debug(\"Bokeh: all callbacks have finished\");\n",
       "  }\n",
       "\n",
       "  function load_libs(css_urls, js_urls, callback) {\n",
       "    if (css_urls == null) css_urls = [];\n",
       "    if (js_urls == null) js_urls = [];\n",
       "\n",
       "    root._bokeh_onload_callbacks.push(callback);\n",
       "    if (root._bokeh_is_loading > 0) {\n",
       "      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n",
       "      return null;\n",
       "    }\n",
       "    if (js_urls == null || js_urls.length === 0) {\n",
       "      run_callbacks();\n",
       "      return null;\n",
       "    }\n",
       "    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n",
       "    root._bokeh_is_loading = css_urls.length + js_urls.length;\n",
       "\n",
       "    function on_load() {\n",
       "      root._bokeh_is_loading--;\n",
       "      if (root._bokeh_is_loading === 0) {\n",
       "        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n",
       "        run_callbacks()\n",
       "      }\n",
       "    }\n",
       "\n",
       "    function on_error() {\n",
       "      console.error(\"failed to load \" + url);\n",
       "    }\n",
       "\n",
       "    for (var i = 0; i < css_urls.length; i++) {\n",
       "      var url = css_urls[i];\n",
       "      const element = document.createElement(\"link\");\n",
       "      element.onload = on_load;\n",
       "      element.onerror = on_error;\n",
       "      element.rel = \"stylesheet\";\n",
       "      element.type = \"text/css\";\n",
       "      element.href = url;\n",
       "      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n",
       "      document.body.appendChild(element);\n",
       "    }\n",
       "\n",
       "    for (var i = 0; i < js_urls.length; i++) {\n",
       "      var url = js_urls[i];\n",
       "      var element = document.createElement('script');\n",
       "      element.onload = on_load;\n",
       "      element.onerror = on_error;\n",
       "      element.async = false;\n",
       "      element.src = url;\n",
       "      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n",
       "      document.head.appendChild(element);\n",
       "    }\n",
       "  };var element = document.getElementById(\"1001\");\n",
       "  if (element == null) {\n",
       "    console.error(\"Bokeh: ERROR: autoload.js configured with elementid '1001' but no matching script tag was found. \")\n",
       "    return false;\n",
       "  }\n",
       "\n",
       "  function inject_raw_css(css) {\n",
       "    const element = document.createElement(\"style\");\n",
       "    element.appendChild(document.createTextNode(css));\n",
       "    document.body.appendChild(element);\n",
       "  }\n",
       "\n",
       "  var js_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-gl-1.3.2.min.js\"];\n",
       "  var css_urls = [];\n",
       "\n",
       "  var inline_js = [\n",
       "    function(Bokeh) {\n",
       "      Bokeh.set_log_level(\"info\");\n",
       "    },\n",
       "    \n",
       "    function(Bokeh) {\n",
       "      \n",
       "    },\n",
       "    function(Bokeh) {} // ensure no trailing comma for IE\n",
       "  ];\n",
       "\n",
       "  function run_inline_js() {\n",
       "    \n",
       "    if ((root.Bokeh !== undefined) || (force === true)) {\n",
       "      for (var i = 0; i < inline_js.length; i++) {\n",
       "        inline_js[i].call(root, root.Bokeh);\n",
       "      }if (force === true) {\n",
       "        display_loaded();\n",
       "      }} else if (Date.now() < root._bokeh_timeout) {\n",
       "      setTimeout(run_inline_js, 100);\n",
       "    } else if (!root._bokeh_failed_load) {\n",
       "      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n",
       "      root._bokeh_failed_load = true;\n",
       "    } else if (force !== true) {\n",
       "      var cell = $(document.getElementById(\"1001\")).parents('.cell').data().cell;\n",
       "      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n",
       "    }\n",
       "\n",
       "  }\n",
       "\n",
       "  if (root._bokeh_is_loading === 0) {\n",
       "    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n",
       "    run_inline_js();\n",
       "  } else {\n",
       "    load_libs(css_urls, js_urls, function() {\n",
       "      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n",
       "      run_inline_js();\n",
       "    });\n",
       "  }\n",
       "}(window));"
      ],
      "application/vnd.bokehjs_load.v0+json": "\n(function(root) {\n  function now() {\n    return new Date();\n  }\n\n  var force = true;\n\n  if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n    root._bokeh_onload_callbacks = [];\n    root._bokeh_is_loading = undefined;\n  }\n\n  \n\n  \n  if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n    root._bokeh_timeout = Date.now() + 5000;\n    root._bokeh_failed_load = false;\n  }\n\n  var NB_LOAD_WARNING = {'data': {'text/html':\n     \"<div style='background-color: #fdd'>\\n\"+\n     \"<p>\\n\"+\n     \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n     \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n     \"</p>\\n\"+\n     \"<ul>\\n\"+\n     \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n     \"<li>use INLINE resources instead, as so:</li>\\n\"+\n     \"</ul>\\n\"+\n     \"<code>\\n\"+\n     \"from bokeh.resources import INLINE\\n\"+\n     \"output_notebook(resources=INLINE)\\n\"+\n     \"</code>\\n\"+\n     \"</div>\"}};\n\n  function display_loaded() {\n    var el = document.getElementById(\"1001\");\n    if (el != null) {\n      el.textContent = \"BokehJS is loading...\";\n    }\n    if (root.Bokeh !== undefined) {\n      if (el != null) {\n        el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n      }\n    } else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(display_loaded, 100)\n    }\n  }\n\n\n  function run_callbacks() {\n    try {\n      root._bokeh_onload_callbacks.forEach(function(callback) {\n        if (callback != null)\n          callback();\n      });\n    } finally {\n      delete root._bokeh_onload_callbacks\n    }\n    console.debug(\"Bokeh: all callbacks have finished\");\n  }\n\n  function load_libs(css_urls, js_urls, callback) {\n    if (css_urls == null) css_urls = [];\n    if (js_urls == null) js_urls = [];\n\n    root._bokeh_onload_callbacks.push(callback);\n    if (root._bokeh_is_loading > 0) {\n      console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n      return null;\n    }\n    if (js_urls == null || js_urls.length === 0) {\n      run_callbacks();\n      return null;\n    }\n    console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n    root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n    function on_load() {\n      root._bokeh_is_loading--;\n      if (root._bokeh_is_loading === 0) {\n        console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n        run_callbacks()\n      }\n    }\n\n    function on_error() {\n      console.error(\"failed to load \" + url);\n    }\n\n    for (var i = 0; i < css_urls.length; i++) {\n      var url = css_urls[i];\n      const element = document.createElement(\"link\");\n      element.onload = on_load;\n      element.onerror = on_error;\n      element.rel = \"stylesheet\";\n      element.type = \"text/css\";\n      element.href = url;\n      console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n      document.body.appendChild(element);\n    }\n\n    for (var i = 0; i < js_urls.length; i++) {\n      var url = js_urls[i];\n      var element = document.createElement('script');\n      element.onload = on_load;\n      element.onerror = on_error;\n      element.async = false;\n      element.src = url;\n      console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n      document.head.appendChild(element);\n    }\n  };var element = document.getElementById(\"1001\");\n  if (element == null) {\n    console.error(\"Bokeh: ERROR: autoload.js configured with elementid '1001' but no matching script tag was found. \")\n    return false;\n  }\n\n  function inject_raw_css(css) {\n    const element = document.createElement(\"style\");\n    element.appendChild(document.createTextNode(css));\n    document.body.appendChild(element);\n  }\n\n  var js_urls = [\"https://cdn.pydata.org/bokeh/release/bokeh-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-widgets-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-tables-1.3.2.min.js\", \"https://cdn.pydata.org/bokeh/release/bokeh-gl-1.3.2.min.js\"];\n  var css_urls = [];\n\n  var inline_js = [\n    function(Bokeh) {\n      Bokeh.set_log_level(\"info\");\n    },\n    \n    function(Bokeh) {\n      \n    },\n    function(Bokeh) {} // ensure no trailing comma for IE\n  ];\n\n  function run_inline_js() {\n    \n    if ((root.Bokeh !== undefined) || (force === true)) {\n      for (var i = 0; i < inline_js.length; i++) {\n        inline_js[i].call(root, root.Bokeh);\n      }if (force === true) {\n        display_loaded();\n      }} else if (Date.now() < root._bokeh_timeout) {\n      setTimeout(run_inline_js, 100);\n    } else if (!root._bokeh_failed_load) {\n      console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n      root._bokeh_failed_load = true;\n    } else if (force !== true) {\n      var cell = $(document.getElementById(\"1001\")).parents('.cell').data().cell;\n      cell.output_area.append_execute_result(NB_LOAD_WARNING)\n    }\n\n  }\n\n  if (root._bokeh_is_loading === 0) {\n    console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n    run_inline_js();\n  } else {\n    load_libs(css_urls, js_urls, function() {\n      console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n      run_inline_js();\n    });\n  }\n}(window));"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from bokeh.plotting import figure, show, ColumnDataSource\n",
    "from bokeh.models import HoverTool, Legend, Band, Range1d\n",
    "from bokeh.io import output_notebook\n",
    "output_notebook()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next functions are used to plot the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Colors taken from colorbrewer\n",
    "COLORS = ['#a6cee3', '#1f78b4', '#b2df8a', '#33a02c', '#fb9a99', '#e31a1c', '#fdbf6f',\n",
    "          '#ff7f00', '#cab2d6', '#6a3d9a', '#ffff99', '#b15928', '#8dd3c7', '#fdb462',\n",
    "          '#d9d9d9', '#ffed6f', '#e31a1c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_variable_data(data_dict, variables=None, parameter='accuracy'):\n",
    "    '''This function plots the variable vs. lag time data of the given input data_dict\n",
    "    using the bokeh plotting library.\n",
    "\n",
    "    If variables is set to None, this function will plot all variables in data_dict. Else\n",
    "    it will plot all the variables in variables.\n",
    "\n",
    "    The parameter input is for labeling the graph. By default it is accuracy, and will\n",
    "    include this word in the title, y axis, and on the tooltips.\n",
    "    '''\n",
    "    variable_data, error_data = {}, {}\n",
    "    time_data, items = [], []\n",
    "    for var in data_dict:\n",
    "        # Parse tuples in data_dict\n",
    "        time_data, variable_subset, error_subset= [], [], []\n",
    "        for tup in data_dict[var]:\n",
    "            time_data.append(tup[0])\n",
    "            variable_subset.append(tup[1])\n",
    "            error_subset.append(tup[2])\n",
    "        variable_data[var] = variable_subset\n",
    "        error_data[var] = error_subset\n",
    "\n",
    "    # Basic plot setup\n",
    "    plot = figure(plot_width=800, plot_height=600, tools='',\n",
    "                  toolbar_location=None, title='Lag time vs. ' + parameter,\n",
    "                  x_axis_label='Lag time (hours)', y_axis_label=parameter.capitalize())\n",
    "\n",
    "    circles = []\n",
    "    min_val = 1\n",
    "    max_val = 0\n",
    "    for i, var in enumerate(variable_data):\n",
    "        if variables:\n",
    "            if var not in variables: continue\n",
    "        source = ColumnDataSource(data=dict(\n",
    "            x_data = time_data,\n",
    "            y_data = variable_data[var],\n",
    "        ))\n",
    "        item = plot.line('x_data', 'y_data', line_width=1, line_alpha=0.5,\n",
    "                         color=COLORS[i], source=source)\n",
    "        items.append((var, [item]))\n",
    "        circles.append(plot.circle('x_data', 'y_data', size=10, source=source,\n",
    "                       fill_color=COLORS[i], hover_fill_color=COLORS[i],\n",
    "                       fill_alpha=0.25, hover_alpha=0.5,\n",
    "                       line_color=None, hover_line_color='white'))\n",
    "\n",
    "        # Used for creating error bands\n",
    "        err_xs, err_ys = [], []\n",
    "        for x, y, y_err in zip(time_data, variable_data[var], error_data[var]):\n",
    "            if y + y_err / 2 > max_val: max_val = y + y_err / 2\n",
    "            if y - y_err / 2 < min_val: min_val = y - y_err / 2\n",
    "            err_xs.append((x, x))\n",
    "            err_ys.append((y - y_err / 2, y + y_err / 2))\n",
    "\n",
    "        source = ColumnDataSource({\n",
    "            'base': time_data,\n",
    "            'lower': list(map(lambda x : x[0], err_ys)),\n",
    "            'upper': list(map(lambda x : x[1], err_ys))\n",
    "        })\n",
    "\n",
    "        band = Band(base='base', lower='lower', upper='upper', source=source, \n",
    "                    level='underlay', fill_alpha=.5, line_width=1,\n",
    "                    line_color='black', fill_color=COLORS[i])\n",
    "        plot.add_layout(band)\n",
    "\n",
    "    plot.add_tools(HoverTool(tooltips=[(parameter.capitalize(), '@y_data %')], renderers=circles,\n",
    "                             mode='vline'))\n",
    "    plot.y_range = Range1d(min_val - (max_val - min_val) / 10,\n",
    "                           max_val  + (max_val - min_val) / 10)\n",
    "    plot.x_range = Range1d(0, 25)\n",
    "    plot.y_range = Range1d(0.45, 0.65)\n",
    "    legend = Legend(items=items)\n",
    "    legend.click_policy='hide'\n",
    "    plot.add_layout(legend, 'right')\n",
    "\n",
    "    plot.title.text_font_size = '16pt'\n",
    "    plot.xaxis.axis_label_text_font_size = \"16pt\"\n",
    "    plot.yaxis.axis_label_text_font_size = \"16pt\"\n",
    "    plot.yaxis.axis_label_text_font_size = \"16pt\"\n",
    "    show(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#plot_variable_data(accuracy_data_dict, variables=['TOTUSJH', 'TOTUSJZ', 'MEANJZD', 'R_VALUE', 'USFLUX', 'TOTPOT'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_coef_data(coef_data, time_data):\n",
    "    '''This function plots the coefficient data vs. lag time with the bokeh plotting\n",
    "    library. Each coefficient is displayed as a separate color.\n",
    "    '''\n",
    "    coef_data = np.array(coef_data)\n",
    "    transposed_data = coef_data.transpose()\n",
    "\n",
    "    sums = []\n",
    "    for var in coef_data:\n",
    "        sums.append(sum(list(map(lambda x : abs(x), var))) + 0.01)\n",
    "    normalized_data = []\n",
    "    for var in transposed_data:\n",
    "        normalized_data.append([abs(x) / sums[i] for i, x in enumerate(var)])\n",
    "\n",
    "    # Basic plot setup\n",
    "    plot = figure(plot_width=600, plot_height=300, tools='',\n",
    "                  toolbar_location=None, title='Lag time vs. feature importances',\n",
    "                  x_axis_label='Lag time (hr)', y_axis_label='Importance')\n",
    "\n",
    "    circles = []\n",
    "    items = []\n",
    "    for i, var in enumerate(normalized_data):\n",
    "        source = ColumnDataSource(data=dict(\n",
    "            x_data = time_data,\n",
    "            y_data = var\n",
    "        ))\n",
    "        item = plot.line('x_data', 'y_data', line_width=1, color=COLORS[i], source=source)\n",
    "        items.append(('coef ' + str(i + 1), [item]))\n",
    "        circles.append(plot.circle('x_data', 'y_data', size=10, source=source,\n",
    "                       fill_color=COLORS[i], hover_fill_color=COLORS[i],\n",
    "                       fill_alpha=0.25, hover_alpha=0.5,\n",
    "                       line_color=None, hover_line_color='white'))\n",
    "\n",
    "    plot.add_tools(HoverTool(tooltips=[('Importance', '@y_data')], renderers=circles,\n",
    "                             mode='vline'))\n",
    "    plot.x_range = Range1d(0, 25)\n",
    "    legend = Legend(items=items)\n",
    "\n",
    "    plot.add_layout(legend, 'right')\n",
    "    plot.legend.click_policy='hide'\n",
    "    \n",
    "    show(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_coef_data(coef_data['USFLUX'], time_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The plot above is confusing. If we want to plot only specific features, we can manipulate the `coef_data` before passing it into `plot_coef_data`.\n",
    "\n",
    "We will splice the data such that we only plot `coef 2` and `coef 6`. These specific variables are meaningful because `coef 2` corresponds to the first half of the lag time and `coef 6` corresponds to the last half of the lag time. This is due to the properties of B-splines. Note: this is only true if we are plotting coefficients for `spline_features`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "spliced_data = list(map(lambda x : [x[1], x[-2]], coef_data['USFLUX']))\n",
    "plot_coef_data(spliced_data, time_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we have a function that plots the importance of the feature for spline fitting over time. This is built by using the ratios of the two variables above. Since the ratio between the two coefficients corresponds to the relative importance of the first and second half of the lag time, we can make a plot that reflects this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "def plot_spline_feature_importance(coef_data, time_data):\n",
    "    '''This method takes coefficient data and time data, and creates a plot of the\n",
    "    importance of the time series data for the spline model over time.\n",
    "    '''\n",
    "    first_and_last = list(map(lambda x : [abs(x[1]), abs(x[-2])], coef_data))\n",
    "\n",
    "    def normalize_points(point):\n",
    "        '''This method takes a list of two values and returns the normalized list.\n",
    "        It is normalized such that both numbers sum to 1.\n",
    "        '''\n",
    "        if point[0] == 0 and point[1] == 0: return [0.5, 0.5] # Inconclusive\n",
    "        else:\n",
    "            point_sum = point[0] + point[1]\n",
    "            return [point[0] / point_sum, point[1] / point_sum]\n",
    "    normalized_data = list(map(normalize_points, first_and_last))\n",
    "\n",
    "    time_dict = {}\n",
    "    for i, t in enumerate(time_data):\n",
    "        contains_nan = False\n",
    "        for coef in normalized_data[i]:\n",
    "            if np.isnan(coef): contains_nan = True\n",
    "        if contains_nan: continue\n",
    "        time_dict[t] = normalized_data[i]\n",
    "\n",
    "    time_points, data_points, data_point_ranges = [], [], []\n",
    "    for i, lag_time in enumerate(time_dict.keys()):\n",
    "        if i == 0:\n",
    "            time_points += [24 - lag_time * 3/4, 24 - lag_time/4]\n",
    "            data_points += time_dict[lag_time]\n",
    "            data_point_ranges += [(24 - lag_time, 24 - lag_time/2),\n",
    "                                  (24 - lag_time/2, 24)]\n",
    "        else:\n",
    "            # Keep track of areas since many areas overlap\n",
    "            second_half_area, first_half_area = 0, 0\n",
    "            second_half_range = (24 - lag_time/2, 24)\n",
    "            first_half_range = (24 - lag_time, 24 - lag_time/2)\n",
    "            for j, d in enumerate(data_point_ranges):\n",
    "                second_overlap, first_overlap = 0, 0\n",
    "                if second_half_range[1] > d[0]:\n",
    "                    second_overlap = (min(second_half_range[1], d[1]) -\n",
    "                                      max(second_half_range[0], d[0]))\n",
    "                    if second_overlap < 0: second_overlap = 0\n",
    "                second_half_area += second_overlap * data_points[j]\n",
    "                if first_half_range[1] > d[0]:\n",
    "                    first_overlap = min(first_half_range[1], d[1]) -  d[0]\n",
    "                first_half_area += first_overlap * data_points[j]\n",
    "            width = 1\n",
    "            # Adding 0.1 smooths the ratios\n",
    "            ratio = (time_dict[lag_time][0] + 0.1) / (time_dict[lag_time][1] + 0.1)\n",
    "            if ratio * second_half_area - first_half_area < 0:\n",
    "                average_ratio = (first_half_area / second_half_area + ratio) / 2\n",
    "                factor = average_ratio / (first_half_area / second_half_area)\n",
    "                for k, d in enumerate(data_point_ranges):\n",
    "                    if first_half_range[1] > d[0]:\n",
    "                        data_points[k] *= factor\n",
    "                data_points.append(0)\n",
    "            else:\n",
    "                data_points.append((ratio * second_half_area - first_half_area) / width)\n",
    "            data_point_ranges.append((24 - lag_time, 24 - lag_time + width))\n",
    "            time_points.append(24 - lag_time * 3/4)\n",
    "\n",
    "        areas = ([x * (data_point_ranges[i][1] - data_point_ranges[i][0])\n",
    "                  for i, x in enumerate(data_points)])\n",
    "        total_area = sum(areas)\n",
    "        data_points = list(map(lambda x : x / total_area, data_points))\n",
    "\n",
    "    # Create plot\n",
    "    plot = figure(plot_width=600, plot_height=300, tools='', x_range=[0,24],\n",
    "                  toolbar_location=None, title='Feature importance over time',\n",
    "                  x_axis_label='Time', y_axis_label='Importance')\n",
    "    source = ColumnDataSource(data=dict(\n",
    "        x_data = time_points,\n",
    "        y_data = data_points\n",
    "    ))\n",
    "    plot.circle('x_data', 'y_data', size=10, source=source,\n",
    "                fill_color='red', fill_alpha=1, line_color=None)\n",
    "    # To avoid division by 0, replace all 0s with 0.01\n",
    "    data_points = list(map(lambda x : x + 0.01, data_points))\n",
    "    reg = LinearRegression().fit(np.array(time_points).reshape(-1, 1), data_points)\n",
    "    plot.line([time_data[0], time_data[-1]],\n",
    "              [reg.predict([[time_data[0]]])[0],\n",
    "               reg.predict([[time_data[-1]]])[0]], line_width=2)\n",
    "    show(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_spline_feature_importance(coef_data['USFLUX'], time_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we can plot the difference in the importance of the first half of the lag time (coefficient 2) versus the importance of the last half of the lag time (coefficient 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_difference_data(coef_data, time_data):\n",
    "    '''\n",
    "    '''\n",
    "    normalized_coef_data = {}\n",
    "    def normalize_points(point):\n",
    "        '''This method takes a list of two values and returns the ratio of the\n",
    "        second data point to the first data point.\n",
    "        '''\n",
    "        if point[0] == 0 and point[1] == 0: return 1 # Inconclusive\n",
    "        else:\n",
    "            point_sum = point[0] + point[1]\n",
    "            return (point[1] - point[0]) / point_sum\n",
    "    for coef in coef_data:\n",
    "        normalized_coef_data[coef] = list(map(lambda x : [abs(x[1]), abs(x[-2])], coef_data[coef]))\n",
    "        normalized_coef_data[coef] = list(map(normalize_points, normalized_coef_data[coef]))\n",
    "\n",
    "    # Basic plot setup\n",
    "    plot = figure(plot_width=600, plot_height=400, tools='',\n",
    "                  toolbar_location=None, title='Lag time vs. ratios',\n",
    "                  x_axis_label='Lag time (hr)', y_axis_label='Difference')\n",
    "\n",
    "    circles = []\n",
    "    items = []\n",
    "    for i, var in enumerate(normalized_coef_data):\n",
    "        source = ColumnDataSource(data=dict(\n",
    "            x_data = time_data,\n",
    "            y_data = normalized_coef_data[var]\n",
    "        ))\n",
    "        item = plot.line('x_data', 'y_data', line_width=1, color=COLORS[i], source=source)\n",
    "        items.append((var + ' ratio', [item]))\n",
    "        circles.append(plot.circle('x_data', 'y_data', size=10, source=source,\n",
    "                       fill_color=COLORS[i], hover_fill_color=COLORS[i],\n",
    "                       fill_alpha=0.25, hover_alpha=0.5,\n",
    "                       line_color=None, hover_line_color='white'))\n",
    "\n",
    "    plot.add_tools(HoverTool(tooltips=[('Ratio', '@y_data')], renderers=circles,\n",
    "                             mode='vline'))\n",
    "    plot.x_range = Range1d(0, 25)\n",
    "    legend = Legend(items=items)\n",
    "\n",
    "    plot.add_layout(legend, 'right')\n",
    "    plot.legend.click_policy='hide'\n",
    "    \n",
    "    show(plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plot_difference_data(coef_data, time_data)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}