Detecting Bursty Terms in Computer Science.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Detecting Bursty Terms in Computer Science Research Using Text Mining\n",
    "\n",
    "**E. Tattershall, G. Nenadic, R.D. Stevens**\n",
    "\n",
    "**Abstract**\n",
    "\n",
    "Research topics rise and fall in popularity over time, some more swiftly than others. The fastest rising topics are typically called *bursts*; e.g. `deep learning`, `internet of things` and `big data`. Being able to detect and track bursty terms in the literature could give insight into how scientific thought evolves over time.\n",
    "\n",
    "\n",
    "In this paper, we take a trend detection algorithm from technical stock market analysis and apply it to 31 years of computer science research abstracts, treating the prevalence of each term in the dataset like the price of a stock. Unlike previous work in this domain, we use the free text of abstracts and titles, resulting in a finer-grained analysis. We report a list of bursty terms, then use historical data to build a classifier to predict whether they will rise or fall in popularity in the future, obtaining accuracy in the region of 80%. As a consequence, we now have a pipeline that can be applied to any time-ordered collection of text to yield past and present bursty terms and predict their probable fate.\n",
    "\n",
    "**Data collection**\n",
    "\n",
    "- We downloaded data from DBLP (api:, alternative= semantic scholar)\n",
    "- Automatically detected and labelled non-English language abstracts using: \n",
    "- Unpacked into MySQL database\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "# Visualisation\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# database\n",
    "import _mysql\n",
    "\n",
    "# monitoring\n",
    "import time\n",
    "\n",
    "# data cleaning\n",
    "import re\n",
    "\n",
    "# lemmatisation\n",
    "from collections import defaultdict\n",
    "from nltk.stem import WordNetLemmatizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "# intermediate storage\n",
    "import csv\n",
    "import pandas as pd\n",
    "import pickle\n",
    "\n",
    "# stats\n",
    "import numpy as np\n",
    "\n",
    "# stopwords\n",
    "from nltk.corpus import stopwords\n",
    "\n",
    "# Clustering\n",
    "from scipy.spatial.distance import squareform\n",
    "from scipy.cluster import hierarchy\n",
    "\n",
    "# Machine learning\n",
    "import sklearn\n",
    "from sklearn import datasets, linear_model\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import svm\n",
    "from sklearn.model_selection import KFold\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import tree\n",
    "from sklearn.metrics import roc_curve, auc\n",
    "from matplotlib.legend_handler import HandlerLine2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choice of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [],
   "source": [
    "ngram_length = 3\n",
    "min_yearly_df = 5\n",
    "\n",
    "long_ma_length = 12\n",
    "short_ma_length = 6\n",
    "signal_line_ma = 3\n",
    "significance_ma_length = 3\n",
    "\n",
    "significance_threshold = 0.0002\n",
    "years_above_significance = 3\n",
    "testing_period = 3\n",
    "\n",
    "# Detection threshold is set such that the top 500 terms are chosen\n",
    "burstiness_threshold_prediction = 0.003\n",
    "burstiness_threshold_detection = 0.002451\n",
    "\n",
    "plt.rcParams['xtick.labelsize'] = 11\n",
    "plt.rcParams['ytick.labelsize'] = 11\n",
    "plt.rc('font', family='sans-serif')\n",
    "\n",
    "year_range = list(range(1988,2018))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabets= \"([A-Za-z])\"\n",
    "prefixes = \"(Mr|St|Mrs|Ms|Dr)[.]\"\n",
    "suffixes = \"(Inc|Ltd|Jr|Sr|Co)\"\n",
    "starters = \"(Mr|Mrs|Ms|Dr|He\\s|She\\s|It\\s|They\\s|Their\\s|Our\\s|We\\s|But\\s|However\\s|That\\s|This\\s|Wherever)\"\n",
    "acronyms = \"([A-Z][.][A-Z][.](?:[A-Z][.])?)\"\n",
    "websites = \"[.](com|net|org|io|gov)\"\n",
    "htmltags = '<[^>]+>'\n",
    "htmlspecial = '&#?[xX]?[a-zA-Z0-9]{2,8};'\n",
    "\n",
    "start_delimiter = 'documentstart'\n",
    "sent_delimiter = 'sentenceboundary'\n",
    "end_delimiter = 'documentend'\n",
    "\n",
    "delimiters = [start_delimiter, sent_delimiter, end_delimiter]\n",
    "\n",
    "# Download the lemmatisesr\n",
    "wnl = WordNetLemmatizer()\n",
    "\n",
    "# Create a tokeniser\n",
    "count = CountVectorizer(strip_accents='ascii', min_df=1)\n",
    "tokeniser = count.build_analyzer()\n",
    "\n",
    "def normalise_acronymns(text):\n",
    "    '''\n",
    "    Remove the periods in acronyms. \n",
    "    Adapted from the method found at https://stackoverflow.com/a/40197005 \n",
    "    '''\n",
    "    return re.sub(r'(?<!\\w)([A-Z, a-z])\\.', r'\\1', text)\n",
    "\n",
    "def normalise_decimals(text):\n",
    "    '''\n",
    "    Remove the periods in decimal numbers and replace with POINT\n",
    "    '''\n",
    "    return re.sub(r'([0-9])\\.([0-9])', r'\\1POINT\\2', text)\n",
    "\n",
    "def split_into_sentences(text):\n",
    "    '''\n",
    "    Sentence splitter adapted from https://stackoverflow.com/a/31505798\n",
    "    '''\n",
    "    text = text.replace(\"\\n\",\" \")\n",
    "    text = re.sub(prefixes,\"\\\\1<prd>\",text)\n",
    "    text = re.sub(websites,\"<prd>\\\\1\",text)\n",
    "    \n",
    "    # my addition\n",
    "    text = re.sub(htmltags, \" \", text)\n",
    "    text = re.sub(htmlspecial, \" \", text)\n",
    "    \n",
    "    if \"Ph.D\" in text: \n",
    "        text = text.replace(\"Ph.D.\",\"PhD\")\n",
    "        \n",
    "    text = re.sub(\"\\s\" + alphabets + \"[.] \",\" \\\\1\",text)\n",
    "    text = re.sub(acronyms+\" \"+starters,\"\\\\1<stop> \\\\2\",text)\n",
    "    text = re.sub(alphabets + \"[.]\" + alphabets + \"[.]\" + alphabets + \"[.]\",\"\\\\1\\\\2\\\\3\",text)\n",
    "    text = re.sub(alphabets + \"[.]\" + alphabets + \"[.]\",\"\\\\1\\\\2\",text)\n",
    "    text = re.sub(\" \"+suffixes+\"[.] \"+starters,\" \\\\1 \\\\2\",text)\n",
    "    text = re.sub(\" \"+suffixes+\"[.]\",\" \\\\1\",text)\n",
    "    text = re.sub(\" \" + alphabets + \"[.]\",\" \\\\1\",text)\n",
    "    \n",
    "    if \"”\" in text: \n",
    "        text = text.replace(\".”\",\"”.\")\n",
    "    if \"\\\"\" in text: \n",
    "        text = text.replace(\".\\\"\",\"\\\".\")\n",
    "    if \"!\" in text: \n",
    "        text = text.replace(\"!\\\"\",\"\\\"!\")\n",
    "    if \"?\" in text: \n",
    "        text = text.replace(\"?\\\"\",\"\\\"?\")\n",
    "        \n",
    "    text = text.replace(\".\",\"<stop>\")\n",
    "    text = text.replace(\"?\",\"<stop>\")\n",
    "    text = text.replace(\"!\",\"<stop>\")\n",
    "    \n",
    "    sentences = text.split(\"<stop>\")\n",
    "    sentences = [s.strip() for s in sentences]\n",
    "    \n",
    "    non_empty = []\n",
    "    for s in sentences: \n",
    "        # we require that there be two alphanumeric characters in a row\n",
    "        if len(re.findall(\"[A-Za-z0-9][A-Za-z0-9]\", s)) > 0:\n",
    "            non_empty.append(s)\n",
    "    return non_empty\n",
    "\n",
    "def pad_sentences(sentences):\n",
    "    '''\n",
    "    Takes a list of sentences and returns a string in which:\n",
    "        - The beginning of the abstract is indicated by DOCUMENTSTART\n",
    "        - The end is indicated by DOCUMENTEND\n",
    "        - Sentence boundaries are indicated by SENTENCEBOUNDARY\n",
    "        \n",
    "    The number of delimiters used is dependent on the ngram length\n",
    "    '''\n",
    "    sent_string = (' '+(sent_delimiter+' ')*(ngram_length-1)).join(sentences)\n",
    "    \n",
    "    return (start_delimiter+' ')*(ngram_length-1) + sent_string + (' '+end_delimiter)*(ngram_length-1)\n",
    "    \n",
    "def cleaning_pipeline(title, abstract):\n",
    "    '''\n",
    "    Takes a binary string and returns a list of cleaned sentences, stripped of punctuation and lemmatised\n",
    "    '''\n",
    "\n",
    "    title = normalise_decimals(normalise_acronymns(title.decode()))\n",
    "    abstract = normalise_decimals(normalise_acronymns(abstract.decode()))\n",
    "    sentences = [title] + split_into_sentences(abstract)\n",
    "    \n",
    "    # strip out punctuation and make lowercase\n",
    "    clean_sentences = []\n",
    "    for s in sentences:\n",
    "        \n",
    "        # Deal with special cases\n",
    "        s = re.sub(r'[-/]', ' ', s)\n",
    "        \n",
    "        # Remove all other punctuation\n",
    "        s = re.sub(r'[^\\w\\s]','',s)\n",
    "                   \n",
    "        clean_sentences.append(s.lower())\n",
    "        \n",
    "    # pad sentences with delimiters\n",
    "    text = pad_sentences(clean_sentences)\n",
    "    \n",
    "    # Lemmatise word by word\n",
    "    lemmas = []\n",
    "    for word in tokeniser(text):\n",
    "        lemmas.append(wnl.lemmatize(word))\n",
    "        \n",
    "    return ' '.join(lemmas)\n",
    "\n",
    "\n",
    "def calc_macd(dataset):\n",
    "    long_ma = dataset.ewm(span=long_ma_length).mean()\n",
    "    short_ma = dataset.ewm(span=short_ma_length).mean()\n",
    "    significance_ma = dataset.ewm(span=significance_ma_length).mean()\n",
    "    macd = short_ma - long_ma\n",
    "    signal = macd.ewm(span=signal_line_ma).mean()\n",
    "    hist = macd - signal\n",
    "    return long_ma, short_ma, significance_ma, macd, signal, hist\n",
    "\n",
    "def calc_significance(stacked_vectors, significance_threshold, n):\n",
    "    # Must have been above the significance threshold for two consecutive timesteps\n",
    "    a = stacked_vectors>significance_threshold\n",
    "    b = a.rolling(window=n).sum()\n",
    "    return stacked_vectors[stacked_vectors.axes[1][np.where(b.max()>=n)[0]]]\n",
    "    \n",
    "def calc_burstiness(hist, scaling_factor):\n",
    "    return hist.iloc[long_ma_length-1:]/scaling_factor\n",
    "\n",
    "def calc_scaling(significance_ma, method):\n",
    "    if method == \"max\":\n",
    "        scaling = significance_ma.iloc[significance_ma_length-1:].max()\n",
    "    elif method == \"mean\":\n",
    "        scaling = significance_ma.iloc[significance_ma_length-1:].mean()\n",
    "    elif method == \"sqrt\":\n",
    "        scaling = np.sqrt(significance_ma.iloc[significance_ma_length-1:].max()  )      \n",
    "    return scaling\n",
    "\n",
    "def max_burstiness(burstiness, absolute=False):\n",
    "    if absolute:\n",
    "        b = pd.concat([np.abs(burstiness).max(), burstiness.idxmax()], axis=1)\n",
    "    else:\n",
    "        b = pd.concat([burstiness.max(), burstiness.idxmax()], axis=1)\n",
    "    b.columns = [\"max\", \"location\"]\n",
    "    return b\n",
    "\n",
    "def feature_selection(dataset):\n",
    "    '''\n",
    "    Compile the features for the prediction step\n",
    "    '''\n",
    "    long_ma = dataset.ewm(span=long_ma_length).mean()\n",
    "    short_ma = dataset.ewm(span=short_ma_length).mean()\n",
    "    significance_ma = dataset.ewm(span=significance_ma_length).mean()\n",
    "    macd = short_ma - long_ma\n",
    "    signal = macd.ewm(span=signal_line_ma).mean()\n",
    "    hist = macd - signal\n",
    "    \n",
    "    scaling_factor = calc_scaling(significance_ma, \"sqrt\")\n",
    "    burstiness_over_time = calc_burstiness(hist, scaling_factor)\n",
    "    burstiness = max_burstiness(burstiness_over_time)\n",
    "    \n",
    "    \n",
    "    X = long_ma.iloc[long_ma_length:].T\n",
    "    scaled_hist = hist.iloc[long_ma_length:]/scaling_factor\n",
    "    scaled_signal = signal.iloc[long_ma_length:]/scaling_factor\n",
    "    \n",
    "    Xtra = pd.concat([significance_ma.iloc[-1], \n",
    "                      dataset.iloc[-1],\n",
    "                        significance_ma.iloc[significance_ma_length:].std()/scaling_factor,\n",
    "                        significance_ma.iloc[significance_ma_length:].max(),\n",
    "                        significance_ma.iloc[significance_ma_length:].min(),\n",
    "                      scaling_factor\n",
    "                        ], axis=1)\n",
    "    X = pd.concat([X,scaled_hist.T,scaled_signal.T,Xtra], axis=1)\n",
    "\n",
    "    X.columns = [str(i) for i in range(8)] + [\"hist\"+str(i) for i in range(8)] + [\"signal\"+str(i) for i in range(8)] + [\n",
    "                        \"significance\",\n",
    "                        \"prevalence\",\n",
    "                        \"scaled std\",\n",
    "                        \"max\",\n",
    "                        \"min\",\n",
    "                        \"scaling\"\n",
    "                    ]\n",
    "\n",
    "\n",
    "    return X\n",
    "\n",
    "def balanced_subsample(x,y,subsample_size=1.0):\n",
    "    # from https://stackoverflow.com/a/23479973\n",
    "    class_xs = []\n",
    "    min_elems = None\n",
    "\n",
    "    for yi in np.unique(y):\n",
    "        elems = x[(y == yi)]\n",
    "        class_xs.append((yi, elems))\n",
    "        if min_elems == None or elems.shape[0] < min_elems:\n",
    "            min_elems = elems.shape[0]\n",
    "\n",
    "    use_elems = min_elems\n",
    "    if subsample_size < 1:\n",
    "        use_elems = int(min_elems*subsample_size)\n",
    "\n",
    "    xs = []\n",
    "    ys = []\n",
    "\n",
    "    for ci,this_xs in class_xs:\n",
    "        if len(this_xs) > use_elems:\n",
    "            np.random.shuffle(this_xs)\n",
    "\n",
    "        x_ = this_xs[:use_elems]\n",
    "        y_ = np.empty(use_elems)\n",
    "        y_.fill(ci)\n",
    "\n",
    "        xs.append(x_)\n",
    "        ys.append(y_)\n",
    "\n",
    "    xs = np.concatenate(xs)\n",
    "    ys = np.concatenate(ys)\n",
    "\n",
    "    return xs,ys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Some statistics about the dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "db=_mysql.connect(user=\"root\",passwd=\"\",db=\"dblp\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 2634308 total English-language documents in the dataset.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xbbadf98>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a frequency distribution of English-language documents over time\n",
    "db.query(\"\"\"SELECT year, COUNT(*) as count FROM dblp2018 where `language`='en\\r' GROUP BY year ORDER BY year ASC;\"\"\")\n",
    "r=db.store_result()\n",
    "\n",
    "results = r.fetch_row(maxrows=0)\n",
    "number_of_documents = [int(r[1]) for r in results[:-1]]\n",
    "years = [d[0] for d in results[:-1]]\n",
    "\n",
    "# Plot a figure\n",
    "fig = plt.figure(figsize=(6,3.7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "ax.set_title('Documents per year, DBLP', fontsize=13)\n",
    "ax.grid()\n",
    "ax.set_ylim(0,200000)\n",
    "ax.set_xlim(0,30)\n",
    "ax.set_ylabel('Number of documents',fontsize=12)\n",
    "ax.set_xlabel('Year',fontsize=12)\n",
    "plt.xticks(np.arange(0,31,5), np.arange(1988,2019, 5))\n",
    "ax.bar(years, number_of_documents, color='0.7', label = 'All')\n",
    "\n",
    "print(\"There are\", str(np.sum(number_of_documents)), \"total English-language documents in the dataset.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The average length of titles and abstracts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5,0,'Year')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAFQCAYAAABpt9OPAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xd4VGX2wPHvIRAIIIQSiijFAihSpIgUlV5EikhdEEVYQBHXssrKogIqovLDQgkdETShSVdpggsKriACUkUEQUE6GGrK+f1xb9gxJpCEuZlJOJ/nuc/M3PK+551J5sx931tEVTHGGGO8lC3QARhjjMn6LNkYY4zxnCUbY4wxnrNkY4wxxnOWbIwxxnjOko0xxhjPWbIxJh1EpJ6IxAU6jmAhIsNE5NUrrDNWREZdYZ0PRGRiGuqdISI9Uru+CRxLNibdRGSgiKiIdAt0LCbtX9R+rLck0BN422feXhHp6rueqvZR1Scvt046vAIMFZGwqyzHeMySjUkXEckG9ACOA709rivErS/LCpY2ikiOdGz2ODBfVU/7O54rUdUdwG6gc0bXbdIm4H/cJtNqCtwAdANqi8gdiQtEZLiIzPVdWUTqi8gfIpLHfX2HiCwRkaMi8ouIvJH4RScipd09ph4isg04CxQRkU4isklETovIQREZl1ieu10xEVkoIqdEZJe7vYpIaZ91/i4iP7jrbBSRJpdrpIjcJyKrReS4G+uUJMs7ishPbnkzReQ6n2VDRWSPiMS46zztsyy9bczrvr973Pdzq4jUFZEXgC7AI259MSIS4m7TRkQ2iMhJEdkuIl18yntURHaLyPMicgD4Xhyvi8hvbh17RaTfZd6mNsAynzIXAiWBiW4cS935l/a8Ulonmfe/kIhMEpH9InLEfY+LJlltmRuDCWaqapNNaZ6AecAC9/n3wPs+y24HLgIRPvOmApPc50WAYzh7RKFACWA98LK7vDSgwAqgmLtOCNAcqIDzI+kWYBvwhk8dK4A5QD63jlVuOaXd5b1wfgVXdsu4H4gBbkmhjZWA88CjQE4gDKjvLqvnlj0JyAsUBX4E/u2zfVfgekCABsA5oOlVtnEGsBoo45Z7a2L8wAfAxCRtaOy+1/e4Zd4FnADudZc/CsQB77jtyw00AQ4AN7rrFAWqpvAehbntqJRk/l6ga5J5f4rvSuu47VsNTATyu7FNAlYk2eYh4ECg/ydsusJ3RqADsCnzTe4XaCzQxn39lPsFFuazzjfAM+7z69wv9Tru638CXyQp8yFgt/s88Yv43ivE8STwX/f5De42N/ksb8ifk80PQLckZSwEBqZQ/hhgVgrL6rll+ybUt4G5l4l3NvDWVbSxiLtNhRTWTS7ZLMJN4j7zRvp8oT+KkwRzJmnbUaAZkCsVfwuX3mOf+f5INtVx9vh8Yyvk1neDz7zGwNlA/1/YdPnJutFMeiSO1SxyX0/H+YXb0WedKUB393kH4FdV/cp9XQao43brnBSRk8BknF/4vvb6vhCRxm6X1hEROQ28CUS4i0u4j7/4bLIvSXllgNFJ6q3vs21SpYFdKSwDiFfVIz6vz+Ak1sR4nxKRLSJywq2rpU+86WljaffxcjElVQbon6TNj+IkiUQHVfVC4gtVXQUMAAYCh93uzuoplH/CfcyXhphSqwzOHuXvPrH/hLO3WdJnvXw4f48miFmyMWkiziB2TyAcOCAih3C6ekJwuqkSRQO3ikhVnC8337GOfcByVQ33mfKrat4k1SX41BuK03UXDZRU1XxAf5yuFoBf3UffLyHf54n1Ppak3ryq+ngKzd2L002VZiJSBydR9AYKq2o4zl6UJFk1LW3c6z6mFFNCMvP2AYOStPk6Vb3/ctup6nhVrYvzA2AT8ElyFarqOWAnTtfplWJJTbxJYz8DFEwSf5iqfu2z3h3AxlTUZwLIko1Jq2Y4XVa1gSo+UwuglohUBFDVk8Bc4DXgbuBDnzI+BKqLyGMikktEsonITSLS7DL1hgK5gBOqek5EbsfpYsKt7wDOGM0wEblORIrg/DL39Q4wSESquIPgYe7gevkU6hwHtBKRh0Uk1F2/3pXeIFc+IB44AqiItMAZj7mcK7XxME5X3Bj3AAMRkVtE5BZ3lUPATfLno9reBZ4WkXvEOeItVESqXWZPBRGp4b4vOYELwB844zopmQc0SjLvEFdO1FdaZz3OeOB7IlLIjS1CRDolWa+xG4MJYpZsTFr1Buap6gZVPeQzLQXW8ufDoKfgfMEuUdXfEmeq6iGc7qs2OL/WT+AkpptSqlRVY3AOsX1LRGKA0cDHSVb7G84g8gFgDTDLnX/BLWMC8JYb1wmcLreXgGQP91XVTTgHETwOHHbXfzilGJNYAkwD/osz/tHObWOKUtnGx3C+gL/ESQLz+V/340QgD3DM7XYKcT+XXjjjSUeBgzhJN+lepK/rgPfd9Y/hHDCQ9AveVyTQRkR8u9JeA7q6XYifpbDdZddR1QScv5FswAYR+QNnLLBe4joiUg4nYSV9n0yQEVW7eZrJmkSkKc6XcZjaH7qnRGQYEKuqL2VwvVE4R6dl+MmsJm0s2ZgsQ0Qq4xyptAVncHkGsE1VHwloYMaY4O5GE5Fn3JPWfhCRKLd/v4yIfCMiP4pzXaTQQMdpgkZBnIHsGJxutM3APwIakTEGCOI9GxEpgfOFcbs7WDoT+BSnD/0TVY0WkbHAJlWNDGSsxhhjLi+o92yA7ECYiGTHGfg9iHMm9mx3+VTsMhXGGBP0gjbZqOqvwHCcI4AOAqeADcBJVU08DPMAKZ+QZ4wxJkhkD3QAKRGRAkBrnIHekziHsSZ3nsJf+gFFpBfuCYa5cuWqVrJk0nP7so6EhASyZQva3wxXzdqXuWXl9mXltgHs2rXrqKomveJFugVtssE5SeznxMuBiMgnOCcShotIdnfv5gbgt6Qbqup4YDxAuXLldOfOnRkXdQZbtWoV9erVC3QYnrH2ZW5ZuX1ZuW0AIpL0ck9XJZjT8i/A3SKSW0QE56KK24CVOCfIATyCcx6FMcaYIBa0yUZVv8E5EOA7nPMmsuHsrfQHnhWR3ThXgJ0UsCCNMcakSjB3o6Gqr+Dc9tXXHpx7chhjjMkkgnbPxhhjTNZhycYYY4znLNkYY4zxXFCP2RhjjEm/uLg49u7dy86dO0k8BeTZZ58NSCyWbIwxJpM7fvz4pYSSOO3YsYPdu3cTGxt7ab2KFStasjHGGJM68fHxfP7554wfP56vv/6ao0ePXlqWPXt2brnlFsqVK0fLli0pV67cpalw4cIBi9mSjTHGZBK///47kyZNYvz48ezbt49ixYrRqlUrbrvttksJpUyZMuTIkezNZwPKko0xxgQxVeXLL78kMjKSuXPnEhsbS4MGDRg+fDitW7cOysSSHEs2xhgThE6ePMmHH37I2LFj2b59OwUKFODJJ5+kd+/elCtXLtDhpZklG2OMCRIXL17k22+/ZfLkyURFRXHu3Dlq1qzJlClT6NixI2FhYYEOMd0s2RhjTIAcOnSItWvXsnbtWr7++ms2bNjA+fPnyZMnDw8//DB9+vThzjvvDHSYfmHJxhhjMkBcXBybN2++lFjWrl3Lzz//DEBoaCjVqlXjiSeeoFatWjRu3Jj8+fMHOGL/smRjjDEeOXz4MLNnz2bOnDmsW7eOs2fPAlC8eHFq165N3759qV27NlWrViVnzpwBjtZblmyMMcaPTp06xdy5c4mKimLFihXEx8dz22230aNHD2rXrk2tWrUoWbIkzm26rh2WbIwx5iqdO3eORYsWERUVxaeffsqFCxcoXbo0L7zwAp06daJixYrXXHJJypKNMcakQ1xcHIsXLyYqKor58+cTExND0aJF6d27N507d6ZmzZrXfILxZcnGGGNS6ejRoyxZsoTPPvuMhQsXcvr0acLDw+nYsSOdO3emXr16hISEBDrMoGTJxhhjUhAfH8/69ev57LPP+Oyzz/j2229RVQoXLkzNmjV58sknadq0aZYf3PcHSzbGGOPjyJEjl/ZelixZwrFjxxARatasyaBBg2jevDnVqlXjP//5D/Xq1Qt0uJmGJRtjzDXv9OnTTJ06lWnTprF+/XpUlYiICO6//36aN29OkyZNKFSoUKDDzNSCNtmISDlghs+sm4CXgXDg78ARd/4AVf00g8MzxmQBu3btYtSoUUyZMoWYmBiqVavG4MGDad68OVWrViVbNruZsb8EbbJR1Z1AFQARCQF+BeYC3YF3VHV4AMMzxmRSCQkJLFmyhJEjR/LZZ5+RI0cOOnbsSL9+/bjrrrsCHV6WlWHJRkTqA/Gq+p90bN4Q+ElV99mhhMaY9EjsKhs5ciQ//vgjxYoVY/DgwfTq1YtixYoFOrwsz7N9RBH5UkTquM/7A9FAlIgMSEdxnYAon9dPishmEZksIgX8EK4xJovatWsXTz31FCVKlOCpp56iUKFCfPzxx+zbt4+XX37ZEk0GEVX1pmCRY0ARVY0Xkd1ASyAG+EpVS6ahnFDgN6CCqv4uIkWBo4ACrwLFVfWxJNv0AnoBREREVJs5c6Zf2hSMYmJiyJs3b6DD8Iy1L3MLVPvi4+NZt24d8+fP59tvvyV79uzUr1+fBx98kNtuu80vdWT1z65+/fobVLW63wpUVU8m4ATOntPNOF1gifP/SGM5rYGlKSwrDfxwue3Lli2rWdnKlSsDHYKnrH2ZW0a379ChQ/r6669ryZIlFdDrr79eBw8erAcPHvR7XVn9swPWqx9zgpdjNmuAUUBxnIF9RORmnL2StOiMTxeaiBRX1YPuyweBH64+VGNMZqWqrFmzhjFjxjBnzhxiY2Np1KgR7777Li1btiR79qA9Duqa4uWn8CjwHM4hym+588oD76W2ABHJDTQGevvMfktEquB0o+1NsswYc404ffo006dPJzIykh9++IH8+fPTt29f+vTpkylvm5zVeZJs3EOVRwC9VPVC4nxVXZyWclT1LFAoybyH/RKkMSZT2rZtG6NGjWLatGnExMRQtWpVJk2aRKdOncidO3egwzMp8CTZqHNQQBMgwYvyjTHXnjVr1vDmm2+yaNEicuXKRadOnXj88cepUaOGXV05E/Dy9Nh3gMEiksPDOowxWVhCQgLz58+nTp063HPPPaxbt44hQ4Zw4MABpkyZwl133WWJJpPwcsymH1AMeFZEjuCMsQCgaTj02Rhz7bl48SIfffQRb7/9Ntu3b6d06dKMGjWK7t27W1dZJuVlsunqYdnGmCzojz/+YPz48bzzzjv8+uuvVK5cmY8//pj27dvbUWWZnGefnqp+6VXZxpis5ffff+f9999nzJgxnDx5kvr16zNp0iSaNGli3WRZhGfJRkRy4lyluTNQSFXzuwcNlFXVUV7Va4wJfqrK1q1bWbRoEYsWLWLt2rWoKm3btqV///7UqFEj0CEaP/Nyv/QdoATQBfjMnbfVnW/JxphrzPnz51m5ciWLFy9m0aJF7Nu3D4CqVasycOBAunTpQtmyZQMcpfGKl8nmQeAWVT0jIgkAqvqriJTwsE5jTBA5evQoEyZMYNGiRSxfvpyzZ8+SO3duGjduzL///W/uv/9+SpSwr4RrgZfJ5mLS8kUkAjjmYZ3GmAA7deoUH330EZMnT2bDhg0AlCpViu7du/PAAw9Qr149cuXKFeAoTUbzMtnMAqaKyDPgXNMMeBfnVgPGmCxEVfn2228ZN24c0dHRnD17lipVqtCrVy+eeuopbr/9dhvov8Z5eVLnAJxrl23BuZXzjzi3ChjiYZ3GmAx0+vRpIiMjqVq1KjVr1mTGjBn87W9/49tvv+W7776jc+fOVKhQwRKN8fTQ54vA08DTbvfZUfey1caYTExVWb9+PePHjycqKoozZ85QuXJlxowZQ5cuXciXL1+gQzRByMtDn4+rakEAVT3iM/+wqhbxql5jjDdOnDjBzJkzGTduHBs3biR37tx06tSJ3r172/XJzBV5OWbzl2uiuddJC/GwTmOMH8XExLBw4UKioqL4/PPPiY2NpVKlSowePZouXbqQP3/+QIdoMgm/JxsRWY1zHbRcIvKfJItvAL72d53GGP+5cOECn332GdHR0SxcuJCzZ89SokQJ+vXrR+fOnalWrZrtxZg082LPZiIgQA1gks98BX4HvvCgTmPMVYiLi+OLL74gKiqKuXPncurUKQoXLswjjzxCp06dqFu3LtmyeXk8kcnq/J5sVHUqgIisU9Ud/i7fGOM/P/74I++++y6zZs3iyJEj5MuXjwcffJDOnTvToEEDcuSwO4QY//ByzOYJEYlW1UvdZiJSG+igqk97WK8x5gpOnDjBq6++yqhRowgJCaFly5Z07tyZ5s2b2wmXxhNeJpvOwD+TzNsAzMM5JNoYk8FiY2MZN24cgwYN4vjx4/To0YNXX32VYsWKBTo0k8V52QmryZQf4nGdxphkqCqffvoplSpVol+/flSuXJmNGzcyYcIESzQmQ3j5xb8aeE1EsgG4j4Pc+VckIuVE5Huf6bSIPC0iBUVkmYj86D4W8K4JxmR+W7dupVmzZrRo0YL4+Hjmz5/P8uXLqVy5cqBDM9cQL5PNP4BGwEER+S/OpWoa49wu+opUdaeqVlHVKkA14CwwF/gXsEJVbwVWuK+NMUkcOXKExx9/nEqVKvHf//6Xd955hx9++IFWrVrZocsmw3l5uZoDIlIVqIlzfs1+4L+qmpCO4hoCP6nqPhFpDdRz508FVgH9rz5iY7KGc+fOMXr0aF599VXOnDlD3759eeWVVyhUqFCgQzPXME9v6u0mlrV+KKoTEOU+L6qqB93yD4qIXfrGXPMOHz7M4sWLWbhwIUuXLuXMmTO0aNGC4cOHU758+UCHZwzi1bUxRSQfzhjNfUBhnBM9AVDVkmkoJxSnC66Cqv4uIidVNdxn+QlVLZBkm15AL4CIiIhqM2fOvJqmBLWYmBjy5s0b6DA8Y+1Lnqqyb98+1q5dy1dffcW2bdtQVSIiIqhVqxb169enSpUqHkScNln588vKbQOoX7/+BlWt7rcCVdWTCZiO08XVGvjDfVwDPJPGcloDS31e7wSKu8+LAzsvt33ZsmU1K1u5cmWgQ/CUte9/Ll68qCtXrtRnnnlGb775ZsU54lOrVaumgwcP1u+++04TEhK8CzYdsvLnl5XbpqoKrFc/5gQvu9GaALep6jERiVfV+SKyHlgIvJOGcjrzvy40gAXAI8Aw93G+vwI2JhidOHGCV155hWnTpnHy5Ely5sxJw4YNef7553nggQfstsomU/Ay2WQDTrnPY0QkHDgI3JLaAkQkN84RbL19Zg8DZopID+AXoL1/wjUmuCQkJDB16lReeOEFjh8/zt/+9jfatm1L48aNs3T3jcmavEw2m3DGa1bgnFszGogBdqW2AFU9CxRKMu8YztFpxmRZmzZt4oknnuDrr7+mdu3ajBkzxs6LMZmal+fZ/B3nttAATwHncG4P3c3DOo3J1E6dOsXTTz9N1apV2bVrF5MnT2b16tWWaEym58mejYiEAI8Cr8OlO3X29KIuY7ICVeXjjz/mn//8J7///ju9e/fm9ddfp2DBgoEOzRi/8GTPRlXjgb5ArBflG5OVbNu2jQYNGtC1a1duuOEGvvnmGyIjIy3RmCzFy260qUAfD8s3JlOLiYlh7NixVK5cmU2bNjF27FjWrVtHjRo1Ah2aMX7n5QECdwH9ROQFnEvVXDp7VFXv9bBeY4La0aNHGTt2LKNGjeL333/nscceY9iwYURERAQ6NGM842WymeBOxhhg586dvPPOO0ydOpXz58/TvHlzWrRoQd++fQMdmjGe8/JCnFO9KtuYzEJVWbVqFSNGjGDRokXkzJmThx9+mKeffpoKFSqwatWqQIdoTIbw9EKcIlIUpzst6bXRJntZrzGBdvHiRWbOnMmIESPYuHEjERERDBo0iMcff5wiRezaseba41myEZE2ONdH+xGoAGwF7sC5PpolG5MlHT9+nAkTJvD+++/z22+/cdtttzFhwgS6dOlCWFhYoMMzJmC83LN5DeiuqrPcKzPfKSLdcRKPMUHvzJkz7N69mz179nDs2DFOnjz5p+nEiRN/mXf27FkAGjduzKRJk2jSpAnZstmd0I3xMtmUVNVZSeZNBQ4B//SwXmNSLTY2lr1797Jr166/TAcOHPjL+tmyZSM8PJwCBQoQHh5OeHg4xYsXv/S8YMGCPPDAA1SqVCkArTEmeHmZbA6LSFFV/R3YKyK1gKNAiId1GnNZ8fHxzJ49m48++oidO3eyZ88e4uLiLi0vUKAA5cqVo0GDBtx6662ULVuWW265hYiICMLDw8mbN6/dUtmYdPD60Oe6wBycWwqsBBKA//OwTmOSdfHiRaZPn86wYcP48ccfKVOmDNWqVaNdu3aULVv20mS3TjbGG14e+vymz/MPRWQVkEdVt3tVpzFJnT17lkmTJvH222+zf/9+7rzzTmbPns2DDz5oYynGZCBPD31OJCLZgAOJz1U1ISPqNdeuU6dOERkZyYgRIzhy5Ah169Zl/PjxNG3a1LrBjAkALw99ropzD5tKQK7E2TiXrbFxG+OJo0eP8t577zFy5EhOnTpFs2bNGDBgAPfcc0+gQzPmmublns1UnFtAPwac9bAec41TVbZu3crkyZMZN24c586do23btrz44otUq1Yt0OEZY/A22ZQC/q2qesU1jUmjQ4cOsXz5cpYtW8ayZcs4ePAgISEhdOnShf79+3P77bcHOkRjjA8vk81coAmwxMM6zDXi3LlzrF69mmXLlrF06VI2b94MQKFChWjUqBGNGzemWbNmlChRIsCRGmOS49dkIyLT+N+tBHICc0VkDc6JnJeoqt0a2lzR9u3biYqK4vXXX2f16tVcuHCB0NBQ6tatyxtvvEGTJk2oUqWKHVVmTCbg7z2b3Uleb0tvQSISDkzEuZ6a4oz9NAX+DhxxVxugqp+mtw4TfA4ePEh0dDTTp0/nu+++A+COO+6gb9++NG7cmHvvvZfcuXMHOEpjTFr5Ndmo6mARqQO0UtX+SZeLyJs43Wup8R7wuaq2E5FQIDdOsnlHVYf7LWgTcDExMcybN49p06axfPlyEhISqF69Ou+++y4lSpSgXbt2gQ7RGHOVvBizGQCMSWHZSuDfQMvLFSAi+YB7gUcBVPUicNHOj8g64uLiWL58OdOnT2fu3LmcPXuW0qVLM2DAALp06UL58uUB7H4vxmQRXiSbKsDnKSxbTupuL3ATTlfZFBGpDGwA/uEue1JEugHrgedU9cRVxmv8JC4ujgsXLnD+/HnOnz+f7PMzZ86wfPlyoqKiOHz4MAUKFKBbt2507dqV2rVr2wmXxmRR4u8jk0XkD6CIqp5LZlkYcFhVr7tCGdWBdUAdVf1GRN4DTgOjcC7mqcCrQHFVfSyZ7XsBvQAiIiKqzZw58ypbFbxiYmLImzdvhtapquzfv5/vvvuO77//ns2bN3Pq1CkSElJ3YYgcOXJQu3ZtGjVqxF133UVoaGiK6waifRnJ2pd5ZeW2AdSvX3+Dqlb3V3le7NnswDnkeX4yy5q4y6/kAHBAVb9xX88G/uVeQRoAEZkALEpuY1UdD4wHKFeunNarVy/VwWc2q1atwuv2qSo///wzK1eu5IsvvmDlypUcPHgQgBtvvJGWLVty4403kjNnTnLlynVpSul1uXLlCA8PT1XdGdG+QLL2ZV5ZuW1e8CLZvAOME5EQYJ6qJrjXRmuDc/maZ69UgKoeEpH9IlJOVXcCDYFtIlJcVQ+6qz0I/OBB/Ab49ddfLyWWL774gn379gFQtGhRGjRoQIMGDahfvz433XSTdX0ZY67I78lGVT8WkWI4l6vJKSJHgcLAeeAVVY1KZVH9gI/cI9H2AN2B90WkCk432l6gt7/jv5YdPHiQWbNmER0dzdq1awEoWLAg9evX5/nnn6dBgwaUL1/ekosxJs08uYKAqo4QkYlALaAQcAxYq6qn01DG90DS/sKH/RelATh27Bhz5swhOjqaVatWoapUrlyZoUOH0rx5cypVqmQnTRpjrpqX97M5jV2qJiidPn2aefPmER0dzbJly4iLi6Ns2bK8/PLLdOzYkdtuuy3QIRpjspgMuZ+NCbyzZ8+yePFioqOjWbx4MRcuXKBUqVI899xzdOrUicqVK1v3mDHGM5ZssrDY2FiWLVtGVFQU8+bNIyYmhmLFitG7d286derE3XffbQnGGJMhLNlkMQkJCaxZs4aoqChmzZrFsWPHCA8Pp1OnTnTu3Jn77ruPkBC7d50xJmNZsskCVJXvv/+ejz/+mOjoaA4cOEBYWBitW7emc+fONG3alJw5cwY6TGPMNcySTRCJj49n7dq17N79v4tn+3ZzJff8iy++oE+fPuzcuZPs2bPTtGlT3nzzTVq1apWlz242xmQulmwCLCYmhqVLl7JgwQIWL17M0aNH07S9iHDvvffy7LPP8tBDD1GoUCGPIjXGmPSzZBMABw4cYOHChSxcuJAVK1Zw8eJFChQowP3330+rVq2oXr062bJlw/e6dSk937JlC23atMnQ+I0xJq0s2WSAxDGVBQsWsGDBgks3Bbv55pt58sknadWqFXXq1CF79rR/HPv37/d3uMYY43eWbDwUHx9PdHQ0r776Kjt37kREqFWrFsOGDaNVq1Z26RdjzDXDko0H4uPjmTFjBkOGDGHnzp1UrFiRiRMn0rJlS4oUKRLo8IwxJsNZsvGj+Ph4Zs6cyZAhQ9ixYwd33HEHs2bNom3btnZ9MWPMNc2+Af0gsbusYsWK/O1vfyMkJISZM2eyadMm2rVrZ4nGGHPNs2/Bq5CQkMDMmTOpVKkSnTt3RkSYMWMGmzdvpn379pZkjDHGZd+G6RAbG8uMGTOoVKkSHTt2RFWJjo5m8+bNdOjQwZKMMcYkkeXHbM6fP4+q+uWor/379zN+/HgmTpzIoUOHKF++PFFRUbRv396uN2aMMZeR5ZPNL7/8wg033EDLli1p2bIlDRo0ICwsLNXbJyQksHTpUiIjI1m0aBGqSvPmzXn88cdp3ry5JRljjEmFLJ9sihUrRq1atfjoo48YN24cuXPnpnHjxrRs2ZIWLVpQrFixZLc7cuQIkyfhvCJsAAAgAElEQVRPZty4cfz8888UKVKE/v3706tXL0qXLp2xjTDGmEwuyyebfPnyMXv2bC5cuMCqVasuXSZm/vz5ANSsWfPSXk/FihVZs2YNY8eOZfbs2Vy8eJH77ruPN954gwcffJDQ0NAAt8YYYzKnLJ9sEuXMmZOmTZvStGlTRo4cyebNmy8lnoEDBzJw4EDy58/PqVOnyJcvH71796ZPnz7cfvvtgQ7dGGMyvaBONiISDkwE7gAUeAzYCcwASgN7gQ6qeiKN5VK5cmUqV67MwIEDOXjwIIsXL2b16tXce++9dOrUiTx58vi1LcYYcy0L6mQDvAd8rqrtRCQUyA0MAFao6jAR+RfwL6D/1VRSvHhxevbsSc+ePa8+YmOMMX8RtCeEiEg+4F5gEoCqXlTVk0BrYKq72lTArq9vjDFBLmiTDXATcASYIiIbRWSiiOQBiqrqQQD30a5saYwxQS6Yu9GyA1WBfqr6jYi8h9NldkUi0gvo5b68ICI/eBRjMCgMpO32npmLtS9zy8rty8ptAyjnz8LE966PwUREigHrVLW0+/oenGRzC1BPVQ+KSHFglaqm+KaIyHpVrZ4RMQeCtS9zs/ZlXlm5beD/9gVtN5qqHgL2i0hiImkIbAMWAI+48x4B5gcgPGOMMWkQzN1oAP2Aj9wj0fYA3XES5EwR6QH8ArQPYHzGGGNSIaiTjap+DyS3G9cwDcWM91M4wcral7lZ+zKvrNw28HP7gnbMxhhjTNYRtGM2xhhjsg5LNsYYYzxnycYYY4znLNkYY4zxnCUbY4wxnrNkY4wxxnOWbIwxxnjOko0xxhjPWbIxxhjjOUs2xhhjPGfJxhhjjOcs2RhjjPGcJRtjjDGes2RjjDHGc5ZsjDHGeM6SjTHGGM9ZsjHGGOM5SzbGGGM8Z8nGXNNEpJ6IxAU6jmAhIsNE5NVUrltaRFREbvA6Ln8SkQgR2ScihQMdy7XEko1BRAa6XxrdAh2LARH5QEQmBqDekkBP4O0Mqk9FpK7HdTwqIrt956nqEeBj4BUv6zZ/ZsnmGici2YAewHGgt8d1hbj1ZVnB0kYRyZGOzR4H5qvqaX/Hk17pbEdqTAa6i0g+j8o3SQT8n8IEXFPgBqAbUFtE7khcICLDRWSu78oiUl9E/hCRPO7rO0RkiYgcFZFfROSNxC8In26WHiKyDTgLFBGRTiKySUROi8hBERmXWJ67XTERWSgip0Rkl7u9ikhpn3X+LiI/uOtsFJEml2ukiNwnIqtF5Lgb65QkyzuKyE9ueTNF5DqfZUNFZI+IxLjrPO2zLL1tzOu+v3vc93OriNQVkReALsAjbn0xIhLibtNGRDaIyEkR2S4iXXzKe1REdovI8yJyAPheHK+LyG9uHXtFpN9l3qY2wLIk70uKbffRzP2cTorIfBEp4rP9UyLys1v/ryIy1J2/yV1lqVv2RHf+XhF5WURWisgZ4CERqSwiX7qf2wkR+UxEbvapQ0Skl4hscd/v/SLSV0RqAWOBm3zey3oAqvojcBRodJn3w/iTqtp0DU/APGCB+/x74H2fZbcDF4EIn3lTgUnu8yLAMZw9olCgBLAeeNldXhpQYAVQzF0nBGgOVMD5sXMLsA14w6eOFcAcIJ9bxyq3nNLu8l7AbqCyW8b9QAxwSwptrAScBx4FcgJhQH13WT237ElAXqAo8CPwb5/tuwLXAwI0AM4BTa+yjTOA1UAZt9xbE+MHPgAmJmlDY/e9vsct8y7gBHCvu/xRIA54x21fbqAJcAC40V2nKFA1hfcozG1HpSTzU9P2/7htzwfMBZa6y8viJN8K7utw4G6fshWom6S+vcB+4E63zjD386vvfnb5gVnAWp9tHgd+A+q6701h4C6f92V3Cm1eCLwW6P/Ba2UKeAA2BfDDd75EYoE27uun3C+wMJ91vgGecZ9fh/OlXsd9/U/giyRlPpT4z+3zZXTvFeJ4Eviv+/wGd5ubfJY35M/J5gegW5IyFgIDUyh/DDArhWX13LJ9E+rbwNzLxDsbeOsq2ljE3aZCCut+wF+TzSLcJO4zb2Tieu6X6jkgZ5K2HQWaAblS8bdw6T1OY9sb+iy/xZ13PXCTG1MHIG8yZaWUbF6+Qgx3uNvmcV9vA/qmsO6jpJxsPgLGePX/ZdOfJ+tGu7YljtUscl9Px/kl2dFnnSlAd/d5B+BXVf3KfV0GqON2n5wUkZM4feHFktSz1/eFiDR2u7SOiMhp4E0gwl1cwn38xWeTfUnKKwOMTlJvfZ9tkyoN7EphGUC8OoPGic7gJNbEeJ9yu2hOuHW19Ik3PW0s7T5eLqakygD9k7T5UZwv9UQHVfVC4gtVXQUMAAYCh8Xp7qyeQvkn3Mc/jWGko+2Jz29Q1T04XYJ/B34TkTVX6u5MpjxE5GYR+cTthjsNJP79JR5NVpq0vZeJ8uH8/ZsMYMnmGiXOIHZPnK6NAyJyCOcXYghON1WiaOBWEamK8+XmO9axD1iuquE+U35VzZukugSfekNxuu6igZKqmg/oj9NlAvCr+1jSZ3vf54n1Ppak3ryq+ngKzd2L002VZiJSBydR9AYKq2o4zl6UJFk1LW3c6z6mFFNCMvP2AYOStPk6Vb3/ctup6nhVrYvzA2AT8ElyFarqOWAnTtdpYjtS2/bSyTw/4Jb7iao2xkkMM4H5IpI7sdrkYkmmHWOBP3C6+PIBdRJDdB/3krb3MtEdwMbLLDd+ZMnm2tUMp8uqNlDFZ2oB1BKRigCqehKnH/414G7gQ58yPgSqi8hjIpJLRLKJyE0i0uwy9YYCuYATqnpORG7H6WLCre8AzhjNMBG5zh1sHpikjHeAQSJSxR0cDnMH18unUOc4oJWIPCwioe769a70BrnyAfHAEUBFpAXOeMzlXKmNh3G6o8aIc4CBiMgtInKLu8ohnEFt3//Pd4GnReQecY54CxWRapfZU0FEarjvS07gAs4X9uXOKZrHnwfMU9v2l0SkqDhHdr0JrFDV30SknIg0c5NLLHAKJ8EkJoBDpO5HQD6cvc2T4pwbMyTJ8tHAABGp5f4NFhaRGj51FJEkR52573UEsDwV9Rt/CHQ/nk2BmYD5wJwUln0NjPJ53RjnS2JRMuveDizA+ac+hfPr+Ql3WWl3uxuSbNML55dvDLASeBnY67O8OE7X3imc7pHH3XKK+6zzCM6v0pM4X4ZLgIqXaW8Dt12J6yce5FAPiEuy7iCcPTZwfpBF4nQzHcfZs5sOfHCVbbwOJ4Hsc9fZijt+gTPW8Y1b50kgxJ3fAljnzj+GMzBfz132KEnGJtw2f4eTZE7iHJBw12Xeo1I4Yzz50tj2nu7ndApnz6eYu7wisNadfwrYADT3qa87zsEAJ4Bx7ry9QNckcdUGtuAknO3AY/x5DE+Avjh75n/gdMEm/g1mxznY5Jj7Htznzh+Kz9+4Td5P4r7xxgQtEWmKkxzD1P5gPSUiw4BYVX0p0LF4xd072gBU1z+P1RkPWbIxQUdEKuP8ct2CMzA+A9imqo8ENDBjTLplyJiNiEwWkcMi8oPPvLdFZIeIbBaRuSIS7rPsRXFOUNvp/qpNnN/MnbdbRP6VEbGbgCiIM5AdA6wBNgP/CGhExpirkiF7NiJyL84Xx4eqeoc7rwnOORpxIvImgKr2dwdTo3BOWrseZwCvrFvULpzxgwPAt0BnVd3meQOMMcZclQzZs1HV/5DkeHZVXaqqiUfGrMM5MgqgNRCtqhdU9WecM8XvcqfdqrpHVS/iHFbaOiPiN8YYc3WC5dDnx4DP3OclcI5QSXTAnZfSfGOMMUEue6ADEJF/4xz7/1HirGRWU5JPjMn2AYpIL9wTE3PlylWtZMmk5wRmHQkJCWTLFiy/GfzP2pe5ZeX2ZeW2Aezateuoqia9WkS6BTTZiMgjwAM411ZKTBwHgBt9VrsB5yJ7XGb+n6jqeGA8QLly5XTnzp3+DDuorFq1inr16gU6DM9Y+zK3rNy+rNw2ABFJepmoqxKwtOyeZd4faKWqZ30WLQA6iUhOESmDc4bxf3EOCLhVRMq4lwPp5K5rjDEmyGXIno2IROGcqV1YnHttvAK8iHPJ8GUiArBOVfuo6lYRmYlzNnAcztVc491ynsQ5UzwEmKyqWzMifmOMMVcnQ5KNqnZOZvaky6z/OvB6MvM/BT71Y2jGGGMyQNYd3TLGGBM0LNkYY4zxnCUbY4wxnrNkY4wxxnOWbIwxxnjOko0xxhjPWbIxxhjjOUs2xhhjPGfJxhhjjOcs2RhjjPGcJRtjjDGes2RjjDHGc5ZsjDHGeM6SjTHGGM9ZskkHVWXatGn89NNPgQ7FGGMyBUs26TB58mS6detGq1atuHDhQqDDMcaYoGfJJo02b97Mk08+yW233ca2bdsYMmRIoEMyxpigZ8kmDf744w/at29PgQIFWLVqFd27d+fNN99kw4YNgQ7NGGOCmiWbVFJVevfuze7du4mKiqJIkSKMGDGCokWL8uijj3Lx4sVAh2iMMUHLkk0qjR8/nqioKIYMGcJ9990HQHh4OOPHj+eHH37gtddeC3CExhgTvCzZpML333/PP/7xD5o2bcqLL774p2UtWrSgW7duDB06lI0bNwYoQmOMCW6WbK7g9OnTtG/fnsKFCzNt2jSyZfvrW/buu+9SpEgRunfvbt1pxhiTjHQnGxGpLyL3+jOYYKOq/P3vf+fnn38mOjqaiIiIZNcrUKAAY8eOZdOmTbzxxhsZHKUxxgS/VCcbEflSROq4z/sD0UCUiAzwKrhAi4yMZObMmbz22mvUrVv3suu2atWKLl268Nprr7Fp06YMitAYYzKHtOzZ3AGsc5//HagH3A308XNMQWHDhg0888wz3H///bzwwgup2ua9996jUKFCdO/endjYWI8jNMaYzCMtySYboCJyMyCqul1V9wMFvAktcE6dOkWHDh0oUqQIU6dOTXacJjmFChVi7NixbNy4kTfffNPjKI0xJvNIS7JZA4wChgNzAdzEc9SDuAJGVenRowe//PILM2bMoHDhwmnavk2bNnTq1IkhQ4awZcsWj6I0xpi0uXDhAvv27QtY/WlJNo8CJ4HNwCvuvPLAe36OKaBGjRrFnDlzeOONN6hdu3a6yhg5ciTh4eF0796duLg4P0eYPps3b6ZVq1Y8//zzzJw5k59//hlVDXRYxpgM8NNPP1GnTh2aNm0asCNms6dmJREJAUYAvVT10pUnVXWxV4EFwrfffstzzz1Hy5Ytee6559JdTuHChYmMjKRdu3a8/fbbfzk3J6OdOnWKtm3bcujQIZYsWXLpj61QoUJUr16d6tWrU6NGDapXr06JEiUCGqsxxr9mzZpFz549yZYtG1OmTCE0NDQgcaQq2ahqvIg0ARI8jidgEsdpihcvzgcffICIXFV5Dz30EO3bt2fQoEG0atWKChUq+CnStFFVunfvzr59+1i1ahU1atRgy5YtrF+/nm+//Zb169czbNgw4uPjAShevDjVq1enZs2a9O7dO83diMaY4HD+/HmeffZZIiMjqVmzJtHR0ZQuXTpwAalqqibgBWAokCO12/hsOxk4DPzgM689sBUngVVPsv6LwG5gJ9DUZ34zd95u4F+pqbts2bKaGo888oiGhITo119/nar1U+P333/XwoUL61133aWxsbF/Wnbx4kU9fPiw7tixQ9euXauLFy/W6dOn68iRI3XlypWpruNK6/7f//2fAvp///d/Ka5z5swZ/frrr/W9997Trl27avny5VVEtEiRIjpv3rxUx+KFtLwXmZG1L/MK5rbt3LlTK1eurID+85//1IsXL6a5DGC9pvG7/nJTWhLGfiAWOO8+/yVxSsW29wJVkySb24BywCrfZAPcDmwCcgJlgJ+AEHf6CbgJCHXXuf1Kdacm2cybN08BHThwYJo/kCuZMWOGAnrnnXdqlSpVtGTJknrdddcpkOIkIjpt2rRUlX+5P/ivvvpKs2fPrg8++KAmJCSkKe5NmzZplSpVFNBu3brpiRMn0rS9vwTzP7Q/WPsyr2Bt2/Tp0zVPnjxaqFAhXbRoUbrL8XeySVU3mqtrGtb9E1X9j4iUTjJvO5Bcd1VrIFqdsaGfRWQ3cJe7bLeq7nG3i3bX3ZbeuACOHDlCr169uPPOO3nppZeupqhktW/fns2bN/Pll19SsGBBKleuTIECBShYsOCfHhOf58mTh27duvHII48QEhJC586d01XvkSNH6NChA6VKlWLy5Mlp7hasVKkS33zzDa+99hpDhw5lxYoVTJo0iaZNm6YrHmOMt86ePUu/fv2YPHkydevWJSoqihtuuCHQYV2S6mSjql96GYiPEvzv5FGAA+48cPaofOfXvJqKVJU+ffpw8uRJVqxY4cnAmYik+YrQCxYsoEWLFnTt2pWQkBA6dOiQpu3j4+Pp0qULR48eZd26dYSHh6dp+0ShoaEMGTKEVq1a0a1bN5o1a0avXr0YPnw41113XbrKNMb439atW+nQoQPbt29nwIABDB48mOzZ07Iv4b1URyMiOYGXgc5AIVXN7x40UFZVR/kxpuR+givJH6ad7LG7ItIL6AUQERHBqlWrkq1o2bJlfPLJJ/Tq1YujR4+muF4g9O/fn+PHj9O5c2e2b99+6bYGScXExPwl7qlTp7Js2TKee+45Tp486Zd2vfvuu0yePJkJEyawYMEC+vfvT5UqVa663CtJrn1ZibUv8wqGtqkqn3/+Oe+99x65c+fmzTffpEaNGqxZsyagcSUrtf1twBhgPlALOOnOKwFsTeX2pfEZs/GZv4o/j9m8CLzo83qJW2ctYElK66U0pTRm88svv2j+/Pm1Tp06GhcXl6a+zIxy+vRprVWrlmbPnj3Fgfqk/cZLlixREdFu3bqleZwmNdasWaO33HKLAvrUU0/pmTNn/F6Hr2DtF/cXa1/mFei2nT17Vrt166aA1q9fX3/77Te/lk8ADxA4CORxnx/3mX8yldunNtlU4M8HCOzBOTggu/u8DP87QKDClepNLtkkJCRo48aNNU+ePLp79+6r+Tw8d+rUKa1Zs6bmyJFDFyxY8Jflvn/w+/fv18KFC2uFChU0JibGs5hiYmK0X79+Cuitt96qX331lWd1Bfof2mvWvswrkG3bv3+/VqtWTQF95ZVXPPnB7O9kk5ZOvYsk6XYTkQjg2JU2FJEonAt3FhaRAzhXIDgOjAQigMUi8r2qNlXVrSIyE2fgPw7oq6rxbjlP4uzphACTVXVrGuK/JDIykmXLlhEZGcnNN9+cniIyTL58+fj8889p3Lgx7dq1Y+7cudx///1/WS82NpaOHTty/vx5Zs+eTZ48eTyLKU+ePLz//vu0adOGxx57jHvuuYeSJUsSFhZG7ty5k518l+XLl4/w8HAKFChw6THxeZ48ea76HCdjsrKvvvqKhx56iDNnzjBv3jxat24d6JBSJS3JZhYwVUSeARCR4sC7OLcauCxVTemQqrkprP868Hoy8z8FPk1twMnZvXs3zz//PE2bNqV3795XU1SGCQ8PZ+nSpTRq1Ii2bdsyf/78vxwV9q9//Yuvv/6aqKgoypcvnyFxNWjQgM2bNzN8+HD27dvH2bNnL00nTpzgt99++9O8c+fOXfFSGdmzZ/9TIipVqhQ1atTwNHkak1lMnDiRJ554glKlSrFixYqAnSyeHmlJNgOAt4AtQG7gR2ACMMSDuDwRHx9Pt27dCA0NZdKkSZnqF3SBAgVYtmwZDRs2pE2bNixcuJBGjRoBMHfuXEaMGEHfvn3p1KlThsaVL18+hgxJ/Z9AXFwcp0+f5uTJk5w4ceKyj0eOHGHOnDls2bKFjz/+mKpVq3rYEmOCV2xsLM888wyjR4+mSZMmREdHU6BAJrvgfnr63nC6vsSf/XleTb5jNm+88YYCOn369DT0XAaXI0eOaMWKFTUsLEy/+OILnT59uubLl09r1Kih58+fD3R4fjdixAgtUaKE5siRQ9966y2Nj48PdEh+lZXHNFSzdvsyqm2HDx/WevXqXboaQNKrkXiFAB4gcDyF+Yf9GZC/p8Rks2nTJs2RI4e2a9fOk6O0MtLhw4e1QoUKmjt3br3xxhu1QIECunfv3kCH5YmVK1fq0aNHtW3btgpow4YN9ddff013eefPn9cpU6Zo3759PT+SLjWy8pexatZuX0a0bePGjVqqVCnNmTNnqq8q4i/+TjZpucVAjqQzRCQHzmB9ULt48SLdunWjYMGCREZGZqrus+RERESwYsUKSpYsyf79+5k2bRqlSpUKdFieKVSoELNnz2bChAmsXbuWSpUqMX/+/DSVcfjwYYYMGUKpUqXo3r07o0ePZvDgwR5FbMzVmzVrFnXq1CEuLo41a9bQtWu6L+ISHK6UjYDVwH9wrov2nyTTHmChP7Ofv6eyZcvqgAEDFEj20OHM7NixYzpq1KhAh+GppL8ed+zYoVWrVlVA+/Tpc8W9ky1btmiPHj00Z86cCuj999+vS5cu1R49emhISIh+9913HkZ/ZVn5l79q1m6fV22Lj4/Xf//73wpo7dq19eDBg57UcyVkdDca8AjOjdPOuc8Tp25AU9JxFeiMnEqWLKnZsmXT7t27X+17H5Sy8j+zavLtu3Dhgj7//PMK6G233aYbN2780/L4+HhdvHixNmrUSAENCwvTPn366Pbt2y+tc/z4cS1WrJhWrVo1w/rAk3Mtfn5Zhb/bdu7cOf3kk0+0YcOGCmjPnj0DOg6b4cnm0opQ3p8VZ9SUI0cOLVmypJ46dSq973lQy8r/zKqXb9+yZcu0ePHiGhoaqiNGjNCYmBiNjIzU8uXLK6DXX3+9Dh06VI8ePZrs9rNnz1ZA3377bY+iv7Jr+fPL7PzRtgsXLuiiRYv04YcfvnQ1+IiICB0zZkzAx5YDmWzeB2onmVcbeNefAfl7AvSLL764irc8uGXlf2bVK7fvyJEj2rp1awU0NDRUAa1WrZpOnz5dL1y4cNltExIStHXr1hoWFqY//fSTH6NOvWv98wsm06dP12rVquknn3ySqi/69LYtNjZWly1bpj169NACBQoooOHh4dqjRw9dunRpQPe0fQUy2RwBQpPMy0mQH41WunTpq3i7g19m+mdOj9S0LyEhQSdOnKg9e/bU1atXp+kX4YEDBzRfvnzaqFGjgPyStM8vOGzevFlz5cp1aWyvYcOG+sMPP1x2m7S0LT4+Xr/88kt94okntEiRIgpo3rx5tWvXrrpo0aIr/jAKBH8nm7QcjZbclZdDkpkXVAJ1v22TcUSEHj16MGHCBOrWrZumow1LlCjBsGHDWL58OR9++KGHUZpgFRMTQ4cOHcifPz8//fQTI0eO5LvvvqNy5co89dRTnDhxIt1l//LLL7z88suUKlWK++67jylTpnDfffcxZ84cDh8+zLRp02jRosU18T2VlkSxGnhNRLIBuI+D3PnGZFq9e/emTp06PPvssxw+fDjQ4ZgM1rdvX3bu3MlHH31EiRIlePLJJ9m1axe9evVi9OjR3HrrrURGRhIfH5+q8uLi4li4cCEPPPAAZcqU4bXXXqNixYp8/PHHHD58mJkzZ9K2bVvCwsI8bllwSUuy+QfQCDgoIv8FfgMaA/28CMyYjJItWzYmTJhATEwMTz/9dKDDMRnogw8+4MMPP+Sll16iYcOGl+YXLlyYMWPG8N1333HHHXfwxBNPULVqVb78MuV7SB44cIBBgwZRpkwZWrVqxYYNG3jxxRfZs2cPn376KZ07dyZv3rwZ0azglJY+N5zkVAtoD9wNZPNnn54XU0r3s8kqMkufeHplZPsGDx6swFXdtz2t7PMLnK1bt2ru3Lm1Xr16l71Ef0JCgs6aNUtLliypgLZv31737t2rK1eu1Li4OF20aJG2bNlSs2XLpiKiTZs21Tlz5ujFixczsDX+R6AOEMiskyWbzC0j23fhwgWtUKGC3njjjXr69OkMqdM+v8CIiYnR22+/XYsUKZLqm46dPXtWBw8erGFhYZorVy5t1qyZ3njjjQpo0aJF9cUXX9Q9e/Z4HHnG8XeySXU3mojkE5ERIrJBRPaJyC+Jk993t4wJgNDQUCZMmMCBAwcYOHBgoMMxHurXrx/bt29n+vTpFC9ePFXbhIWF8fLLL7Njxw7atGnDkiVLKF++PLNmzWL//v0MHTqUMmXKeBx55pWWMZsxQFWcWwoUxBmr+QV4x4O4jAmIWrVq0bdvX0aOHMm6desCHY7xwLRp05gyZQoDBgygcePGad6+ZMmSREVFsWzZMpYuXUq7du3IkeMvl440SaQl2TQBHlLV+UC8+9gReNiTyIwJkKFDh1KiRAl69ux5xZu9mcxlx44dPP7449xzzz0MGjToqsoKCQn6axAHlbQkm2zAKfd5jIiEAweBW/welTEBdN111xEZGcnWrVt56623Ah2O8ZNz587RoUMHwsLCiIqKInv2tNw70lyttCSbTcB97vPVwGggEtjl76CMCbQHHniAjh078uqrr7Jjx45UbRMbG8vx48edI29M0PnHP/7Bli1bmDZtGiVKlAh0ONectKT2vwOJp2Y/BbwBhONc/dmYLOe9995j6dKl9OzZk+eff56jR49edjp58iQAdevWZfjw4dSsWTPALTCJoqKimDBhAv/6179o1qxZoMO5JqUq2YhICM5tBl4HUNUjQE/vwjIm8IoWLcqIESPo3r07X3311aX5uXLlIiIigsKFC1O4cGHKlClz6bmIMHr0aO6++246dOjA0KFDufnmmwPYCpN4NYA6derw6quvBjqca1aqko2qxotIX5zL0xhzzXj00UepWrUqcXFxlxJK7ty5L7vN008/zfDhwxk+fDhz587liSee4KWXXqJQoUIZFLVJdP78eTp06EBoaKiN0wRYWsZspgJ9vArEmGBVqVIlqlatSsmSJa+YaMA5wGDw4MH8+OOPPPLII4wcOZKbb76Zt956i/Pnz2dAxObkyZOMH/gqQIQAABJKSURBVD+eunXrsmnTJj788ENuvPHGQId1TUtLsrkLeE9E9orIahH5T+LkVXDGZGbXX389EyZMYPPmzdSpU4f+/ftTrlw5pk+fTkJCQqDDy3L+v717j66qvhI4/t0kkIg8BAkhCAFqUJNUG4I6goIsHGGKCFRlrQHlzSAIDK0WBunMRNohI7ULHJAZfGISalhYW4WxxqEE6qqigzqAECSgloQKIgHLQyU89vxxfsFLSCA33JNzc9mftc665/7OuSd75z72Peee8/udOnWKoqIiRowYQYcOHXjwwQf55ptvWLZsGXfddVfQ4V3ywtmnfNZNxpgwZGZm8vrrr1NcXMzMmTMZNWoUCxcu5IknnqBJk6geoaNRKCkpIS8vj4KCAvbu3Uvbtm2ZOHEiY8eOpWfPnmENOWH8U+dio6p5fgZiTKzr378/GzdupLCwkDlz5nDHHXcwcuRI+vXrF3RojU5FRQUrVqwgLy+PjRs3EhcXx6BBgxgzZgyDBw8mISEh6BBNNWH9WiYiyXiH09rx3WnQqOoLEY7LmJjUpEkT7r//fu69916mTJnCiy++yPjx48/q3t7UrqKiglmzZlFQUMCJEye44YYbWLBgASNHjiQ5OTno8Mx51LnYiMgwYDmwE8gEtgHfB/4EWLExJgyJiYksWbKE4uJixo4dy5YtW2jTpk3QYUUtVWXFihXMmDGDQ4cOMXnyZCZMmEBWVlbQoZk6CueA8b8B41S1B3DM3U4CPvAlMmNiXPPmzZkzZw779u1j6tSpQYcTtcrKyhg8eDAjR46kW7dufPjhhyxevNgKTSMTTrFJVdWXq7XlUYceBETkBRHZLyJbQ9raisgaEdnpbtu4dhGRRSKyS0S2iEh2yGPGuPV3isiYMGI3Jipde+215OTkUFhYSGFhYdDhRJXTp0/z1FNPkZmZyfr163nyySd55513uP7664MOzdRDOMVmv/vNBuDPItILuBqoS9enLwLV+4iYDaxV1e7AWncf4IdAdzdNwut/DRFpC+QAf4P3u1FOVYEypjGbPXs2vXr14qGHHqK8vDzocKJCSUkJt912G9OnT+fWW29l27ZtzJgxw3pabsTCKTbPAre5+YXAOrzOOf/zQg9U1beAg9Wah+LtGeFuh4W057vB4t4FrhCRFGAgsEZVD6rqIWAN5xYwYxqd+Ph48vPzOXHiBOPGjbukr8GprKxk7ty5ZGVlUVpaSkFBAW+88QZdu3YNOjRzkepcbFR1vqq+4ubzgWuAnqr6L/X828mqutdtby/Q3rVfBYR+vdvj2mprN6bRS0tLY+HChaxdu5ZFixYFHU4gNmzYQHZ2No899hjDhw+npKSEBx54wK6TiRH16ihIRJrgfdgjIk1UNZJfxWp6Zel52s/dgMgkvENwJCUlsX79+ogFF22OHj1q+TViofmlpaXRu3dvZs2aRevWrWNiiOG6PH8HDhxg+fLlrFq1iqSkJHJzc+nVqxclJSWUlJQ0TKD1EOuvzYhT1TpNeENCbwCOAafcdBpv1M66PL4rsDXk/g4gxc2nADvc/NPAiOrrASOAp0Paz1qvtumaa67RWLZu3bqgQ/DVpZbfvn37NCkpSbOysvT48ePBBBVB53v+ysvLddq0aZqQkKBxcXE6bdo0PXz4cMMFd5Fi/bUJvK91rA91mcLtiHMdcCPwPTd1c7f1sQqoOqNsDPBaSPtod1baLcBf1TvM9iYwQETauBMDBrg2Y2JGcnIyzz33HJs2bSInJyfocHyxe/dupkyZwtVXX83SpUsZNWoUpaWlLF68mJYtWwYdnvFJOIfRugA/cxUvLCJSCPQD2onIHryzyh4HVorIBKAMGO5W/z0wCNgFfA2MA1DVgyLyC2CjW+/nqlr9pANjGr0hQ4YwceJE5s+fz6BBg+jTp0/QIUXEp59+Sm5uLnl5eYgIEyZMYPbs2XTp0iXo0EwDCKfY/I567k2o6ohaFp3TR4crZjVe4aZetzjWW4GJeQsXLqS4uJjRo0ezefNmWrVqFXRI9VZaWkpubi7Lly8nPj6eyZMnM2vWLOvy/xJz3mIjIgV89yN8AvA7EfkTsC90PVW1oaGNiaAWLVpQUFBAnz59mDFjBsuWLQs6pLBt376defPmUVxcTLNmzZg+fTozZ86kY8eOQYdmAnChPZtd1e5H76khxsSY3r178+ijjzJv3jzuvvtu7rnnnqBDuqBDhw6xcuVKCgoKePvtt0lMTOThhx/mkUceoUOHDkGHZwJ03mKjqnNF5FZgiKr+U/XlIjIf7/CaMcYHOTk5FBUVMWnSJHr16kVKSkrQIZ2jsrKSoqIi8vPzWb16NZWVlaSnp5Obm0t6ejrDhg278EZMzKvLbzZzqL2XgHXAz4C7IxaRMeaMpk2bUlBQQHZ2Nj169CA7O5vMzEwyMjLIzMwkPT09kDO4VJWNGzdSUFBAYWEhFRUVJCUlMXnyZEaPHk12djYiYtehmDPqUmyygKJalv0B+8HeGF+lp6fz6quvkpeXR0lJCcXFxRw/fvzM8tTU1LMKUEZGBtdddx2tW7eOaByqyu7du3nppZfIz89nx44dJCQkMHToUEaPHs2AAQNo2rRpRP+miR11KTatgGbANzUsawrYifHG+GzgwIEMHDgQgJMnT/LZZ5+xbds2SkpKztxWL0KtWrWiS5cupKamkpqaes58SkrKWR1bfvvtt5SXl1NeXk5ZWdk5t2VlZRw7dgyAvn37MnPmTO67776IFzUTm+pSbD7GO+X5tRqWDXDLjTENJD4+nu7du9O9e/ezfg85derUmSJUWlpKeXk5u3fvpqysjA0bNnDw4NmXpcXFxdGpUyfatGnD559/zv79+8/5W8nJyXTu3Jn09HQGDhxIt27dGDJkiHWMacJWl2KzEHhaROKAV1X1tOsbbRiwBHjYzwCNMXUTFxdHWloaaWlpNS4/cuTImb2UqiJUVlbGoUOHuOmmm87s9XTu3JnU1FSuuuoqEhMTGzgLE6suWGxU9SUR6YDXXU2CiBwA2gHfAjmqaiM+GdMItGzZkoyMDDIyMoIOxVyC6tSDgKouEJHngF7AlUAFsEFVD/sZnDHGmNhQ5+5qXGGxji+NMcaELZxen40xxph6sWJjjDHGd1ZsjDHG+M6KjTHGGN9ZsTHGGOM7KzbGGGN8Z8XGGGOM76zYGGOM8Z0VG2OMMb6zYmOMMcZ3VmyMMcb4zoqNMcYY31mxMcYY4zsrNsYYY3xnxcYYY4zvrNgYY4zxnRUbY4wxvrNiY4wxxndWbIwxxvgu8GIjIjNEZKuIbBORH7u2tiKyRkR2uts2rl1EZJGI7BKRLSKSHWz0xhhj6iLQYiMi3wf+AbgZ+AEwWES6A7OBtaraHVjr7gP8EOjupknAfzV40MYYY8IW9J5NOvCuqn6tqieBPwI/AoYCeW6dPGCYmx8K5KvnXeAKEUlp6KCNMcaEJ+hisxXoKyJXikhzYBDQGUhW1b0A7ra9W/8qoDzk8XtcmzHGmCgWH+QfV9XtIjIfWAMcBTYDJ8/zEKlpM+esJDIJ7zAbwHER2XqxsUaxdsCBoIPwkeXXuMVyfrGcG8C1kdxYoMUGQFWfB54HEJFcvL2VL0QkRVX3usNk+93qe/D2fKp0Aj6vYZvPAM+4bb6vqjf6mEKgLL/GzfJrvGI5N/Dyi+T2gj6Mhoi0d7epwD1AIbAKGONWGQO85uZXAaPdWWm3AH+tOtxmjDEmegW+ZwO8IiJXAieAqap6SEQeB1aKyASgDBju1v093u86u4CvgXFBBGyMMSY8gRcbVe1TQ1sFcEcN7QpMDfNPPFPP0BoLy69xs/war1jODSKcn3if38YYY4x/Av/NxhhjTOxrlMVGRF4Qkf2hpzSLyA9EZIOIfCQiq0WklWtvKiJ5rn27iDwa8pifuG5ytopIoYgkBpFPdWHm10xElrn2zSLSL+QxRa5tm4gsFZG4ANI5SwRzG+Hat7g82wWQzjlEpLOIrHOvtW0iMsO1h9UFk4h0EZEPRGST287kIPOqEqn83LJfum1sd+vUdGlDg6pHfte51+5xEflpyHYSReR/Q95/c4PKKSSmiOTmloX/2amqjW4C+gLZwNaQto3A7W5+PPALNz8SWOHmmwN/BrriXQz6GXCZW7YSGBt0bvXIbyqwzM23Bz4Amrj7rdytAK8Afx8LueH91rgfaOeW/RJ4LOjcXCwpQLabbwmUAhkuxtmufTYw380PAt5wz9EtwHuuvRmQ4OZbuNdtxxjKrzfwNhDnpg1Av0aYX3vgJmAe8NOQ7QjQws03Bd4DbomR3Or12dko92xU9S3gYLXma4G33Pwa4N6q1YHLRSQeuAyoBA67ZfHAZW5Zc2q4ZicIYeaXgdd/HKq6H/gKuNHdD82zGTVcANvQIpSbuOly9224FdHz3O1V1Q/d/BFgO96bM6wumFS1UlWPu3USiJKjEJHKD++1mIgrqngfyF80WCK1CDc/Vd2vqhvxzqYN3Y6q6lF3t6mbAn3/RSo3J+zPzqh4AUfIVmCImx/Odxd//gY4BuzFO436V6p6UFX/AvzKte3Fu2bnfxo25LDUlt9mYKiIxItIN6BnyDJE5E28vYAjeP+LaBRWbqp6ApgCfIT3Is/AXRgcTUSkK9AD71tt2F0wucMeW9zy+aoaFQW1ysXkp6obgHV47729wJuqur1hIq+bOuZ3vsfHicgmvPffGlV9z79ow3MxudX3szOWis14YKqIfIC3i1jp2m8GTgEdgW7AIyLyPXdccqhr64j3LfmBhg+7zmrL7wW8N/D7wJPAO4R0+aOqA/F2nxOA/g0ZcBjCyk1EmuIVmx54z90W4NHqGw2SiLTAO3T545A9zBpXraFNAVS1XFVvANKAMSKSHPlI6+di8xORNLyOeDvhFaT+ItI38pHWTxj51UpVT6lqFl6ON4vXy33gLja3+n52xkyxUdWPVXWAqvbE64XgE7doJFCkqifcoZi38Q7F/C3wmap+6b4p/xbvOHJUqi0/VT2pqj9R1SxVHQpcAeys9thv8XpfGNrQcddFPXLLcss/Ue+g8Uqi6LlzxfAV4Neq+lvX/IU7fISE2QWT26PZBpxzTVoQIpTfj/B6fD/qDje9gfebTuDCzO+CVPUrYD3wdxEONWwRyq1en50xU2zku25vmgD/DCx1i8rwvjWJiFyO94L+2LXfIiLN3XH/O/COYUal2vJz8V/u5u8ETqpqiYi0CHkBxeP9UPtxIMFfQLi5AX8BMkQkyW3iTqLkuXOvpeeB7aq6IGRRWF0wiUgnEbnMbbMNcCuwo0GSOI9I5Yf3/rvdHSJtCtxOFDyH9civtu0kicgVbv4yvA/oQN9/kcqN+n52XugMgmic8L797sX74WoPMAGYgXd2RSnwON9dsNoCeBnvm2EJMDNkO3PxXgBbgQLc2T9BT2Hm1xXvQ2g78Aegi2tPxjvLa4vLfTEQHwu5uWWTXfsWYDVwZdC5ubhuwzsMtgXY5KZBwJV4JzvsdLdt3foCLMHbm/sIuNG13+m2sdndTgo6twjnFwc87Z7DEmBB0LnVM78O7nV8GO8Elj14J6zcAPyf285W4F9jJTe3LOzPTutBwBhjjO9i5jCaMcaY6GXFxhhjjO+s2BhjjPGdFRtjjDG+s2JjjDHGd1ZsjDHG+M6KjTERICK/FpEXqrXdLiIVVRfXGnMps2JjTGT8IzDI9XSAG9/jWeARdZ0cRoJEwZhExtSHFRtjIkBVK4DpwDOui50c4BNVfVFEmojIHBH5REQOiMiKkAGqmojIb0Rkn4h8JSLrRSS9arsislxElog3QNwxoqR/NGPCZcXGmAhR1ZfxBngrBCYBD7pFDwN34Q0c1wlvyItFIQ/9b6A7XvcgVd1/hBqJ1z1IS7xBxoxpdKy7GmMiyA0D8AnwM1X9D9e2E5ioqn909zsDu/BGOjxd7fHtgC/xRnk8JiLLgUpVHd+QeRgTafFBB2BMLFHVL0TkAF7np1VSgdUiElpYFGgvIl8C/w7cB7QDqtZph7cHBGcPPmZMo2SH0Yzx3x7gTlW9ImRKVNV9wGi8nnf7A63xBkqDswcds8MPptGzYmOM/5YCuSKSCt74PSJSNQx2S+A4UIE3lvu8YEI0xl9WbIzx3wKgCFgrIkfwhre+yS1bhjdyZdVonO8EEqExPrMTBIwxxvjO9myMMcb4zoqNMcYY31mxMcYY4zsrNsYYY3xnxcYYY4zvrNgYY4zxnRUbY4wxvrNiY4wxxndWbIwxxvju/wH4UFrK/CzCEwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0xbbada20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "db.query(\"\"\"SELECT year, AVG(CHAR_LENGTH(title)), AVG(CHAR_LENGTH(abstract)) as count FROM dblp2018 where `language`='en\\r' GROUP BY year ORDER BY year ASC;\"\"\")\n",
    "r=db.store_result()\n",
    "\n",
    "results = r.fetch_row(maxrows=0)\n",
    "\n",
    "x = np.arange(0,len(results)-1)\n",
    "titles = [float(d[1]) for d in results[:-1]]\n",
    "abstracts = [float(d[2]) for d in results[:-1]]\n",
    "\n",
    "fig, ax = plt.subplots(2, figsize=(6,5), sharex=True)\n",
    "plt.subplots_adjust(hspace=0.35)\n",
    "ax[0].set_title('Average characters (title)', fontsize=13)\n",
    "ax[0].plot(x, titles, color='k', ls='-', label='titles')\n",
    "ax[0].grid()\n",
    "ax[0].set_ylim(60,80)\n",
    "ax[0].set_xlim(0,30)\n",
    "ax[0].set_ylabel('Characters', fontsize=12)\n",
    "\n",
    "plt.xticks(np.arange(0,31,5), np.arange(1988,2019, 5))\n",
    "ax[1].set_title('Average characters (abstract)', fontsize=13)\n",
    "ax[1].plot(x, abstracts, color='k', ls='-', label='abstracts')\n",
    "ax[1].grid()\n",
    "ax[1].set_ylim(900,1200)\n",
    "ax[1].set_ylabel('Characters', fontsize=12)\n",
    "ax[1].set_xlabel('Year', fontsize=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vectorisation\n",
    "\n",
    "Prior to this section, we took the MySQL data and cleaned it in another notebook (not included here because of the time taken to run). The procedure can be seen in cleaning_pipeline() above, but essentially it involved:\n",
    "- Normalising decimals so that 3.7 -> 3POINT7\n",
    "- Normalising acronyms so that e.g. I.O.P -> IOP\n",
    "- Splitting the abstract into individual sentences\n",
    "- Tokenising each sentence individually.\n",
    "- Lemmatising each token\n",
    "- Adding sentence delimeters around every sentence, and between the title and abstract. This is to ensure we do not take bi- and tri-grams across sentence boundaries."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Stopword list\n",
    "\n",
    "- We use the normal set of nltk stopwords, the numbers 0-9 and 00-99, the years 1900-2018, and a limited set of words that we found not to be information-bearing in this context."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "stop = set(stopwords.words('english'))\n",
    "stop = set([s.replace(\"'\", \"\") for s in stop])\n",
    "\n",
    "# Add years to prevent spikes\n",
    "for year in range(1900, 2020):\n",
    "    stop.add(str(year))\n",
    "\n",
    "# Add small numbers\n",
    "for num in range(0, 100):\n",
    "    if len(str(num)) < 2:\n",
    "        stop.add(str(num))\n",
    "        num = '0' + str(num)\n",
    "        \n",
    "    stop.add(str(num))\n",
    "    \n",
    "# Add these extra stopwords to the list\n",
    "extra = [\n",
    "    'use', 'using', 'uses', 'used', 'based', 'including', 'include', 'approach',\n",
    "    'wa', 'ha', 'doe'\n",
    "        ]\n",
    "for word in extra:\n",
    "    stop.add(word)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build a vocabulary\n",
    "\n",
    "We have to build a vocabulary before we vectorise the data. This is because we want to set limits on the size of the vocabulary. \n",
    "- Terms must occur at least 5 times in at least one year. This removes one-off spelling errors or excessively rare terms, which, given the intended application, are not interesting to us. \n",
    "- We take uni, bi and tri-grams.\n",
    "- We use sentence delimeters to avoid taking bi and tri-grams across sentence boundaries.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1988 25692 7.088000059127808\n",
      "1989 36158 8.603999853134155\n",
      "1990 46820 10.743000030517578\n",
      "1991 56281 11.759999990463257\n",
      "1992 68189 14.794000148773193\n",
      "1993 81635 17.29900026321411\n",
      "1994 100108 21.322999954223633\n",
      "1995 117463 23.680999994277954\n",
      "1996 138159 27.778000116348267\n",
      "1997 161417 31.77900004386902\n",
      "1998 188912 37.187000036239624\n",
      "1999 216216 40.180999994277954\n",
      "2000 252081 48.967000246047974\n",
      "2001 282932 49.81699991226196\n",
      "2002 323207 58.06400012969971\n",
      "2003 376940 71.08799982070923\n",
      "2004 469382 96.4670000076294\n",
      "2005 565754 111.91100025177002\n",
      "2006 668303 130.1399998664856\n",
      "2007 768343 140.99608254432678\n",
      "2008 865812 154.2474229335785\n",
      "2009 967271 169.29692792892456\n",
      "2010 1068816 182.70226860046387\n",
      "2011 1178349 201.63316130638123\n",
      "2012 1297239 213.95323753356934\n",
      "2013 1402657 224.0695059299469\n",
      "2014 1505240 232.78116989135742\n",
      "2015 1598581 236.857754945755\n",
      "2016 1693630 245.8268904685974\n",
      "2017 1779048 239.97552156448364\n",
      "1517518\n"
     ]
    }
   ],
   "source": [
    "vocab = set()\n",
    "for year in range(1988, 2018):\n",
    "    df = pd.read_csv('../Data/clean_dblp/'+str(year)+'.csv')\n",
    "    \n",
    "    # The same as above, applied year by year instead.\n",
    "    t0 = time.time()\n",
    "\n",
    "    vectorizer = CountVectorizer(strip_accents='ascii', \n",
    "                                 ngram_range=(1,ngram_length),\n",
    "                                 stop_words=stop,\n",
    "                                 min_df=min_yearly_df)\n",
    "\n",
    "\n",
    "    vector = vectorizer.fit_transform(df.text)\n",
    "    \n",
    "    # Save the new words\n",
    "    vocab = vocab.union(vectorizer.vocabulary_.keys())\n",
    "    \n",
    "    print(year, len(vocab), time.time()-t0)\n",
    "\n",
    "    \n",
    "vocabulary = {}\n",
    "i = 0\n",
    "for v in vocab:\n",
    "    # Remove delimiters\n",
    "    if start_delimiter in v:\n",
    "        pass\n",
    "    elif end_delimiter in v:\n",
    "        pass\n",
    "    elif sent_delimiter in v:\n",
    "        pass\n",
    "    else:\n",
    "        vocabulary[v] = i\n",
    "        i += 1\n",
    "        \n",
    "print(len(vocabulary.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Go year by year and vectorise based on our vocabulary\n",
    "\n",
    "We read in the cleaned data and vectorise it according to our vocabulary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1988 6.552000045776367\n",
      "1989 3.755999803543091\n",
      "1990 4.317000150680542\n",
      "1991 4.894000053405762\n",
      "1992 5.67799973487854\n",
      "1993 6.521999835968018\n",
      "1994 8.523000001907349\n",
      "1995 8.95199990272522\n",
      "1996 11.531000137329102\n",
      "1997 13.475000143051147\n",
      "1998 14.690999984741211\n",
      "1999 15.930999994277954\n",
      "2000 19.12000012397766\n",
      "2001 19.521000146865845\n",
      "2002 22.30299997329712\n",
      "2003 29.24575710296631\n",
      "2004 39.14782786369324\n",
      "2005 46.920382261276245\n",
      "2006 52.79055619239807\n",
      "2007 57.3664710521698\n",
      "2008 58.569711685180664\n",
      "2009 63.28699445724487\n",
      "2010 67.35873508453369\n",
      "2011 74.34443378448486\n",
      "2012 83.90738987922668\n",
      "2013 81.94519376754761\n",
      "2014 85.83658289909363\n",
      "2015 86.40463948249817\n",
      "2016 88.78687787055969\n",
      "2017 86.73267245292664\n"
     ]
    }
   ],
   "source": [
    "vectors = []\n",
    "for year in range(1988, 2018):\n",
    "    df = pd.read_csv('../Data/clean_dblp/'+str(year)+'.csv')\n",
    "    \n",
    "    # The same as above, applied year by year instead.\n",
    "    t0 = time.time()\n",
    "\n",
    "\n",
    "    vectorizer = CountVectorizer(strip_accents='ascii', \n",
    "                                 ngram_range=(1,ngram_length),\n",
    "                                 stop_words=stop,\n",
    "                                 vocabulary=vocabulary)\n",
    "\n",
    "\n",
    "    vectors.append(vectorizer.fit_transform(df.text))\n",
    "    \n",
    "    print(year, time.time()-t0)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Summing the vectors\n",
    "\n",
    "We sum the vectors along columns, so that we have the popularity of each term in each year.\n",
    "\n",
    "- All >1 elements are set to 1. This is because it does not matter for our application if a word is used multiple times in an abstract.\n",
    "- We divide by the number of documents in each year to normalise the score. Therefore, the 1988 column is divided by ~6000, etc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1517518, 30)\n"
     ]
    }
   ],
   "source": [
    "summed_vectors = []\n",
    "\n",
    "for y in range(len(vectors)):\n",
    "    vector = vectors[y]\n",
    "\n",
    "    # Set all elements that are greater than one to one -- we do not care if a word is used multiple times in \n",
    "    # the same document\n",
    "    vector[vector>1] = 1\n",
    "\n",
    "    # Sum the vector along columns\n",
    "    summed = np.squeeze(np.asarray(np.sum(vector, axis=0)))\n",
    "\n",
    "    # Normalise by dividing by the number of documents in that year\n",
    "    normalised = summed/vector.shape[0]\n",
    "    \n",
    "    # Save the summed vector\n",
    "    summed_vectors.append(normalised)\n",
    "    \n",
    "# Stack vectors vertically, so that we have the full history of popularity/time for each term\n",
    "stacked_vectors = np.stack(summed_vectors, axis=1)\n",
    "\n",
    "print(stacked_vectors.shape)\n",
    "\n",
    "stacked_vectors=pd.DataFrame(stacked_vectors.transpose(), columns=list(vocabulary.keys())) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "stacked_vectors = pickle.load(open('../Data/methods_paper/stacked_vectors.p', \"rb\"))\n",
    "burstvectors = pickle.load(open('../Data/methods_paper_2/burstvectors_500.p', \"rb\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalise the vectors again\n",
    "\n",
    "The number of tokens per abstract has changed over time. We now normalise again, so each year sums to 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalisation = stacked_vectors.sum(axis=1)\n",
    "stacked_vectors = stacked_vectors.divide(normalisation, axis='index')*100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply a significance threshold\n",
    "We require that each term has been above a given significance threshold for 3 years. This shortens the vocabulary and removes single year spikes due to anomalous events."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(30, 70159)\n"
     ]
    }
   ],
   "source": [
    "stacked_vectors = calc_significance(stacked_vectors, significance_threshold, years_above_significance)\n",
    "print(stacked_vectors.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate burstiness"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_ma, short_ma, significance_ma, macd, signal, hist = calc_macd(stacked_vectors)\n",
    "scaling_factor = calc_scaling(significance_ma, \"sqrt\")\n",
    "burstiness_over_time = calc_burstiness(hist, scaling_factor)\n",
    "burstiness = max_burstiness(burstiness_over_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set a threshold such that the top 500 bursty terms are included"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(burstiness[\"max\"]>0.002451))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['service oriented architecture', '0point18 spl', 'expression data', 'content', 'fifth', 'feature map', 'acm subject', 'soa', 'may purchased', 'show proposed', 'crowdsourcing', 'periodical', 'result show', 'http www', '5g', 'eciency', 'version document may', 'elsevier', 'big', 'massive', 'reserved', 'article history received', 'software defined', 'available http github', 'owl', 'router', 'task', 'wireless mesh network', 'learning', 'relay', 'spl time', 'print electronic form', 'mu cmos', 'cognitive radio network', 'camid4v1 title', '978', 'button product webpage', 'journal economic', 'product librarian', 'selection peer', 'elsevier inc right', 'rfid', 'classification number', 'science bv right', 'avc', 'technology', 'wsn', 'differentiated service', 'simulation result', 'mmwave', 'state art method', 'summary form given', 'deep learning model', 'webpage www', 'efficient', 'smart city', 'web service', 'journal infosci', 'elsevier ltd', 'neural', 'antenna', 'copyright john wiley', 'igi', 'received revised', 'iot', 'revised form', 'energy', 'doi org 10point1016', '802point11', 'xml document', 'camid4v1 title available', 'embedding', 'lte', 'mobile ad hoc', 'spark', 'machine', 'document may purchased', 'webpage', 'economic literature classification', 'cmos', 'bv peer', 'site', 'xml data', 'interscience www', 'particle swarm', 'mu', 'non orthogonal', 'particle swarm optimization', 'convolutional network', 'service', 'recurrent neural network', 'network rnn', 'infosci', 'wearable device', '5g network', 'elsevier science usa', 'gene expression', 'xml', 'short term', 'state', 'virtual reality', 'multiple access noma', 'button product', 'millimeter', 'published online wiley', 'learned', 'convolutional layer', 'dnn', 'throughput', 'dx', 'qos', 'bluetooth', 'originality value', 'fading', 'semantic web', 'inc right reserved', 'ad hoc network', 'trained', 'wireless network', 'peer peer', 'portal', 'elsevier science bv', 'big data', 'id2', 'term memory lstm', 'recommend product librarian', 'permission igi global', 'org 10point1016', 'elsevier ltd right', 'wave mmwave', 'mobile', 'cloud service', 'network trained', 'word embeddings', 'cnn', 'published elsevier ltd', 'learns', 'summary', 'journal discipline', 'sub sub', 'non orthogonal multiple', 'multicore', 'h264', 'http', 'cognitive', 'global com article', 'data mining', 'bv right', 'journal economic literature', 'business', 'intranet', 'smartphones', 'wearable', 'drone', 'print', 'efficiency', 'science usa', 'iot device', 'autoencoder', 'electronic commerce', 'ltd right reserved', 'elsevier science', 'bv peer review', 'available full', 'overlay', 'cart button product', 'cross layer', 'spl mu cmos', 'neural network', '0point18', 'traffic', 'sub', 'purchased', 'analytics', 'imes', 'convolutional neural', '17point00 ieee', 'science inc right', 'full version document', 'copyright igi', 'online wiley', 'long short', 'key word', 'sup', 'fading channel', 'gan', 'fifth generation', 'novel', 'doi 10point1002', 'train', 'sensor node', 'generative', 'recommend product', 'recurrent neural', 'sub spl', 'received revised form', 'version document', 'mimo', 'memory lstm', 'massive multiple input', 'software defined networking', 'international journal', 'cdma', 'selection peer review', 'uwb', 'iot application', 'art method', 'copying distributing', 'science', 'network cnns', 'social', 'semantic segmentation', 'infosci journal', 'device', 'add cart', 'add cart button', 'access noma', 'deep feature', 'bear notice full', 'recurrent', 'literature classification number', 'overlay network', 'infosci journal discipline', '10point1002', 'distributing print electronic', 'health care', 'generation 5g', 'uml', 'learning model', 'notice full citation', 'hoc', 'learn', 'wireless sensor', 'p2p', 'ieee', 'grid computing', 'written permission', 'product webpage', 'doi org', 'term memory', 'service oriented', 'network architecture', 'wireless', 'node', 'streaming', 'right reserved', 'differentiated', 'ltd right', 'significant', 'global com resource', 'android', 'keywords', 'economic literature', 'ip', 'smart grid', 'libraryrecommendation', 'com', 'representation learning', 'protein', 'journal infosci journal', 'paper propose', 'app', 'corba', 'page available', 'aware', 'nfv', 'mobile ad', 'copy bear', 'distributing', 'network function', 'neural network architecture', 'security', 'kinect', 'peer network', 'microarray', 'notice full', 'camid4v1', 'http dx', 'wiley interscience www', 'page available full', 'convolution', 'sensor', 'diffserv', 'copyright john', 'market', 'document may', 'internet thing iot', 'virtual', 'multi core', 'grid', 'periodical inc', 'science bv', 'convolutional', 'swarm', 'knowledge management', 'gpu', 'copying distributing print', 'ad', '10point4018 978', 'written permission igi', 'elsevier bv peer', 'facebook', 'orthogonal multiple', 'network cnn', 'github com', 'com resource libraryrecommendation', '17point00', 'published elsevier bv', 'simulation', 'massive mimo', 'available online', 'form without', 'remote sensing', 'form given', 'cloud', 'warehouse', 'turbo', 'swarm optimization', 'word embedding', 'java', 'doi', 'network', 'deep', 'bv', 'electronic form', 'spl', 'ecient', 'cognitive radio', 'vr', 'mum', 'adversarial', 'peer peer network', 'manet', 'cnn model', 'deep learning method', 'attack', 'sensor network', 'web 2point0', '10point1016', 'pre trained', 'published elsevier science', 'baseline', 'without written', 'machine learning', 'igi global', 'proposed', 'deep learning', 'mesh network', 'propose', 'learning method', 'embeddings', 'global prohibited', 'wireless sensor network', 'ltd', 'igi global com', 'http github com', 'short term memory', 'smartphone', 'propose deep', 'without written permission', 'title available infosci', 'availability implementation', 'www', 'soc', 'neural network cnns', 'full version', 'space time', 'oriented architecture', 'igi global prohibited', 'article history', 'peer review responsibility', 'published elsevier', 'wiley periodical inc', 'product webpage www', 'ontology', 'data analytics', 'elsevier inc', 'dataset', 'web site', 'primary user', 'purchased add cart', 'http github', 'history received', 'social network', 'noma', 'autonomic', 'prohibited', 'long short term', 'acm subject classification', 'full citation', 'reinforcement', '3g', 'poster', 'channel', 'print electronic', 'product librarian www', 'wireless mesh', 'packet', '0point18 mum', 'deep convolutional', 'librarian', 'twitter', 'training', 'neural network cnn', 'com article', 'copying', 'available infosci journal', 'session', 'gene', 'wiley periodical', 'sdn', 'work present', 'tablet', 'available full version', 'permission', 'title available', 'defined networking', 'deep network', 'cart', 'semantic', 'button', 'right', 'end end', 'distributing print', 'data warehouse', 'web', 'infosci journal infosci', 'originality', 'datasets', 'reinforcement learning', 'purchased add', 'internet thing', 'commerce', 'com resource', 'mobile agent', 'millimeter wave', 'thing', 'metadata', 'state art', 'deep neural network', 'rnn', 'may purchased add', 'sparse', 'elsevier bv right', 'cloud computing', 'smart phone', 'hoc network', 'journal', '2point0', 'social medium', 'smart', 'wimax', 'global com', 'different', 'summary form', 'review responsibility', 'deep neural', 'ad hoc', 'mum cmos', 'doi 10point4018 978', 'github', 'deep convolutional neural', 'literature classification', 'gene expression data', 'form without written', 'mining', 'millimeter wave mmwave', 'internet', 'neural network rnn', 'massive multiple', 'thing iot', 'available infosci', 'cnns', 'fifth generation 5g', 'convolutional neural network', 'fog', 'doi 10point4018', '10point4018', 'elsevier bv', 'ar iv', 'librarian www', 'permission igi', 'apps', 'electronic form without', 'cart button', 'spl mu', 'small cell', 'wlan', 'online', 'orthogonal multiple access', 'bv right reserved', 'science ltd right', 'art', 'resource libraryrecommendation', 'copyright igi global', 'loss function', 'lstm', 'online wiley interscience', 'peer', 'inc right']\n"
     ]
    }
   ],
   "source": [
    "bursts = list(burstiness[\"max\"].index[np.where(burstiness[\"max\"]>burstiness_threshold_detection)[0]])\n",
    "print(bursts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cluster bursts based on co-occurence\n",
    "\n",
    "We cluster our 500 bursts based on their co-occurence in abstracts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1988 2.632999897003174\n",
      "1989 2.5250000953674316\n",
      "1990 3.003000259399414\n",
      "1991 3.1740002632141113\n",
      "1992 3.803999900817871\n",
      "1993 4.730000019073486\n",
      "1994 5.771000146865845\n",
      "1995 6.111999988555908\n",
      "1996 7.129999876022339\n",
      "1997 8.062000274658203\n",
      "1998 9.735000133514404\n",
      "1999 10.58299994468689\n",
      "2000 12.434000015258789\n",
      "2001 12.904000043869019\n",
      "2002 15.089000225067139\n",
      "2003 18.10099983215332\n",
      "2004 24.506999969482422\n",
      "2005 28.425999879837036\n",
      "2006 32.45631647109985\n",
      "2007 35.766576051712036\n",
      "2008 38.98089790344238\n",
      "2009 42.290228605270386\n",
      "2010 45.26152586936951\n",
      "2011 49.26992678642273\n",
      "2012 54.476447105407715\n",
      "2013 55.44154381752014\n",
      "2014 57.87278652191162\n",
      "2015 58.20781993865967\n",
      "2016 59.57795715332031\n",
      "2017 58.15581488609314\n"
     ]
    }
   ],
   "source": [
    "# vectorise again, using these terms only\n",
    "vectors = []\n",
    "for year in range(1988, 2018):\n",
    "    df = pd.read_csv('../Data/clean_dblp/'+str(year)+'.csv')\n",
    "    \n",
    "    # The same as above, applied year by year instead.\n",
    "    t0 = time.time()\n",
    "\n",
    "\n",
    "    vectorizer = CountVectorizer(strip_accents='ascii', \n",
    "                                 ngram_range=(1,ngram_length),\n",
    "                                 stop_words=stop,\n",
    "                                 vocabulary=bursts)\n",
    "\n",
    "    vector = vectorizer.fit_transform(df.text)\n",
    "    \n",
    "    # If any element is larger than one, set it to one\n",
    "    vector.data = np.where(vector.data>0, 1, 0)\n",
    "    \n",
    "    vectors.append(vector)\n",
    "    \n",
    "    print(year, time.time()-t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\tattere\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\scipy\\sparse\\compressed.py:742: SparseEfficiencyWarning: Changing the sparsity structure of a csc_matrix is expensive. lil_matrix is more efficient.\n",
      "  SparseEfficiencyWarning)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n",
      "80\n",
      "1 : state art, art, state\n",
      "2 : network, efficient, propose, different, proposed, novel, paper propose, task\n",
      "3 : simulation, result show, show proposed, simulation result\n",
      "4 : social, social network\n",
      "5 : web, online, service, technology, content, internet\n",
      "6 : security, attack\n",
      "7 : device, mobile\n",
      "8 : significant, energy, efficiency\n",
      "9 : neural network, neural\n",
      "10 : machine learning, machine, learning\n",
      "11 : wireless sensor, node, wireless, sensor network, wireless sensor network, sensor\n",
      "12 : hoc network, ad hoc, ad hoc network, ad, hoc\n",
      "13 : title available, product webpage, purchased add cart, com article, available full version, document may, global com article, page available, may purchased add, product webpage www, camid4v1 title available, infosci journal discipline, available infosci, document may purchased, version document may, button, librarian www, title available infosci, purchased add, available full, cart button, webpage, infosci journal, camid4v1 title, journal infosci journal, cart, add cart button, recommend product librarian, purchased, id2, available infosci journal, version document, button product, infosci journal infosci, webpage www, recommend product, com resource libraryrecommendation, add cart, librarian, cart button product, product librarian www, button product webpage, infosci, journal infosci, product librarian, resource libraryrecommendation, com resource, page available full, global com, full version document, camid4v1, may purchased, igi global com, journal discipline, libraryrecommendation, global com resource, full version\n",
      "14 : copyright igi global, permission igi, igi global prohibited, international journal, distributing print electronic, without written permission, print, igi, form without, prohibited, distributing print, electronic form without, permission igi global, permission, copying distributing, global prohibited, copying, 10point4018, igi global, distributing, form without written, doi 10point4018, print electronic, print electronic form, journal, doi, written permission, electronic form, copyright igi, written permission igi, copying distributing print, without written\n",
      "15 : fading channel, antenna, fading, mimo, channel\n",
      "16 : traffic, end end, throughput, qos, router, ip, packet, wireless network, relay, aware\n",
      "17 : inc right, inc right reserved, elsevier inc, elsevier inc right\n",
      "18 : elsevier science bv, elsevier science, science bv, science, science bv right\n",
      "19 : dataset, datasets\n",
      "20 : trained, train, training\n",
      "21 : learns, learned, learn\n",
      "22 : deep, dnn, deep learning, deep neural network, deep neural\n",
      "23 : convolutional neural, convolutional neural network, convolutional, cnn, network cnn, neural network cnn\n",
      "24 : mining, data mining\n",
      "25 : http, http www, www\n",
      "26 : microarray, gene, protein, expression data, gene expression, gene expression data\n",
      "27 : revised form, available online, article history received, received revised, received revised form, article history, history received\n",
      "28 : swarm, particle swarm, swarm optimization, particle swarm optimization\n",
      "29 : thing iot, internet thing iot, internet thing, thing, iot\n",
      "30 : cognitive, cognitive radio, primary user, cognitive radio network\n",
      "31 : recurrent neural network, recurrent neural, recurrent\n",
      "32 : term memory, memory lstm, lstm, long short, long short term, short term, short term memory, term memory lstm\n",
      "33 : mobile ad hoc, mobile ad, manet\n",
      "34 : art method, state art method\n",
      "35 : doi org 10point1016, dx, org 10point1016, http dx, doi org, 10point1016\n",
      "36 : available http github, http github, http github com, github com, com, availability implementation, github\n",
      "37 : wiley periodical, periodical inc, wiley periodical inc, periodical\n",
      "38 : online wiley interscience, online wiley, interscience www, 10point1002, published online wiley, doi 10point1002, wiley interscience www\n",
      "39 : reinforcement, reinforcement learning\n",
      "40 : wireless mesh network, mesh network, wireless mesh\n",
      "41 : 802point11, wlan, ieee\n",
      "42 : software defined networking, software defined, sdn, defined networking\n",
      "43 : bv peer review, published elsevier ltd, review responsibility, bv peer, selection peer, published elsevier bv, elsevier bv peer, peer review responsibility, selection peer review, published elsevier\n",
      "44 : copyright john wiley, copyright john\n",
      "45 : smart phone, app, apps, smartphones, android, smartphone, tablet\n",
      "46 : form given, summary form, summary form given, summary\n",
      "47 : spl mu cmos, spl, mu, mu cmos, 0point18 spl, spl mu\n",
      "48 : 0point18, mum, 0point18 mum, cmos, mum cmos\n",
      "49 : originality, originality value\n",
      "50 : 2point0, web 2point0\n",
      "51 : social medium, twitter, facebook\n",
      "52 : millimeter wave, millimeter, wave mmwave, millimeter wave mmwave, mmwave\n",
      "53 : orthogonal multiple access, non orthogonal multiple, noma, non orthogonal, orthogonal multiple, multiple access noma, access noma\n",
      "54 : 5g, fifth generation, 5g network, fifth generation 5g, generation 5g, fifth\n",
      "55 : data analytics, analytics\n",
      "56 : massive multiple input, massive, massive multiple, massive mimo\n",
      "57 : xml, xml document, xml data\n",
      "58 : h264, avc\n",
      "59 : data warehouse, warehouse\n",
      "60 : 978, doi 10point4018 978, 10point4018 978\n",
      "61 : bear notice full, notice full, copy bear, full citation, notice full citation\n",
      "62 : overlay, overlay network\n",
      "63 : peer network, peer peer network\n",
      "64 : acm subject, acm subject classification\n",
      "65 : neural network cnns, deep convolutional neural, deep convolutional, cnns, network cnns\n",
      "66 : sensor node, wsn\n",
      "67 : literature classification, classification number, literature classification number, economic literature, journal economic, economic literature classification, journal economic literature\n",
      "68 : crowdsourcing, neural network architecture, autonomic, sparse, multicore, network trained, sub sub, neural network rnn, portal, uwb, lte, autoencoder, sub spl, corba, ecient, diffserv, generative, convolutional layer, adversarial, learning model, mobile agent, soc, spark, drone, differentiated service, convolutional network, cdma, differentiated, word embeddings, small cell, network function, embeddings, work present, deep learning model, owl, keywords, 17point00, deep network, wearable device, science ltd right, 3g, remote sensing, imes, iot device, published elsevier science, pre trained, representation learning, streaming, kinect, convolution, science usa, key word, grid computing, feature map, science inc right, cross layer, gan, nfv, space time, java, ar iv, poster, bluetooth, cnn model, semantic segmentation, gpu, wimax, metadata, learning method, elsevier science usa, eciency, deep feature, fog, turbo, rnn, spl time, session, loss function, embedding, multi core, sup, wearable, deep learning method, baseline, intranet, uml, smart city, knowledge management, rfid, network rnn, iot application, network architecture, word embedding, 17point00 ieee, sub, health care, propose deep\n",
      "69 : semantic, semantic web, ontology\n",
      "70 : p2p, peer, peer peer\n",
      "71 : big data, big\n",
      "72 : cloud service, cloud computing, cloud\n",
      "73 : soa, service oriented architecture, oriented architecture, web service, service oriented\n",
      "74 : smart grid, grid, smart\n",
      "75 : vr, virtual reality, virtual\n",
      "76 : site, web site\n",
      "77 : market, commerce, business, electronic commerce\n",
      "78 : ltd right reserved, ltd, elsevier ltd right, elsevier ltd, ltd right\n",
      "79 : right, right reserved, reserved, elsevier\n",
      "80 : elsevier bv right, bv, bv right reserved, elsevier bv, bv right\n"
     ]
    }
   ],
   "source": [
    "cooccurrence = []\n",
    "for v in vectors:\n",
    "    c = v.T*v\n",
    "    c.setdiag(0)\n",
    "    c = c.todense()\n",
    "    cooccurrence.append(c)\n",
    "    \n",
    "all_cooccurrence = np.sum(cooccurrence, axis=0)\n",
    "\n",
    "# Translate co-occurence into a distance\n",
    "dists = 1- all_cooccurrence/all_cooccurrence.max()\n",
    "\n",
    "# Remove the diagonal (squareform requires diagonals be zero)\n",
    "dists -= np.diag(np.diagonal(dists))\n",
    "\n",
    "# Put the distance matrix into the format required by hierachy.linkage\n",
    "flat_dists = squareform(dists)\n",
    "\n",
    "# Get the linkage matrix\n",
    "linkage_matrix = hierarchy.linkage(flat_dists, \"ward\")\n",
    "\n",
    "assignments = hierarchy.fcluster(linkage_matrix, 80, 'maxclust')\n",
    "print(len(bursts))\n",
    "print(len(set(assignments)))\n",
    "\n",
    "clusters = defaultdict(list)\n",
    "\n",
    "for term, assign in zip(bursts, assignments):\n",
    "    clusters[assign].append(term)\n",
    "    \n",
    "for key in sorted(clusters.keys()):\n",
    "    print(key, ':',  ', '.join(clusters[key]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graph selected bursty terms over time\n",
    "\n",
    "We manually remove clusters that contain copyright declarations, etc. Then we filter down to 52, choosing a representative sample over time. We choose one or two terms to represent each cluster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('clusters3/clusters.csv')\n",
    "clusters = [d.split(', ') for d in df.terms]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['neural network'],\n",
       " ['intranet'],\n",
       " ['virtual reality', 'vr'],\n",
       " ['data warehouse'],\n",
       " ['commerce'],\n",
       " ['java'],\n",
       " ['xml'],\n",
       " ['internet'],\n",
       " ['router'],\n",
       " ['grid computing'],\n",
       " ['peer peer', 'p2p'],\n",
       " ['semantic web'],\n",
       " ['data mining'],\n",
       " ['owl'],\n",
       " ['mobile ad hoc', 'manet'],\n",
       " ['gene expression'],\n",
       " ['service oriented architecture', 'soa'],\n",
       " ['bluetooth'],\n",
       " ['security'],\n",
       " ['web 2point0'],\n",
       " ['wireless sensor network'],\n",
       " ['particle swarm optimization'],\n",
       " ['multicore', 'multi core'],\n",
       " ['gpu'],\n",
       " ['social network'],\n",
       " ['cognitive radio'],\n",
       " ['smart grid'],\n",
       " ['kinect'],\n",
       " ['smartphones', 'smartphone'],\n",
       " ['cloud'],\n",
       " ['dataset', 'datasets'],\n",
       " ['machine learning'],\n",
       " ['wearable'],\n",
       " ['crowdsourcing'],\n",
       " ['long short term', 'lstm'],\n",
       " ['github'],\n",
       " ['big data'],\n",
       " ['spark'],\n",
       " ['deep'],\n",
       " ['iot', 'internet thing'],\n",
       " ['ar iv'],\n",
       " ['recurrent neural network', 'rnn'],\n",
       " ['representation learning'],\n",
       " ['autoencoder'],\n",
       " ['mmwave', 'millimeter wave'],\n",
       " ['word embeddings', 'word embedding'],\n",
       " ['convolutional neural', 'cnn'],\n",
       " ['fog'],\n",
       " ['drone'],\n",
       " ['pre trained'],\n",
       " ['5g', 'fifth generation'],\n",
       " ['non orthogonal multiple', 'noma']]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0,0.5,'Percentage of documents containing term (%)')"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x13ae3780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def get_prevalence(cluster):\n",
    "    indices = []\n",
    "    for term in cluster:\n",
    "        indices.append(bursts.index(term))\n",
    "\n",
    "    prevalence = []\n",
    "    for year in range(30):\n",
    "        prevalence.append(100*np.sum(np.sum(burstvectors[year][:,indices], axis=1)>0)/burstvectors[year].shape[0])\n",
    "        \n",
    "    return prevalence\n",
    "\n",
    "\n",
    "yplots = 13\n",
    "xplots = 4\n",
    "fig, axs = plt.subplots(yplots, xplots)\n",
    "plt.subplots_adjust(right=1, hspace=0.9, wspace=0.3)\n",
    "plt.suptitle('Prevalence of selected bursty clusters over time', fontsize=14)\n",
    "fig.subplots_adjust(top=0.95)\n",
    "fig.set_figheight(16)\n",
    "fig.set_figwidth(12)\n",
    "x = np.arange(0,30)\n",
    "\n",
    "prevalences = []\n",
    "for i, cluster in enumerate(clusters):\n",
    "    prevalence = get_prevalence(cluster)\n",
    "    prevalences.append(prevalence)\n",
    "    title = df.name[i]\n",
    "    axs[int(np.floor((i/xplots)%yplots)), i%xplots].plot(x, prevalence, color='k', ls='-', label=title)\n",
    "    axs[int(np.floor((i/xplots)%yplots)), i%xplots].grid()\n",
    "    ymax=np.ceil(max(prevalence)*2)/2\n",
    "    if ymax == 0.5 and max(prevalence) <0.25:\n",
    "        ymax=0.25\n",
    "    elif ymax == 2.5:\n",
    "        ymax=3\n",
    "    axs[int(np.floor((i/xplots)%yplots)), i%xplots].set_ylim(0,ymax)\n",
    "    axs[int(np.floor((i/xplots)%yplots)), i%xplots].set_xlim(0,30)\n",
    "    axs[int(np.floor((i/xplots)%yplots)), i%xplots].set_title(title, fontsize=12)\n",
    "    \n",
    "    \n",
    "    if i%yplots != yplots-1:\n",
    "        axs[i%yplots, int(np.floor((i/yplots)%xplots))].set_xticklabels([])\n",
    "    else:\n",
    "        axs[i%yplots, int(np.floor((i/yplots)%xplots))].set_xticklabels([1988, 1998, 2008, 2018])\n",
    "        \n",
    "axs[6,0].set_ylabel('Percentage of documents containing term (%)', fontsize=12)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction\n",
    "\n",
    "### Build the development set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2008 1881\n",
      "2009 1946\n",
      "2010 1969\n",
      "2011 2067\n",
      "2012 2190\n",
      "2013 2152\n",
      "2014 2273\n",
      "2015 2255\n",
      "2016 2369\n",
      "2017 2535\n"
     ]
    }
   ],
   "source": [
    "development_data = {}\n",
    "for year in range(2008, 2018):\n",
    "    year_idx = year_range.index(year)\n",
    "    \n",
    "    # Use our three-year method to calc significance\n",
    "    valid_vectors = calc_significance(stacked_vectors[:year_idx+1], significance_threshold, 3)\n",
    "    \n",
    "    # Recalculate the macd things based on this more limited dataset\n",
    "    long_ma, short_ma, significance_ma, macd, signal, hist = calc_macd(valid_vectors)\n",
    "    \n",
    "    \n",
    "    # Calculate scaling factor\n",
    "    scaling_factor = calc_scaling(significance_ma.iloc[max(long_ma_length, year_idx-19):year_idx+1], \"sqrt\")\n",
    "\n",
    "    # Calculate the burstiness\n",
    "    burstiness_over_time = calc_burstiness(hist, scaling_factor)\n",
    "    burstiness = max_burstiness(burstiness_over_time)\n",
    "\n",
    "    # Choose terms that are above both thresholds (burstiness, and also most recent year was significant)\n",
    "    burst_idx = np.where((burstiness[\"max\"]>0.0012)&(significance_ma.iloc[year_idx]>significance_threshold))[0]\n",
    "    \n",
    "    # Find the actual names of these terms\n",
    "    bursts = valid_vectors.keys()[burst_idx]\n",
    "    \n",
    "    # Create a new, much smaller dataset\n",
    "    dataset = stacked_vectors[bursts].iloc[year_idx-19:year_idx+1]\n",
    "    \n",
    "    # Get the scaled y values\n",
    "    if year < 2015:\n",
    "        y = stacked_vectors[bursts].iloc[year_idx+testing_period]\n",
    "\n",
    "\n",
    "    # Select features and store the data\n",
    "    development_data[year] = {}\n",
    "    development_data[year][\"X\"] = feature_selection(dataset)\n",
    "    if year < 2015:\n",
    "        development_data[year][\"y\"]=y-development_data[year][\"X\"]['significance']\n",
    "    print(year, len(bursts))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing a max depth for the random forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d2d5438>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.array(pd.concat([development_data[year][\"X\"] for year in range(2008,2015)]))\n",
    "y = np.array(pd.concat([development_data[year][\"y\"] for year in range(2008,2015)]))\n",
    "y_thresh = np.zeros_like(y)\n",
    "y_thresh[y>0] = 1\n",
    "\n",
    "# Balance the sample\n",
    "X, y_thresh = balanced_subsample(X, y_thresh,subsample_size=1.0)\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y_thresh, test_size=0.33, random_state=1)\n",
    "\n",
    "max_depths = np.linspace(1, 32, 32, endpoint=True)\n",
    "train_results = []\n",
    "test_results = []\n",
    "for max_depth in max_depths:\n",
    "    rf = RandomForestClassifier(n_estimators=100, max_depth=max_depth)\n",
    "    rf.fit(x_train, y_train)\n",
    "    train_pred = rf.predict(x_train)\n",
    "    false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n",
    "    roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "    train_results.append(roc_auc)\n",
    "    y_pred = rf.predict(x_test)\n",
    "    false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred)\n",
    "    roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "    test_results.append(roc_auc)\n",
    "\n",
    "\n",
    "line1, = plt.plot(max_depths, train_results, 'b', label=\"Train AUC\")\n",
    "line2, = plt.plot(max_depths, test_results, 'r', label=\"Test AUC\")\n",
    "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n",
    "plt.ylabel('AUC score')\n",
    "plt.xlabel('Tree depth')\n",
    "plt.title('Effect of changing the maximum depth of the random forest on classifier accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choosing the number of estimators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x21dda668>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = np.array(pd.concat([development_data[year][\"X\"] for year in range(2008,2015)]))\n",
    "y = np.array(pd.concat([development_data[year][\"y\"] for year in range(2008,2015)]))\n",
    "y_thresh = np.zeros_like(y)\n",
    "y_thresh[y>0] = 1\n",
    "\n",
    "# Balance the sample\n",
    "X, y_thresh = balanced_subsample(X, y_thresh,subsample_size=1.0)\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, y_thresh, test_size=0.33, random_state=3)\n",
    "\n",
    "n_estimators = [1, 2, 4, 8, 16, 32, 64, 100, 150, 200, 300, 500, 800]\n",
    "train_results = []\n",
    "test_results = []\n",
    "for estimator in n_estimators:\n",
    "    rf = RandomForestClassifier(n_estimators=estimator, max_depth=13, n_jobs=-1)\n",
    "    rf.fit(x_train, y_train)\n",
    "    train_pred = rf.predict(x_train)\n",
    "    false_positive_rate, true_positive_rate, thresholds = roc_curve(y_train, train_pred)\n",
    "    roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "    train_results.append(roc_auc)\n",
    "    y_pred = rf.predict(x_test)\n",
    "    false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test, y_pred)\n",
    "    roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "    test_results.append(roc_auc)\n",
    "from matplotlib.legend_handler import HandlerLine2D\n",
    "line1, = plt.plot(n_estimators, train_results, 'b', label='Train AUC')\n",
    "line2, = plt.plot(n_estimators, test_results, 'r', label='Test AUC')\n",
    "plt.legend(handler_map={line1: HandlerLine2D(numpoints=2)})\n",
    "plt.ylabel('AUC score')\n",
    "plt.xlabel('n_estimators')\n",
    "plt.title('Effect of changing the number of estimators of the random forest on classifier accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The effect of changing the burstiness threshold and prediction interval on the random forest classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0006 1 60448 0.683\n",
      "0.0006 2 58156 0.705\n",
      "0.0006 3 56136 0.714\n",
      "0.0006 4 54880 0.722\n",
      "0.0006 5 52894 0.722\n",
      "0.0007999999999999999 1 28394 0.729\n",
      "0.0007999999999999999 2 26886 0.744\n",
      "0.0007999999999999999 3 25570 0.748\n",
      "0.0007999999999999999 4 24804 0.752\n",
      "0.0007999999999999999 5 23858 0.752\n",
      "0.001 1 14518 0.766\n",
      "0.001 2 13572 0.776\n",
      "0.001 3 12978 0.789\n",
      "0.001 4 12604 0.784\n",
      "0.001 5 12142 0.783\n",
      "0.0012 1 8358 0.805\n",
      "0.0012 2 7808 0.816\n",
      "0.0012 3 7450 0.815\n",
      "0.0012 4 7254 0.82\n",
      "0.0012 5 6962 0.817\n",
      "0.0013999999999999998 1 5594 0.814\n",
      "0.0013999999999999998 2 5150 0.823\n",
      "0.0013999999999999998 3 4886 0.822\n",
      "0.0013999999999999998 4 4772 0.824\n",
      "0.0013999999999999998 5 4622 0.809\n",
      "0.0015999999999999999 1 3852 0.837\n",
      "0.0015999999999999999 2 3524 0.843\n",
      "0.0015999999999999999 3 3332 0.835\n",
      "0.0015999999999999999 4 3256 0.824\n",
      "0.0015999999999999999 5 3156 0.826\n"
     ]
    }
   ],
   "source": [
    "scores = {}\n",
    "for threshold in np.arange(0.0006, 0.0017, 0.0002):\n",
    "    scores[threshold] = {}\n",
    "    for year in range(2008, 2013):\n",
    "        year_idx = year_range.index(year)\n",
    "\n",
    "        # Use our three-year method to calc significance\n",
    "        valid_vectors = calc_significance(stacked_vectors[:year_idx+1], significance_threshold, 3)\n",
    "\n",
    "        # Recalculate the macd things based on this more limited dataset\n",
    "        long_ma, short_ma, significance_ma, macd, signal, hist = calc_macd(valid_vectors)\n",
    "\n",
    "\n",
    "        # Calculate scaling factor\n",
    "        scaling_factor = calc_scaling(significance_ma.iloc[max(long_ma_length, year_idx-19):year_idx+1], \"sqrt\")\n",
    "\n",
    "        # Calculate the burstiness\n",
    "        burstiness_over_time = calc_burstiness(hist, scaling_factor)\n",
    "        burstiness = max_burstiness(burstiness_over_time)\n",
    "\n",
    "        # Choose terms that are above both thresholds (burstiness, and also most recent year was significant)\n",
    "        burst_idx = np.where((burstiness[\"max\"]>threshold)&(significance_ma.iloc[year_idx]>significance_threshold))[0]\n",
    "\n",
    "        # Find the actual names of these terms\n",
    "        bursts = valid_vectors.keys()[burst_idx]\n",
    "\n",
    "        # Create a new, much smaller dataset\n",
    "        dataset = stacked_vectors[bursts].iloc[year_idx-19:year_idx+1]\n",
    "\n",
    "        # Select features and store the data\n",
    "        development_data[year] = {}\n",
    "        development_data[year][\"X\"] = feature_selection(dataset)\n",
    "        \n",
    "        development_data[year][\"y\"] = {}\n",
    "        \n",
    "        for interval in range(1,6):\n",
    "            # Get the scaled y values\n",
    "            y = stacked_vectors[bursts].iloc[year_idx+interval]\n",
    "            development_data[year][\"y\"][interval]=y-development_data[year][\"X\"]['significance']\n",
    "    \n",
    "    \n",
    "    X = np.array(pd.concat([development_data[year][\"X\"] for year in range(2008,2013)]))\n",
    "    \n",
    "    for interval in range(1,6):\n",
    "        scores[threshold][interval] = {}\n",
    "        scores[threshold][interval]['scores'] = []\n",
    "        y = np.array(pd.concat([development_data[year][\"y\"][interval] for year in range(2008,2013)]))\n",
    "        \n",
    "        # Binarise y data\n",
    "        y_thresh = np.zeros_like(y)\n",
    "        y_thresh[y>0] = 1\n",
    "        \n",
    "        # Balance the sample\n",
    "        X_bal, y_thresh = balanced_subsample(X, y_thresh,subsample_size=1.0)\n",
    "        \n",
    "        scores[threshold][interval]['size'] = len(y_thresh)\n",
    "        kf = KFold(n_splits=10, shuffle=True)\n",
    "        for train, test in kf.split(X_bal):\n",
    "            clf = RandomForestClassifier(n_estimators=150, max_depth=13)\n",
    "\n",
    "            clf.fit(X_bal[train], y_thresh[train])\n",
    "            preds = clf.predict(X_bal[test])\n",
    "\n",
    "            new_scores = [\n",
    "                sklearn.metrics.accuracy_score(y_thresh[test], preds),\n",
    "                sklearn.metrics.f1_score(y_thresh[test], preds),\n",
    "                np.sum(y_thresh[test]==0)/len(y_thresh[test])\n",
    "            ]\n",
    "            scores[threshold][interval]['scores'].append(new_scores)\n",
    "        \n",
    "        print(threshold, interval, len(y_thresh), np.round(np.mean(np.array(scores[threshold][interval]['scores'])[:,0]),3)\n",
    "             )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Format for table in paper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0006 & 56136 & 0.71 $\\pm$ 0.01 & 0.72 $\\pm$ 0.01 \\\\\n",
      "0.0007999999999999999 & 25570 & 0.75 $\\pm$ 0.01 & 0.75 $\\pm$ 0.01 \\\\\n",
      "0.001 & 12978 & 0.79 $\\pm$ 0.01 & 0.79 $\\pm$ 0.01 \\\\\n",
      "0.0012 & 7450 & 0.82 $\\pm$ 0.01 & 0.82 $\\pm$ 0.01 \\\\\n",
      "0.0013999999999999998 & 4886 & 0.82 $\\pm$ 0.02 & 0.83 $\\pm$ 0.02 \\\\\n",
      "0.0015999999999999999 & 3332 & 0.83 $\\pm$ 0.02 & 0.84 $\\pm$ 0.02 \\\\\n"
     ]
    }
   ],
   "source": [
    "for threshold in np.arange(0.0006, 0.0017, 0.0002):\n",
    "    print(threshold, '&', \n",
    "          scores[threshold][3]['size'], '&', \n",
    "          np.round(np.mean(np.array(scores[threshold][3]['scores'])[:,0]),2), \n",
    "          '$\\pm$', \n",
    "          np.round(np.std(np.array(scores[threshold][3]['scores'])[:,0]),2), '&', \n",
    "          np.round(np.mean(np.array(scores[threshold][3]['scores'])[:,1]),2), \n",
    "          '$\\pm$', \n",
    "          np.round(np.std(np.array(scores[threshold][3]['scores'])[:,1]),2), \n",
    "          '\\\\\\\\'\n",
    "         )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x58bb23c8>"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7007e860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.rc('font', family='sans-serif')\n",
    "plt.rc('xtick', labelsize='medium')\n",
    "plt.rc('ytick', labelsize='medium')\n",
    "line_styles = ['-', '--', ':']\n",
    "col = 0.5\n",
    "fig = plt.figure(figsize=(6,3.7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "ax.set_title('Choosing a prediction interval, I', fontsize=13)\n",
    "ax.grid()\n",
    "ax.set_ylim(0.65,0.9)\n",
    "#ax.set_xlim(1,5)\n",
    "\n",
    "ax.set_ylabel('F1 score', fontsize=12)\n",
    "ax.set_xlabel('Number of years in future', fontsize=12)\n",
    "\n",
    "plt.xticks(range(1,6), range(1,6))\n",
    "\n",
    "thresholds = [\"0.0006\", \"0.0008\", \"0.0010\", \"0.0012\", \"0.0014\", \"0.0016\"]\n",
    "for i, threshold in enumerate(np.arange(0.0006, 0.0017, 0.0002)):\n",
    "    y = []\n",
    "    yerr = []\n",
    "    for interval in range(1,6):\n",
    "        s = np.array(scores[threshold][interval]['scores'])\n",
    "        y.append(np.mean(s[:,1]))\n",
    "        yerr.append(np.std(s[:,1]))\n",
    "    \n",
    "    ax.errorbar(range(1,6), y, yerr=yerr, color=str(col),  label=thresholds[i], fmt='--o')\n",
    "        \n",
    "    col-=0.1\n",
    "    \n",
    "#ax.legend(ncol=3, mode=\"expand\")\n",
    "ax.legend(fontsize=11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train a single classifier on all the data from 1988-2014"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "            max_depth=13, max_features='auto', max_leaf_nodes=None,\n",
       "            min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "            min_samples_leaf=1, min_samples_split=2,\n",
       "            min_weight_fraction_leaf=0.0, n_estimators=150, n_jobs=1,\n",
       "            oob_score=False, random_state=None, verbose=0,\n",
       "            warm_start=False)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold = 0.0012\n",
    "interval = 3\n",
    "\n",
    "for year in range(2008, 2018):\n",
    "    year_idx = year_range.index(year)\n",
    "\n",
    "    # Use our three-year method to calc significance\n",
    "    valid_vectors = calc_significance(stacked_vectors[:year_idx+1], significance_threshold, 3)\n",
    "\n",
    "    # Recalculate the macd things based on this more limited dataset\n",
    "    long_ma, short_ma, significance_ma, macd, signal, hist = calc_macd(valid_vectors)\n",
    "\n",
    "\n",
    "    # Calculate scaling factor\n",
    "    scaling_factor = calc_scaling(significance_ma.iloc[max(long_ma_length, year_idx-19):year_idx+1], \"sqrt\")\n",
    "\n",
    "    # Calculate the burstiness\n",
    "    burstiness_over_time = calc_burstiness(hist, scaling_factor)\n",
    "    burstiness = max_burstiness(burstiness_over_time)\n",
    "\n",
    "    # Choose terms that are above both thresholds (burstiness, and also most recent year was significant)\n",
    "    burst_idx = np.where((burstiness[\"max\"]>threshold)&(significance_ma.iloc[year_idx]>significance_threshold))[0]\n",
    "\n",
    "    # Find the actual names of these terms\n",
    "    bursts = valid_vectors.keys()[burst_idx]\n",
    "\n",
    "    # Create a new, much smaller dataset\n",
    "    dataset = stacked_vectors[bursts].iloc[year_idx-19:year_idx+1]\n",
    "\n",
    "    # Select features and store the data\n",
    "    development_data[year] = {}\n",
    "    development_data[year][\"X\"] = feature_selection(dataset)\n",
    "    if year < 2015:\n",
    "        y = stacked_vectors[bursts].iloc[year_idx+interval]\n",
    "        development_data[year][\"y\"]=y-development_data[year][\"X\"]['significance']\n",
    "\n",
    "\n",
    "X = np.array(pd.concat([development_data[year][\"X\"] for year in range(2008,2015)]))\n",
    "y = np.array(pd.concat([development_data[year][\"y\"] for year in range(2008,2015)]))\n",
    "\n",
    "# Binarise y data\n",
    "y_thresh = np.zeros_like(y)\n",
    "y_thresh[y>0] = 1\n",
    "\n",
    "# Balance the sample\n",
    "X_bal, y_thresh = balanced_subsample(X, y_thresh,subsample_size=1.0)\n",
    "\n",
    "\n",
    "clf = RandomForestClassifier(n_estimators=150, max_depth=13)\n",
    "clf.fit(X_bal, y_thresh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choose all terms that were above the burstiness and significance thresholds in 2017"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choose terms that are above both thresholds\n",
    "burst_idx = np.where((burstiness[\"max\"]>burstiness_threshold_prediction)&(significance_ma.iloc[29]>significance_threshold))[0]\n",
    "\n",
    "# Find the actual names of these terms\n",
    "bursts = list(valid_vectors.keys()[burst_idx])\n",
    "\n",
    "# Create a new, much smaller dataset\n",
    "dataset = stacked_vectors[bursts].iloc[year_idx-19:year_idx+1]\n",
    "\n",
    "X_test = np.array(feature_selection(dataset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use the classifier to predict whether they will rise or fall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "periodical, result show, 5g, big, massive, article history received, software defined, learning, mmwave, deep learning model, neural, iot, bear notice, machine, mu, convolutional network, recurrent neural network, 5g network, state, millimeter, trained, big data, term memory lstm, advantage copy, network trained, word embeddings, cnn, http, wearable, iot device, autoencoder, neural network, analytics, convolutional neural, commercial advantage copy, long short, fifth generation, novel, train, memory lstm, iot application, network cnns, social, device, bear notice full, recurrent, learning model, notice full citation, learn, written permission, term memory, network architecture, copy bear, neural network architecture, notice full, convolution, sensor, internet thing iot, periodical inc, convolutional, network cnn, github com, massive mimo, cloud, network, deep, vr, adversarial, cnn model, deep learning method, pre trained, machine learning, igi global, proposed, deep learning, propose, embeddings, copy bear notice, http github com, short term memory, neural network cnns, article history, wiley periodical inc, dataset, http github, history received, long short term, acm, deep convolutional, training, neural network cnn, wiley periodical, sdn, work present, deep network, end end, datasets, internet thing, millimeter wave, thing, state art, deep neural network, rnn, smart, different, deep neural, github, deep convolutional neural, internet, thing iot, cnns, convolutional neural network, fog, advantage copy bear, art, lstm\n",
      "\n",
      "content, http www, elsevier, reserved, wireless mesh network, relay, 978, elsevier inc right, title, summary form given, efficient, web service, elsevier ltd, igi, received revised, revised form, doi org 10point1016, lte, service, gene expression, xml, dx, originality value, semantic web, ion, ad hoc network, peer peer, org 10point1016, elsevier ltd right, mobile, h264, bv right, smartphones, print, electronic commerce, ltd right reserved, cross layer, purchased, key word, sup, sensor node, recurrent neural, citation first, received revised form, international journal, cdma, science, uml, hoc, wireless sensor, p2p, grid computing, doi org, service oriented, wireless, node, right reserved, differentiated, ltd right, android, keywords, ip, smart grid, app, kinect, microarray, http dx, multi core, grid, ad, available online, form given, java, doi, bv, spl, cognitive radio, manet, sensor network, web 2point0, 10point1016, without written, mesh network, wireless sensor network, smartphone, without written permission, citation first page, www, full version, published elsevier, ontology, elsevier inc, parallel, web site, social network, prohibited, full citation, channel, wireless mesh, packet, twitter, copying, gene, tablet, permission, semantic, right, web, commerce, elsevier bv right, cloud computing, hoc network, social medium, summary form, ad hoc, elsevier bv, copyright, bv right reserved, full citation first, expert system, peer\n"
     ]
    }
   ],
   "source": [
    "preds = clf.predict(X_test)\n",
    "rise = []\n",
    "fall = []\n",
    "for i, p in enumerate(preds):\n",
    "    if p>0.5:\n",
    "        rise.append(bursts[i])\n",
    "    else:\n",
    "        fall.append(bursts[i])\n",
    "        \n",
    "print(', '.join(rise))\n",
    "print()\n",
    "print(', '.join(fall))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}