From bf77e403241926cfb040d13a2ca62a72e5b0ad07 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 8 Oct 2019 20:55:31 -0500
Subject: [PATCH 01/22] sentiment evaluation v0

---
 lib/tagnews/senteval/__init__.py |  3 ++
 lib/tagnews/senteval/eval.py     | 82 ++++++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+)
 create mode 100644 lib/tagnews/senteval/__init__.py
 create mode 100644 lib/tagnews/senteval/eval.py

diff --git a/lib/tagnews/senteval/__init__.py b/lib/tagnews/senteval/__init__.py
new file mode 100644
index 0000000..7b13ead
--- /dev/null
+++ b/lib/tagnews/senteval/__init__.py
@@ -0,0 +1,3 @@
+from . import eval
+
+__all__ = [eval]
diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
new file mode 100644
index 0000000..952aa9a
--- /dev/null
+++ b/lib/tagnews/senteval/eval.py
@@ -0,0 +1,82 @@
+from google.cloud import language
+from google.cloud.language import enums
+from google.cloud.language import types
+
+
+def process_google_result(text):
+    document = types.Document(content=text, type=enums.Document.Type.PLAIN_TEXT)
+    sentiment = client.analyze_entity_sentiment(document=document)
+
+    for entity in sentiment.entities:
+        clean_entity = "".join(filter(str.isalpha, entity)).lower()
+
+        if clean_entity in ["police", "officer", "cop", "officers", "pigs"]:
+
+            for mention in entity.mentions:
+                return mention.sentiment.score
+
+
+def clean_html_text(html_text):
+    return "".join(filter(str.isalpha, html_text)).lower()
+
+
+class SentimentGoogler:
+    def __init__(self):
+        self.client = self.connect_to_client()
+
+    def connect_to_client(self):
+        return language.LanguageServiceClient()
+
+    @staticmethod
+    def pre_process(html_text):
+        """
+        Parameters
+        ----------
+        html_text : str
+            Article text.
+
+        Returns
+        -------
+        words: str
+            lower case, just letters
+        """
+        words = "".join(filter(str.isalpha, html_text)).lower()
+        return words
+
+    def call_api(self, doc_text):
+        """
+        Parameters
+        ----------
+        doc_text : str
+            article text
+
+        Returns
+        -------
+        sentiment : json
+            google response call
+        """
+        cleaned_doc_text = self.pre_process(doc_text)
+        document = types.Document(
+            content=cleaned_doc_text, type=enums.Document.Type.PLAIN_TEXT
+        )
+        sentiment = self.client.analyze_entity_sentiment(document=document)
+
+        return sentiment
+
+    @staticmethod
+    def is_police_entity(sentiment_response):
+        possible_responses = [
+            "police",
+            "officer",
+            "cop",
+            "officers",
+            "pigs",
+            "policeofficer",
+        ]
+        for entity in sentiment_response.entities:
+            if clean_html_text(clean_entity) in possible_responses:
+                return entity
+            for mention in entity.mentions:
+                if clean_html_text(mention.text.content) in possible_responses:
+                    return entity
+                return False

From de798a95b286730ddd51b5f46dea4365e1c73855 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 15 Oct 2019 20:15:10 -0500
Subject: [PATCH 02/22] google sentiment evaluater evals

---
 lib/tagnews/senteval/eval.py | 66 ++++++++++++++++++++----------------
 1 file changed, 36 insertions(+), 30 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 952aa9a..8396728 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -16,33 +16,19 @@ def process_google_result(text):
                 return mention.sentiment.score
 
 
-def clean_html_text(html_text):
-    return "".join(filter(str.isalpha, html_text)).lower()
-
-
 class SentimentGoogler:
     def __init__(self):
         self.client = self.connect_to_client()
 
+    def run(self, doc_text):
+        sentiment_ = self.call_api(doc_text)
+        for entity in sentiment_.entities:
+            police_entity = self.is_police_entity(entity)
+            return police_entity
+
     def connect_to_client(self):
         return language.LanguageServiceClient()
 
-    @staticmethod
-    def pre_process(html_text):
-        """
-        Parameters
-        ----------
-        html_text : str
-            Article text.
-
-        Returns
-        -------
-        words: str
-            lower case, just letters
-        """
-        words = "".join(filter(str.isalpha, html_text)).lower()
-        return words
-
     def call_api(self, doc_text):
         """
         Parameters
@@ -55,16 +41,22 @@ def call_api(self, doc_text):
         sentiment : json
             google response call
         """
-        cleaned_doc_text = self.pre_process(doc_text)
         document = types.Document(
-            content=cleaned_doc_text, type=enums.Document.Type.PLAIN_TEXT
+            content=doc_text, type=enums.Document.Type.PLAIN_TEXT
         )
         sentiment = self.client.analyze_entity_sentiment(document=document)
 
         return sentiment
 
-    @staticmethod
-    def is_police_entity(sentiment_response):
+    def is_police_entity(self, entity):
+        possible_responses = [
+            "police",
+            "officer",
+            "cop",
+            "officers",
+            "pigs",
+            "policeofficer",
+        ]
         possible_responses = [
             "police",
             "officer",
@@ -73,10 +65,24 @@ def is_police_entity(sentiment_response):
             "pigs",
             "policeofficer",
         ]
-        for entity in sentiment_response.entities:
-            if clean_html_text(clean_entity) in possible_responses:
+        if entity in possible_responses:
+            return entity
+        for mention in entity.mentions:
+            if pre_process_text(mention.text.content) in possible_responses:
                 return entity
-            for mention in entity.mentions:
-                if clean_html_text(mention.text.content) in possible_responses:
-                    return entity
-                return False
+            return False
+
+def pre_process_text(html_text):
+    """
+    Parameters
+    ----------
+    html_text : str
+        Article text.
+
+    Returns
+    -------
+    words: str
+        lower case, just letters
+    """
+    words = "".join(filter(str.isalpha, html_text)).lower()
+    return words

From 76ea06bc185112bb7be453c93f3da2d09f17bc1d Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 15 Oct 2019 21:12:55 -0500
Subject: [PATCH 03/22] formatting

---
 lib/tagnews/senteval/eval.py | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 8396728..a39f16c 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -41,22 +41,12 @@ def call_api(self, doc_text):
         sentiment : json
             google response call
         """
-        document = types.Document(
-            content=doc_text, type=enums.Document.Type.PLAIN_TEXT
-        )
+        document = types.Document(content=doc_text, type=enums.Document.Type.PLAIN_TEXT)
         sentiment = self.client.analyze_entity_sentiment(document=document)
 
         return sentiment
 
     def is_police_entity(self, entity):
-        possible_responses = [
-            "police",
-            "officer",
-            "cop",
-            "officers",
-            "pigs",
-            "policeofficer",
-        ]
         possible_responses = [
             "police",
             "officer",
@@ -72,6 +62,7 @@ def is_police_entity(self, entity):
                 return entity
             return False
 
+
 def pre_process_text(html_text):
     """
     Parameters

From 08c44563e6bd016e7b22f34c596fc07df24dcaa8 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 22 Oct 2019 20:54:37 -0500
Subject: [PATCH 04/22] return sentiment

---
 lib/tagnews/senteval/eval.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index a39f16c..3cb9670 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -24,11 +24,15 @@ def run(self, doc_text):
         sentiment_ = self.call_api(doc_text)
         for entity in sentiment_.entities:
             police_entity = self.is_police_entity(entity)
-            return police_entity
+            if police_entity:
+                return self.sentiment_from_entity(police_entity)
 
     def connect_to_client(self):
         return language.LanguageServiceClient()
 
+    def sentiment_from_entity(self, entity):
+        return entity.sentiment.score
+
     def call_api(self, doc_text):
         """
         Parameters

From a340b26180bb71f0b1a087c3645cc03b2f40b115 Mon Sep 17 00:00:00 2001
From: RJ Worth <bot.collins@gmail.com>
Date: Mon, 4 Nov 2019 20:56:37 -0600
Subject: [PATCH 05/22] Notebook with research on sentiment evaluation API
 budgeting

---
 lib/notebooks/senteval_budgeting.ipynb | 739 +++++++++++++++++++++++++
 1 file changed, 739 insertions(+)
 create mode 100644 lib/notebooks/senteval_budgeting.ipynb

diff --git a/lib/notebooks/senteval_budgeting.ipynb b/lib/notebooks/senteval_budgeting.ipynb
new file mode 100644
index 0000000..403fa75
--- /dev/null
+++ b/lib/notebooks/senteval_budgeting.ipynb
@@ -0,0 +1,739 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "import json\n",
+    "sys.path.append('..')\n",
+    "import tagnews\n",
+    "import matplotlib.pyplot as plt\n",
+    "import datetime as dt\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "pd.set_option('display.width', 150)\n",
+    "pd.set_option('max.columns', 15)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Determine the costs of processing existing articles\n",
+    "\n",
+    "Based on complete data files from through 2019-09-07.\n",
+    "\n",
+    "Each 1000 words of an article submitted is one \"unit\", rounded up.\n",
+    "\n",
+    "1,496,665 units total = $2487 to process at once, or 300 months in free batches of 5k..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/rachel/Code/civic_data/article-tagging/venv/lib/python3.6/site-packages/IPython/core/interactiveshell.py:3326: DtypeWarning: Columns (1) have mixed types. Specify dtype option on import or set low_memory=False.\n",
+      "  exec(code_obj, self.user_global_ns, self.user_ns)\n",
+      "../tagnews/utils/load_data.py:236: RuntimeWarning: 5 location strings were not found in the bodytext.\n",
+      "  RuntimeWarning)\n"
+     ]
+    }
+   ],
+   "source": [
+    "crimetags = tagnews.CrimeTags()\n",
+    "\n",
+    "df_all = tagnews.load_data()\n",
+    "df_all['read_date'] = df_all['created'].str.slice(0, 10)\n",
+    "### Limiting it to last two years because the data volume is unstable before that\n",
+    "df = df_all.loc[df_all['read_date'] >= '2017-01-01']\n",
+    "del df_all\n",
+    "### Number of units to process title and article through Google Cloud API\n",
+    "df['n_chars'] = df['title'].str.len() + df['bodytext'].str.len()\n",
+    "df['n_units'] = np.ceil(df['n_chars']/1000.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calculate_google_nlp_price(total_units, verbose=True):\n",
+    "    '''Cost to run entity sentiment analysis on a given number of \n",
+    "    units in a single month through in Google Cloud API.\n",
+    "    https://cloud.google.com/natural-language/#natural-language-api-pricing\n",
+    "    \n",
+    "    First 5000 = free\n",
+    "    5k-1M  = $2 per 1000 units\n",
+    "    1M-5M  = $1 per 1000 units\n",
+    "    5M-20M = $0.5 per 1000 units\n",
+    "    '''\n",
+    "    free_units        = min(5e3, total_units)\n",
+    "    first_tier_units  = min(1e6-5e3, total_units-free_units)\n",
+    "    second_tier_units = min(5e6-1e6, total_units-free_units-first_tier_units)\n",
+    "    third_tier_units  = max(0, total_units-free_units-first_tier_units-second_tier_units)\n",
+    "    units = [free_units, first_tier_units, second_tier_units, third_tier_units]\n",
+    "    costs = [0, 2., 1., 0.5]\n",
+    "    total_cost = sum([c*np.ceil(u/1e3) for (c, u) in zip(costs, units)])\n",
+    "    if verbose:\n",
+    "        print('{:.0f} units: {:.0f}*0 + {:.0f}*$2 + {:.0f}*$1 + {:.0f}*$0.50 = ${:.2f}'\n",
+    "              .format(total_units,\n",
+    "                      np.ceil(free_units/1e3),\n",
+    "                      np.ceil(first_tier_units/1e3),\n",
+    "                      np.ceil(second_tier_units/1e3),\n",
+    "                      np.ceil(third_tier_units/1e3),\n",
+    "                      total_cost))\n",
+    "    return total_cost"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1496665 units: 5*0 + 995*$2 + 497*$1 + 0*$0.50 = $2487.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "units = df['n_units'].sum()\n",
+    "cost = calculate_google_nlp_price(units)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "2017-01-01 2019-09-07\n"
+     ]
+    }
+   ],
+   "source": [
+    "units_per_day = (df\n",
+    "                 .groupby('read_date')\n",
+    "                 .agg({'url': 'count',\n",
+    "                       'n_units': 'sum'})\n",
+    "                )\n",
+    "print(units_per_day.index.min(), units_per_day.index.max())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7fd00ff57358>]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1080x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Number of units coming in per day\n",
+    "### Typically ranges from 800-2000 daily, so definitely >5000 monthly\n",
+    "f1, ax1 = plt.subplots(1, figsize=[15, 6])\n",
+    "ax1.plot(range(units_per_day.shape[0]), units_per_day['n_units'], label='# units')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Relevance scoring/binning"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Full dataset takes up too much memory, so dropping all but the most recent now\n",
+    "### This keeps 276122 of the original 1.5e6, or a little less than 1/5th of the total\n",
+    "df2 = df.loc[df['read_date'] >= '2019-03-01']\n",
+    "del df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'units' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-58-f5476ba5b95a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnew_units\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'n_units'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdownscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_units\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_units\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdownscale\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'units' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "new_units = df2['n_units'].sum()\n",
+    "downscale = new_units/units\n",
+    "print(new_units, downscale)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Assign a made-up CPD relevance score\n",
+    "\n",
+    "### Words associated with CPD\n",
+    "cop_words = [\n",
+    "    \"cpd\",\n",
+    "    \"police\",\n",
+    "    \"officer\",\n",
+    "    \"cop\",\n",
+    "    \"officers\",\n",
+    "    \"pigs\",\n",
+    "    \"policeofficer\",\n",
+    "  ]\n",
+    "### Count number of times relevant words appear in title or text\n",
+    "df2['cop_word_counts'] = 0\n",
+    "for w in cop_words:\n",
+    "    df2['cop_word_counts'] += df2['bodytext'].str.lower().str.count(w)\n",
+    "    df2['cop_word_counts'] += df2['title'].str.lower().str.count(w)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "count    72783.000000\n",
+       "mean         1.801300\n",
+       "std          4.715337\n",
+       "min          0.000000\n",
+       "25%          0.000000\n",
+       "50%          0.000000\n",
+       "75%          1.000000\n",
+       "max        240.000000\n",
+       "Name: cop_word_counts, dtype: float64"
+      ]
+     },
+     "execution_count": 40,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df2['cop_word_counts'].describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'CPD_model')"
+      ]
+     },
+     "execution_count": 33,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### Does the word count measure the same thing as the CPD_model column? \n",
+    "### No, doesn't look very correlated actually...\n",
+    "f1, ax1 = plt.subplots(1, figsize=[14,6])\n",
+    "ax1.scatter(df2['cop_word_counts'], df2['CPD_model'], alpha=0.3, s=5)\n",
+    "ax1.set_xlabel('cop word count')\n",
+    "ax1.set_ylabel('CPD_model')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Two Chicago police officers were accused of child abuse. A decade later, they were fired\n",
+      "Two Chicago police officers have been fired a decade after they were first\n",
+      "accused of hitting a child in their care and failing to seek medical attention\n",
+      "for the 8-year-old boy, who suffered fractures to the face and arm that the\n",
+      "child said was inflicted by one of the officers.\n",
+      "\n",
+      "In voting 9-0 to dismiss Officers Yasmina Vaval and Teresa Foster, the Chicago\n",
+      "Police Board said it was “deeply troubled” that this case, and others, take so\n",
+      "long to resolve.\n",
+      "\n",
+      "Advertisement\n",
+      "\n",
+      "“The Board continues to be deeply troubled by cases such as this, in which the\n",
+      "charges were filed more than nine years after an incident occurs,” the board\n",
+      "wrote in a 28-page decision handed down last week. \"In this case, the impact was\n",
+      "particularly serious on the victim, who was eight years old when abused and is\n",
+      "now an adult.”\n",
+      "\n",
+      "The alleged abuse occurred in 2008 and 2009. The Illinois Department of Children\n",
+      "and Family Services removed the boy and two other children from the officers’\n",
+      "home at the end of 2009 after finding evidence of abuse. It took about six years\n",
+      "for the now-defunct Independent Police Review Authority to complete its\n",
+      "investigation and recommend the dismissal of Vaval and Foster. Nearly four more\n",
+      "years passed before city officials filed disciplinary charges and referred the\n",
+      "case to the Police Board.\n",
+      "\n",
+      "Bill McCaffrey, a spokesman for the city’s Law Department, blamed “parallel\n",
+      "investigations by other law enforcement and child welfare agencies” for why it\n",
+      "took so long for IPRA to investigate the case and for city officials to\n",
+      "ultimately bring several disciplinary charges against the officers, including\n",
+      "for mistreatment, making false statements and bringing discredit to the Police\n",
+      "Department. IPRA has since been replaced by the Civilian Office of Police\n",
+      "Accountability under a series of reforms.\n",
+      "\n",
+      "** [ [Most read] Two years ago, Kraft Heinz raised eyebrows on Wall Street when it named a 29-year-old as its CFO. Now he’s out. » ][1] **\n",
+      "\n",
+      "\"While this matter may have spanned numerous years, the end result is that (city\n",
+      "officials were) successful in separating these officers from the police\n",
+      "department,” McCaffrey said in a statement.\n",
+      "\n",
+      "The officers have not been criminally charged, even though the board cited\n",
+      "instances of the officers inflicting harm and lying to police and DCFS workers\n",
+      "about it. The Cook County state’s attorney’s office reviewed the case in March\n",
+      "2010 and concluded there wasn’t sufficient evidence to file criminal charges,\n",
+      "the office’s spokeswoman, Tandra Simonton, said in a statement.\n",
+      "\n",
+      "The officers and their attorney were unavailable for comment.\n",
+      "\n",
+      "In its decision, the Police Board detailed several incidents between spring 2008\n",
+      "and November 2009 where one or both officers “physically maltreated” the boy or\n",
+      "did not seek prompt medical attention.\n",
+      "\n",
+      "The officers, who are married, became foster parents to three boys — 6, 8 and 9\n",
+      "— at the end of 2007. The boy at the center of the allegations suffered from\n",
+      "fetal alcohol syndrome and “had cognitive disabilities,” according to the\n",
+      "board’s report. Foster also has two biological children.\n",
+      "\n",
+      "** [ [Most read] Column: Cubs look closer to being dismantled in the offseason than they are to playing in the World Series » ][2] **\n",
+      "\n",
+      "The first allegation dates to the spring of 2008 when the boy was found to have\n",
+      "a fracture to a bone that supported one of his eyes. There was a delay in\n",
+      "treating the fracture and doctors were not able to correct the damage, according\n",
+      "to the board’s report.\n",
+      "\n",
+      "While the boy accused one of the officers of punching him, the board said there\n",
+      "was “conflicting evidence.” As for the delay in seeking treatment, the board\n",
+      "noted that it could not clearly blame the officers since DCFS workers were also\n",
+      "involved in the boy’s care.\n",
+      "\n",
+      "In February 2009, Vaval adopted the boy and the two other foster children.\n",
+      "\n",
+      "On April 29 of that year, the boy got into trouble at school and brought a note\n",
+      "home for either officer to sign. The next day, he came to school with bruising\n",
+      "on his arms and legs, the board reported. The boy told school staff that the\n",
+      "officers had “whipped” him. The school’s social worker contacted DCFS to report\n",
+      "possible child abuse.\n",
+      "\n",
+      "A DCFS investigator interviewed the boy, who told her Vaval whipped him on the\n",
+      "hands and hurt his arm as he tried to protect himself. The boy also told the\n",
+      "investigator that Foster beat him on his buttocks with his pants down, and that\n",
+      "he used his hands to try and protect himself.\n",
+      "\n",
+      "** [ [Most read] Financial adviser accused of swindling one of the ‘Dixmoor 5’ out of settlement money from infamous wrongful conviction case » ][3] **\n",
+      "\n",
+      "The two other adopted children corroborated his account. During a June hearing,\n",
+      "the investigator testified that Vaval initially denied any physical contact with\n",
+      "the boy. She claimed the boy sucked on his arms to create bruising and injured\n",
+      "his legs by rubbing them on the rail of his bunk bed.\n",
+      "\n",
+      "Advertisement\n",
+      "\n",
+      "The investigator, however, saw no way the rails of the boy’s bed could injure\n",
+      "him in the way Vaval described, according to the board. Vaval later admitted\n",
+      "whipping the boy with a belt on his hands, while Foster denied hitting him at\n",
+      "all.\n",
+      "\n",
+      "The investigator urged Vaval to take the boy to a doctor. The boy was taken May\n",
+      "1 to an emergency room, where records show bruising on the back of each thigh\n",
+      "and both forearms. The DCFS investigator reached out to the doctor, who examined\n",
+      "the boy and had questions about his injuries. But the doctor never called the\n",
+      "investigator, who could not reach the boy’s therapist. She closed out the case\n",
+      "without indicating child abuse, the board found.\n",
+      "\n",
+      "While a Chicago police detective reported the boy told medical staff his\n",
+      "injuries were self-inflicted, the board found the boy’s “recantation” at the\n",
+      "hospital “meaningless, given the presence of Officer Vaval.”\n",
+      "\n",
+      "The board cited the DCFS investigator’s testimony that she believed Vaval and\n",
+      "Foster caused the boy’s injuries, a finding corroborated by the boy’s account\n",
+      "outside the presence of the two officers and the accounts of the two other\n",
+      "adopted children. The board said it also considered the timing of the injuries\n",
+      "after getting a note from school.\n",
+      "\n",
+      "** [ [Most read] ‘Ooooh, the skulduggery!’: Inside the world of Steve McMichael, still one of the most colorful and beloved characters from the 1985 Bears » ][4] **\n",
+      "\n",
+      "“When the evidence is viewed in its totality, it is clear that Officer Vaval\n",
+      "whipped (the boy) on his hands with a belt and Officer Foster beat him on the\n",
+      "other parts of his body,” the board wrote. “The Board finds that not only did\n",
+      "Officer Vaval physically maltreat (the boy), but she also failed to protect him\n",
+      "from the beating he received from Officer Foster.”\n",
+      "\n",
+      "The board determined that Vaval would never have taken the boy to a doctor\n",
+      "unless told to do so by DCFS.\n",
+      "\n",
+      "In November 2009, Vaval was accused of failing to seek medical treatment after\n",
+      "the boy apparently suffered a seizure and, in another incident, lost\n",
+      "consciousness after hitting his head in the bathroom. At least one of the\n",
+      "officers claimed the boy did not have a seizure and, in the other incident, had\n",
+      "faked passing out.\n",
+      "\n",
+      "“It is apparent to the Board that ... the officers attempted to minimize (the\n",
+      "boy’s) seizure and loss of consciousness,” the report stated.\n",
+      "\n",
+      "The same month, a staffer at the boy’s school again saw bruising on his hands\n",
+      "and reported that he was complaining of pain, according to the board. The staff\n",
+      "reported suspected abuse to DCFS and another investigator took the case.\n",
+      "\n",
+      "** [ [Most read] 3 things we learned at Bears practice, including how wide receiver Anthony Miller is feeling as the Bears gear up for Week 1 » ][5] **\n",
+      "\n",
+      "A Chicago police detective saw bruising on the boy’s right hand, right forearm,\n",
+      "left shoulder, right shoulder blade, back and left thigh, according to the\n",
+      "board. A doctor from La Rabida Children’s Hospital on the South Side examined\n",
+      "the boy and documented the bruising, along with “linear marks” on the back of\n",
+      "his right hip and a fracture of the left arm caused by blunt trauma within the\n",
+      "past week, the board said.\n",
+      "\n",
+      "Latest Breaking News\n",
+      "\n",
+      "  * [ Two Chicago police officers were accused of child abuse. A decade later, they were fired ][6]\n",
+      "\n",
+      "50m\n",
+      "\n",
+      "[ ][6]\n",
+      "\n",
+      "  * [ At the McHenry VFW Queen of Hearts raffle Tuesday night, they won’t stop drawing tickets until there’s a $2.7 million grand prize winner ][7]\n",
+      "\n",
+      "1h\n",
+      "\n",
+      "[\n",
+      "\n",
+      "![At the McHenry VFW Queen of Hearts raffle Tuesday night, they won’t stop\n",
+      "drawing tickets until there’s a $2.7 million grand prize winner][8]\n",
+      "\n",
+      "][7]\n",
+      "\n",
+      "  * [ Alleged gunman in killing of 9-year-old Tyshawn Lee denied bid to represent himself at trial ][9]\n",
+      "\n",
+      "1h\n",
+      "\n",
+      "[ ][9]\n",
+      "\n",
+      "  * [ Tinley Park Post Office evacuated after suspicious backpack found ][10]\n",
+      "\n",
+      "2h\n",
+      "\n",
+      "[\n",
+      "\n",
+      "![Tinley Park Post Office evacuated after suspicious backpack found][8]\n",
+      "\n",
+      "][10]\n",
+      "\n",
+      "  * [ Man, 13-year old girl identified in fatal Round Lake Beach crash ][11]\n",
+      "\n",
+      "2h\n",
+      "\n",
+      "[\n",
+      "\n",
+      "![Man, 13-year old girl identified in fatal Round Lake Beach crash][8]\n",
+      "\n",
+      "][11]\n",
+      "\n",
+      "Advertisement\n",
+      "\n",
+      "DCFS removed the three children from the home shortly after the November\n",
+      "incident.\n",
+      "\n",
+      "In firing Vaval, the board said she showed disregard for the boy’s safety.\n",
+      "“Officer Vaval’s intentional and material false statement about criminal\n",
+      "activity also render her unfit to be a Chicago police officer,” the board wrote.\n",
+      "\n",
+      "As for Foster, the board said she tried to cover up her abuse of the boy by\n",
+      "“repeatedly falsely stating to Chicago police detectives that she did not\n",
+      "inflict any injuries on the child.”\n",
+      "\n",
+      "The officers can appeal their firings to the Cook County Circuit Court.\n",
+      "\n",
+      "   [1]: https://www.chicagotribune.com/business/ct-biz-kraft-heinz-cfo-knopf-\n",
+      "basilio-20190826-tmqpd4gle5dqjfqwwqgsvzqfdm-story.html#nt=interstitial-auto\n",
+      "\n",
+      "   [2]: https://www.chicagotribune.com/sports/cubs/ct-cubs-struggling-\n",
+      "future-20190826-qgw3cfj4dnfdzhw6rti4pwldc4-story.html#nt=interstitial-auto\n",
+      "\n",
+      "   [3]: https://www.chicagotribune.com/news/criminal-justice/ct-financial-\n",
+      "adviser-fraud-dixmoor-five-20190826-zu47xwb3bndtji3zjmeecsypwa-\n",
+      "story.html#nt=interstitial-auto\n",
+      "\n",
+      "   [4]: https://www.chicagotribune.com/sports/bears/ct-bears-100-steve-\n",
+      "mcmichael-1985-super-\n",
+      "bowl-20190826-cv36vnxv2fgerdzvggtf52xpn4-story.html#nt=interstitial-auto\n",
+      "\n",
+      "   [5]: https://www.chicagotribune.com/sports/bears/ct-cb-bears-anthony-miller-\n",
+      "injury-20190826-4f7qte6w3feovkq72ex7p5grku-story.html#nt=interstitial-auto\n",
+      "\n",
+      "   [6]: https://www.chicagotribune.com/news/breaking/ct-chicago-police-officers-\n",
+      "fired-20190827-wyucxtjk7vbohewcfkv73kaifa-story.html#nt=related-content\n",
+      "\n",
+      "   [7]: https://www.chicagotribune.com/news/breaking/ct-mchenry-queen-of-hearts-\n",
+      "draw-down-20190827-s7wslncf2rdphabt34sl2xw3ne-story.html#nt=related-content\n",
+      "\n",
+      "   [8]: /pb/resources/images/tinygif.gif\n",
+      "\n",
+      "   [9]: https://www.chicagotribune.com/news/criminal-justice/ct-tyshawn-lee-\n",
+      "gunman-trial-lawyer-20190827-pxll5kp7x5gsjnep7mklh5yoqq-story.html#nt=related-\n",
+      "content\n",
+      "\n",
+      "   [10]: https://www.chicagotribune.com/suburbs/daily-southtown/ct-sta-tinley-\n",
+      "park-post-office-evacuated-st-0827-20190826-tli64tbo3jh25ijfwdy6necnym-\n",
+      "story.html#nt=related-content\n",
+      "\n",
+      "   [11]: https://www.chicagotribune.com/suburbs/lake-county-news-sun/sports/ct-\n",
+      "lns-fatal-crash-victims-st-0828-20190826-7seym47jyresbadab7wt5ubxju-\n",
+      "story.html#nt=related-content\n"
+     ]
+    }
+   ],
+   "source": [
+    "### See examples that use the relevant words but didn't score highly in CPD_model\n",
+    "### Some definitely look relevant (e.g. article 650870)\n",
+    "relevant_but_zero = df2.loc[(df2['CPD_model']==0) & ((df2['CPD']==0))].sort_values('cop_word_counts', ascending=False)\n",
+    "print(relevant_but_zero.loc[650870, 'title'])\n",
+    "print(relevant_but_zero.loc[650870, 'bodytext'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### Basic relevance score:\n",
+    "### - 50% human tagged \"CPD\"\n",
+    "### - 25% \"CPD_model\"\n",
+    "### - 25% usage of above words\n",
+    "df2['CPD_relevance'] = (  0.5*df2['CPD'] # upweight because it means more\n",
+    "                       + 0.25*df2['CPD_model']\n",
+    "                       + 0.25*(df2['cop_word_counts']/(2*len(cop_words))).clip(upper=1.)\n",
+    "                      )\n",
+    "### 55% have relevance = 0\n",
+    "### \n",
+    "df['relevance_tier'] = 0\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "137183.0 0.4499402332962368\n",
+      "138939.0 0.5500597667037632\n"
+     ]
+    }
+   ],
+   "source": [
+    "### What number/fraction have score > 0?\n",
+    "print(df2.loc[df2['CPD_relevance']>0, 'n_units'].sum(), (df2['CPD_relevance']>0).mean())\n",
+    "### What number/fraction have score = 0?\n",
+    "print(df2.loc[df2['CPD_relevance']==0, 'n_units'].sum(), (df2['CPD_relevance']==0).mean())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([1.3792e+04, 3.8480e+03, 2.5010e+03, 2.5090e+03, 3.3170e+03,\n",
+       "        2.6980e+03, 1.5210e+03, 7.6300e+02, 5.6900e+02, 9.2700e+02,\n",
+       "        4.0000e+00, 4.0000e+00, 6.0000e+00, 2.2000e+01, 4.9000e+01,\n",
+       "        7.6000e+01, 4.4000e+01, 2.3000e+01, 2.5000e+01, 5.0000e+01]),\n",
+       " array([0.0125025 , 0.06187737, 0.11125225, 0.16062712, 0.210002  ,\n",
+       "        0.25937687, 0.30875175, 0.35812662, 0.4075015 , 0.45687637,\n",
+       "        0.50625125, 0.55562612, 0.605001  , 0.65437587, 0.70375075,\n",
+       "        0.75312562, 0.8025005 , 0.85187537, 0.90125025, 0.95062512,\n",
+       "        1.        ]),\n",
+       " <a list of 20 Patch objects>)"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1008x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### About half of scores are 0\n",
+    "### What is the distribution of the nonzero ones?\n",
+    "nonzero_scores = df2.loc[df2['CPD_relevance']>0].sort_values('CPD_relevance', ascending=False)\n",
+    "\n",
+    "f1, ax1 = plt.subplots(1, figsize=[14, 6])\n",
+    "ax1.hist(nonzero_scores['CPD_relevance'], bins=20)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "article_id\n",
+       "631150    0.479269\n",
+       "640134    0.391405\n",
+       "645792    0.339469\n",
+       "613464    0.311011\n",
+       "627917    0.287989\n",
+       "615123    0.271332\n",
+       "610977    0.256025\n",
+       "643117    0.248357\n",
+       "639736    0.231753\n",
+       "612867    0.212001\n",
+       "594955    0.191755\n",
+       "588112    0.172193\n",
+       "651086    0.150870\n",
+       "642016    0.131650\n",
+       "632426    0.114060\n",
+       "588991    0.099931\n",
+       "598392    0.087853\n",
+       "648261    0.071429\n",
+       "636208    0.060964\n",
+       "598422    0.053571\n",
+       "592626    0.045485\n",
+       "604052    0.035714\n",
+       "616186    0.035714\n",
+       "585041    0.032706\n",
+       "647510    0.027053\n",
+       "642052    0.019166\n",
+       "601597    0.017857\n",
+       "586518    0.017857\n",
+       "651778    0.017857\n",
+       "638311    0.017857\n",
+       "617074    0.017857\n",
+       "589721    0.015602\n",
+       "Name: CPD_relevance, dtype: float64"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "### Divide this ~1/5th sized sample into groups of 1000 rows each, in order to get\n",
+    "### sizes needed for bins that would be ~5000 each.\n",
+    "### This ould actually be a bit too big, but you get the general idea\n",
+    "### Bins would have to get progressively smaller as we go down to stay equal in number\n",
+    "nonzero_scores['CPD_relevance'].iloc[[i*1000 for i in range(1, int(np.ceil(nonzero_scores.shape[0]/1000)))]]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "projectname",
+   "language": "python",
+   "name": "projectname"
+  },
+  "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.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From c8fc724b137c74480e5761c625c63d577f3e395f Mon Sep 17 00:00:00 2001
From: RJ Worth <bot.collins@gmail.com>
Date: Mon, 4 Nov 2019 20:58:26 -0600
Subject: [PATCH 06/22] Notebook with research on sentiment evaluation API
 budgeting

---
 lib/notebooks/senteval_budgeting.ipynb | 104 +++++++++++++++----------
 1 file changed, 62 insertions(+), 42 deletions(-)

diff --git a/lib/notebooks/senteval_budgeting.ipynb b/lib/notebooks/senteval_budgeting.ipynb
index 403fa75..655f567 100644
--- a/lib/notebooks/senteval_budgeting.ipynb
+++ b/lib/notebooks/senteval_budgeting.ipynb
@@ -190,18 +190,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
-     "ename": "NameError",
-     "evalue": "name 'units' is not defined",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[0;32m<ipython-input-58-f5476ba5b95a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnew_units\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'n_units'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mdownscale\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnew_units\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0munits\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_units\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdownscale\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
-      "\u001b[0;31mNameError\u001b[0m: name 'units' is not defined"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "276122.0 0.18449151947830678\n"
      ]
     }
    ],
@@ -652,59 +648,83 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 60,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "922.4575973915339"
+      ]
+     },
+     "execution_count": 60,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "5000*downscale"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
        "article_id\n",
-       "631150    0.479269\n",
-       "640134    0.391405\n",
-       "645792    0.339469\n",
-       "613464    0.311011\n",
-       "627917    0.287989\n",
-       "615123    0.271332\n",
-       "610977    0.256025\n",
-       "643117    0.248357\n",
+       "615662    0.485132\n",
+       "652807    0.407189\n",
+       "630258    0.353261\n",
+       "624546    0.320860\n",
+       "608502    0.299458\n",
+       "646388    0.281343\n",
+       "642065    0.266771\n",
+       "595837    0.252939\n",
+       "651855    0.247067\n",
        "639736    0.231753\n",
-       "612867    0.212001\n",
-       "594955    0.191755\n",
-       "588112    0.172193\n",
-       "651086    0.150870\n",
-       "642016    0.131650\n",
-       "632426    0.114060\n",
-       "588991    0.099931\n",
-       "598392    0.087853\n",
+       "649482    0.214238\n",
+       "649597    0.196261\n",
+       "654330    0.178571\n",
+       "598984    0.160714\n",
+       "597207    0.142857\n",
+       "648693    0.125000\n",
+       "617132    0.107143\n",
+       "592013    0.095360\n",
+       "619221    0.086230\n",
        "648261    0.071429\n",
-       "636208    0.060964\n",
-       "598422    0.053571\n",
-       "592626    0.045485\n",
-       "604052    0.035714\n",
-       "616186    0.035714\n",
-       "585041    0.032706\n",
-       "647510    0.027053\n",
-       "642052    0.019166\n",
+       "618711    0.062814\n",
+       "637667    0.053571\n",
+       "589184    0.049998\n",
+       "635322    0.037251\n",
+       "649248    0.035714\n",
+       "643199    0.035714\n",
+       "611136    0.032706\n",
+       "583819    0.025020\n",
+       "603843    0.018614\n",
        "601597    0.017857\n",
-       "586518    0.017857\n",
-       "651778    0.017857\n",
-       "638311    0.017857\n",
-       "617074    0.017857\n",
-       "589721    0.015602\n",
+       "649000    0.017857\n",
+       "582941    0.017857\n",
+       "635029    0.017857\n",
+       "607456    0.017857\n",
+       "616191    0.017857\n",
+       "610175    0.013737\n",
        "Name: CPD_relevance, dtype: float64"
       ]
      },
-     "execution_count": 56,
+     "execution_count": 61,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "### Divide this ~1/5th sized sample into groups of 1000 rows each, in order to get\n",
+    "### Divide this sample into groups of 900 rows each, in order to get\n",
     "### sizes needed for bins that would be ~5000 each.\n",
     "### This ould actually be a bit too big, but you get the general idea\n",
     "### Bins would have to get progressively smaller as we go down to stay equal in number\n",
-    "nonzero_scores['CPD_relevance'].iloc[[i*1000 for i in range(1, int(np.ceil(nonzero_scores.shape[0]/1000)))]]"
+    "nonzero_scores['CPD_relevance'].iloc[[i*900 for i in range(1, int(np.ceil(nonzero_scores.shape[0]/900)))]]"
    ]
   },
   {

From e831faa86b4b08bcc0e0c9c85a5b473ae2049602 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 19:14:10 -0600
Subject: [PATCH 07/22] add imports, bucket

---
 lib/tagnews/__init__.py      | 3 ++-
 lib/tagnews/senteval/eval.py | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/tagnews/__init__.py b/lib/tagnews/__init__.py
index 57e80e0..dc14179 100644
--- a/lib/tagnews/__init__.py
+++ b/lib/tagnews/__init__.py
@@ -5,8 +5,9 @@
 from .geoloc.tag import GeoCoder, get_lat_longs_from_geostrings
 from .utils.load_data import load_data
 from .utils.load_vectorizer import load_glove
+from .senteval.eval import SentimentGoogler
 
-__all__ = [utils, crimetype, CrimeTags, GeoCoder,
+__all__ = [utils, crimetype, CrimeTags, GeoCoder, SentimentGoogler,
            get_lat_longs_from_geostrings, load_data, load_glove]
 
 __version__ = '1.2.4'
diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 3cb9670..0779aa5 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -66,6 +66,8 @@ def is_police_entity(self, entity):
                 return entity
             return False
 
+    def set_bucket_value(self):
+        pass
 
 def pre_process_text(html_text):
     """

From c6ae60f5d4a938242473c0775f6bfbd5bb2f984c Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 19:43:26 -0600
Subject: [PATCH 08/22] bucketing will happen in chicago-justice i think

---
 lib/tagnews/senteval/eval.py         | 6 +++---
 lib/tagnews/senteval/police_words.py | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)
 create mode 100644 lib/tagnews/senteval/police_words.py

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 0779aa5..515747b 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -2,6 +2,8 @@
 from google.cloud.language import enums
 from google.cloud.language import types
 
+from tagnews.senteval import police_words
+
 
 def process_google_result(text):
     document = types.Document(content=text, type=enums.Document.Type.PLAIN_TEXT)
@@ -10,7 +12,7 @@ def process_google_result(text):
     for entity in sentiment.entities:
         clean_entity = "".join(filter(str.isalpha, entity)).lower()
 
-        if clean_entity in ["police", "officer", "cop", "officers", "pigs"]:
+        if clean_entity in police_words:
 
             for mention in entity.mentions:
                 return mention.sentiment.score
@@ -66,8 +68,6 @@ def is_police_entity(self, entity):
                 return entity
             return False
 
-    def set_bucket_value(self):
-        pass
 
 def pre_process_text(html_text):
     """
diff --git a/lib/tagnews/senteval/police_words.py b/lib/tagnews/senteval/police_words.py
new file mode 100644
index 0000000..1e37a63
--- /dev/null
+++ b/lib/tagnews/senteval/police_words.py
@@ -0,0 +1 @@
+police_words = ["police", "officer", "cop", "officers", "pigs"]
\ No newline at end of file

From 89287f5788f80a4bd6004c25d84c31f0d5ec4e14 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 19:47:16 -0600
Subject: [PATCH 09/22] police words in separate file

---
 lib/tagnews/senteval/eval.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 515747b..485d81a 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -21,6 +21,7 @@ def process_google_result(text):
 class SentimentGoogler:
     def __init__(self):
         self.client = self.connect_to_client()
+        self.polce_words = police_words
 
     def run(self, doc_text):
         sentiment_ = self.call_api(doc_text)
@@ -61,10 +62,10 @@ def is_police_entity(self, entity):
             "pigs",
             "policeofficer",
         ]
-        if entity in possible_responses:
+        if entity in self.police_words:
             return entity
         for mention in entity.mentions:
-            if pre_process_text(mention.text.content) in possible_responses:
+            if pre_process_text(mention.text.content) in self.police_words:
                 return entity
             return False
 

From f4c2e3669de4a8ed00df698a895d954d9c158952 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 19:47:34 -0600
Subject: [PATCH 10/22] unused lines

---
 lib/tagnews/senteval/eval.py | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 485d81a..af98988 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -54,14 +54,6 @@ def call_api(self, doc_text):
         return sentiment
 
     def is_police_entity(self, entity):
-        possible_responses = [
-            "police",
-            "officer",
-            "cop",
-            "officers",
-            "pigs",
-            "policeofficer",
-        ]
         if entity in self.police_words:
             return entity
         for mention in entity.mentions:

From ec0bade713d060d482a4716eb50ff773e106e3c2 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 19:48:01 -0600
Subject: [PATCH 11/22] spell police

---
 lib/tagnews/senteval/eval.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index af98988..f2225a5 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -21,7 +21,7 @@ def process_google_result(text):
 class SentimentGoogler:
     def __init__(self):
         self.client = self.connect_to_client()
-        self.polce_words = police_words
+        self.police_words = police_words
 
     def run(self, doc_text):
         sentiment_ = self.call_api(doc_text)

From c00157a9484724121c1dd0decce49c81455a4bc5 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 20:19:55 -0600
Subject: [PATCH 12/22] actually in this project

---
 lib/tagnews/senteval/eval.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index f2225a5..3bda9b5 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -61,6 +61,11 @@ def is_police_entity(self, entity):
                 return entity
             return False
 
+    def extract_google_priority_bin(article, cpd_model_val, cpd_val):
+        cop_words = sent_evaller().police_words
+        cop_word_counts = sum([article.count(substr) for substr in cop_words])
+        score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * max(cop_word_counts / (2 * len(cop_words)), 1.)
+
 
 def pre_process_text(html_text):
     """

From e7c4ddec1ecab20020645dea399afc464df734c1 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 20:20:29 -0600
Subject: [PATCH 13/22] min, score

---
 lib/tagnews/senteval/eval.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 3bda9b5..8bd41cb 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -64,7 +64,8 @@ def is_police_entity(self, entity):
     def extract_google_priority_bin(article, cpd_model_val, cpd_val):
         cop_words = sent_evaller().police_words
         cop_word_counts = sum([article.count(substr) for substr in cop_words])
-        score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * max(cop_word_counts / (2 * len(cop_words)), 1.)
+        score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * min(cop_word_counts / (2 * len(cop_words)), 1.)
+        return score
 
 
 def pre_process_text(html_text):

From 74dcf9402f29b783b63478c251075818e40258da Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 20:21:15 -0600
Subject: [PATCH 14/22] self police words

---
 lib/tagnews/senteval/eval.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 8bd41cb..0f79e05 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -61,10 +61,9 @@ def is_police_entity(self, entity):
                 return entity
             return False
 
-    def extract_google_priority_bin(article, cpd_model_val, cpd_val):
-        cop_words = sent_evaller().police_words
-        cop_word_counts = sum([article.count(substr) for substr in cop_words])
-        score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * min(cop_word_counts / (2 * len(cop_words)), 1.)
+    def extract_google_priority_bin(self, article, cpd_model_val, cpd_val):
+        cop_word_counts = sum([article.count(substr) for substr in self.police_words])
+        score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * min(cop_word_counts / (2 * len(self.police_words)), 1.)
         return score
 
 

From 022b29d3478db9c97a70a35f14fd74c56d72868b Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 20:35:06 -0600
Subject: [PATCH 15/22] binning!

---
 lib/tagnews/senteval/eval.py         | 5 +++--
 lib/tagnews/senteval/police_words.py | 4 +++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 0f79e05..5d05171 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -2,7 +2,7 @@
 from google.cloud.language import enums
 from google.cloud.language import types
 
-from tagnews.senteval import police_words
+from tagnews.senteval import police_words, bins
 
 
 def process_google_result(text):
@@ -64,7 +64,8 @@ def is_police_entity(self, entity):
     def extract_google_priority_bin(self, article, cpd_model_val, cpd_val):
         cop_word_counts = sum([article.count(substr) for substr in self.police_words])
         score = 0.5 * cpd_val + 0.25 * cpd_model_val + 0.25 * min(cop_word_counts / (2 * len(self.police_words)), 1.)
-        return score
+        bin = [bin for bin, bin_max_val in enumerate(bins) if bin_max_val > score][0]
+        return bin
 
 
 def pre_process_text(html_text):
diff --git a/lib/tagnews/senteval/police_words.py b/lib/tagnews/senteval/police_words.py
index 1e37a63..cd48183 100644
--- a/lib/tagnews/senteval/police_words.py
+++ b/lib/tagnews/senteval/police_words.py
@@ -1 +1,3 @@
-police_words = ["police", "officer", "cop", "officers", "pigs"]
\ No newline at end of file
+police_words = ["police", "officer", "cop", "officers", "pigs"]
+
+bins = [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1]
\ No newline at end of file

From 710117fbe986907d3ba17f6c6e69e24d91c4926b Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 5 Nov 2019 20:40:10 -0600
Subject: [PATCH 16/22] i still don't understand how these imports work

---
 lib/tagnews/__init__.py              | 3 ++-
 lib/tagnews/senteval/__init__.py     | 4 ++--
 lib/tagnews/senteval/eval.py         | 6 +++---
 lib/tagnews/senteval/police_words.py | 2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/lib/tagnews/__init__.py b/lib/tagnews/__init__.py
index dc14179..c90d3ca 100644
--- a/lib/tagnews/__init__.py
+++ b/lib/tagnews/__init__.py
@@ -6,8 +6,9 @@
 from .utils.load_data import load_data
 from .utils.load_vectorizer import load_glove
 from .senteval.eval import SentimentGoogler
+from .senteval.police_words import police_words_list, bins
 
 __all__ = [utils, crimetype, CrimeTags, GeoCoder, SentimentGoogler,
-           get_lat_longs_from_geostrings, load_data, load_glove]
+           get_lat_longs_from_geostrings, load_data, load_glove, police_words_list, bins]
 
 __version__ = '1.2.4'
diff --git a/lib/tagnews/senteval/__init__.py b/lib/tagnews/senteval/__init__.py
index 7b13ead..3611eaa 100644
--- a/lib/tagnews/senteval/__init__.py
+++ b/lib/tagnews/senteval/__init__.py
@@ -1,3 +1,3 @@
-from . import eval
+from . import eval, police_words
 
-__all__ = [eval]
+__all__ = [eval, police_words]
diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 5d05171..6eb3b3b 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -2,7 +2,7 @@
 from google.cloud.language import enums
 from google.cloud.language import types
 
-from tagnews.senteval import police_words, bins
+from tagnews.senteval.police_words import police_words_list, bins
 
 
 def process_google_result(text):
@@ -12,7 +12,7 @@ def process_google_result(text):
     for entity in sentiment.entities:
         clean_entity = "".join(filter(str.isalpha, entity)).lower()
 
-        if clean_entity in police_words:
+        if clean_entity in police_words_list:
 
             for mention in entity.mentions:
                 return mention.sentiment.score
@@ -21,7 +21,7 @@ def process_google_result(text):
 class SentimentGoogler:
     def __init__(self):
         self.client = self.connect_to_client()
-        self.police_words = police_words
+        self.police_words = police_words_list
 
     def run(self, doc_text):
         sentiment_ = self.call_api(doc_text)
diff --git a/lib/tagnews/senteval/police_words.py b/lib/tagnews/senteval/police_words.py
index cd48183..93e770e 100644
--- a/lib/tagnews/senteval/police_words.py
+++ b/lib/tagnews/senteval/police_words.py
@@ -1,3 +1,3 @@
-police_words = ["police", "officer", "cop", "officers", "pigs"]
+police_words_list = ["police", "officer", "cop", "officers", "pigs"]
 
 bins = [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1]
\ No newline at end of file

From 7aaf9777e8187e7c6d339b0c6fc81b9a3eae663a Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 3 Dec 2019 20:06:09 -0600
Subject: [PATCH 17/22] pip install google cloud

---
 .travis.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.travis.yml b/.travis.yml
index 9e8d9b5..3aee5ba 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -30,6 +30,7 @@ install:
   - pip install pytest
   - pip install pytest-cov
   - pip install requests
+  - pip install google-cloud-language
   - |
     if [[ $FLAKE8 ]]; then
       pip install flake8

From d05806c8d52508f82226600d3f25778c79d684a0 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 3 Dec 2019 20:28:53 -0600
Subject: [PATCH 18/22] unused function

---
 lib/tagnews/senteval/eval.py | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 6eb3b3b..1d790df 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -5,17 +5,17 @@
 from tagnews.senteval.police_words import police_words_list, bins
 
 
-def process_google_result(text):
-    document = types.Document(content=text, type=enums.Document.Type.PLAIN_TEXT)
-    sentiment = client.analyze_entity_sentiment(document=document)
-
-    for entity in sentiment.entities:
-        clean_entity = "".join(filter(str.isalpha, entity)).lower()
-
-        if clean_entity in police_words_list:
-
-            for mention in entity.mentions:
-                return mention.sentiment.score
+# def process_google_result(text):
+#     document = types.Document(content=text, type=enums.Document.Type.PLAIN_TEXT)
+#     sentiment = client.analyze_entity_sentiment(document=document)
+#
+#     for entity in sentiment.entities:
+#         clean_entity = "".join(filter(str.isalpha, entity)).lower()
+#
+#         if clean_entity in police_words_list:
+#
+#             for mention in entity.mentions:
+#                 return mention.sentiment.score
 
 
 class SentimentGoogler:

From 8d0b296fe5137dfcd2fbbce4dddbee562c2981bd Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 7 Jan 2020 20:46:50 -0600
Subject: [PATCH 19/22] num bins

---
 lib/tagnews/senteval/eval.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/tagnews/senteval/eval.py b/lib/tagnews/senteval/eval.py
index 1d790df..e8b0af5 100644
--- a/lib/tagnews/senteval/eval.py
+++ b/lib/tagnews/senteval/eval.py
@@ -22,6 +22,8 @@ class SentimentGoogler:
     def __init__(self):
         self.client = self.connect_to_client()
         self.police_words = police_words_list
+        self.bins = bins[::-1] # reversed because we start with lower numbered bins
+        self.num_bins = len(bins)
 
     def run(self, doc_text):
         sentiment_ = self.call_api(doc_text)

From 03d580a7c64a3f0a88f270bf7f8dbf360095b301 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 14 Jan 2020 19:59:33 -0600
Subject: [PATCH 20/22] sentiment evaluation v0

---
 lib/tagnews/__init__.py              |   2 +-
 lib/tagnews/senteval/police_words.py |   3 +-
 lib/tagnews/utils/load_data.py       | 474 ++++++++++++++-------------
 lib/tagnews/utils/load_vectorizer.py |   2 +-
 setup.py                             |   3 +-
 5 files changed, 259 insertions(+), 225 deletions(-)

diff --git a/lib/tagnews/__init__.py b/lib/tagnews/__init__.py
index c90d3ca..93596d8 100644
--- a/lib/tagnews/__init__.py
+++ b/lib/tagnews/__init__.py
@@ -11,4 +11,4 @@
 __all__ = [utils, crimetype, CrimeTags, GeoCoder, SentimentGoogler,
            get_lat_longs_from_geostrings, load_data, load_glove, police_words_list, bins]
 
-__version__ = '1.2.4'
+__version__ = '1.2.5'
diff --git a/lib/tagnews/senteval/police_words.py b/lib/tagnews/senteval/police_words.py
index 93e770e..47d9c9e 100644
--- a/lib/tagnews/senteval/police_words.py
+++ b/lib/tagnews/senteval/police_words.py
@@ -1,3 +1,4 @@
 police_words_list = ["police", "officer", "cop", "officers", "pigs"]
 
-bins = [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1]
\ No newline at end of file
+bins = [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1]
+num_bins = len(bins)
\ No newline at end of file
diff --git a/lib/tagnews/utils/load_data.py b/lib/tagnews/utils/load_data.py
index 70eecdc..1112025 100644
--- a/lib/tagnews/utils/load_data.py
+++ b/lib/tagnews/utils/load_data.py
@@ -16,7 +16,9 @@
 # Caution! Modifying this in code will have no effect since the
 # default arguments are populated with this reference at creation
 # time, so post-hoc modifications will do nothing.
-__data_folder = os.path.join(os.path.split(__file__)[0], '..', 'data')
+
+# __data_folder = os.path.join(os.path.split(__file__)[0], "..", "data")
+__data_folder = "/Users/joshherzberg/Documents/chihack/article-tagging/lib/tagnews/data/cjp_tables/"
 
 
 def clean_string(s):
@@ -25,7 +27,7 @@ def clean_string(s):
     Replaces newlines with spaces.
     """
 
-    return s.replace('\r', '').replace('\n', ' ').replace('\xa0', ' ').strip()
+    return s.replace("\r", "").replace("\n", " ").replace("\xa0", " ").strip()
 
 
 def load_articles(data_folder=__data_folder, nrows=None):
@@ -33,109 +35,137 @@ def load_articles(data_folder=__data_folder, nrows=None):
     Loads the articles CSV. Can optionally only load the first
     `nrows` number of rows.
     """
-    column_names = ['id',
-                    'feedname',
-                    'url',
-                    'orig_html',
-                    'title',
-                    'bodytext',
-                    'relevant',
-                    'created',
-                    'last_modified',
-                    'news_source_id',
-                    'author']
-
-    return pd.read_csv(os.path.join(data_folder,
-                                    'newsarticles_article.csv'),
-                       header=None,
-                       names=column_names,
-                       nrows=nrows,
-                       dtype={'orig_html': str, 'author': str})
+    column_names = [
+        "id",
+        "feedname",
+        "url",
+        "orig_html",
+        "title",
+        "bodytext",
+        "relevant",
+        "created",
+        "last_modified",
+        "news_source_id",
+        "author",
+    ]
+
+    return pd.read_csv(
+        os.path.join(data_folder, "newsarticles_article.csv.gz"),
+        header=None,
+        names=column_names,
+        nrows=nrows,
+        dtype={"orig_html": str, "author": str},
+        compression="gzip",
+    )
 
 
 def load_taggings(data_folder=__data_folder):
     """Loads the type-of-crime human tagging of the articles."""
-    uc_column_names = ['id', 'date', 'relevant', 'article_id',
-                       'user_id', 'locations', 'sentiment']
-
-    uc = pd.read_csv(os.path.join(data_folder,
-                                  'newsarticles_usercoding.csv'),
-                     header=None,
-                     names=uc_column_names)
+    uc_column_names = [
+        "id",
+        "date",
+        "relevant",
+        "article_id",
+        "user_id",
+        "locations",
+        "sentiment",
+    ]
+
+    uc = pd.read_csv(
+        os.path.join(data_folder, "newsarticles_usercoding.csv.gz"),
+        header=None,
+        names=uc_column_names,
+        compression="gzip",
+    )
 
-    uc.set_index('id', drop=True, inplace=True)
+    uc.set_index("id", drop=True, inplace=True)
 
-    uc_tags_column_names = ['id', 'usercoding_id', 'category_id']
+    uc_tags_column_names = ["id", "usercoding_id", "category_id"]
 
     uc_tags = pd.read_csv(
-        os.path.join(data_folder, 'newsarticles_usercoding_categories.csv'),
+        os.path.join(data_folder, "newsarticles_usercoding_categories.csv.gz"),
         header=None,
-        names=uc_tags_column_names
+        names=uc_tags_column_names,
+        compression="gzip",
     )
-    uc_tags.set_index('usercoding_id', drop=True, inplace=True)
+    uc_tags.set_index("usercoding_id", drop=True, inplace=True)
 
-    uc_tags['article_id'] = uc.loc[uc_tags.index, 'article_id']
+    uc_tags["article_id"] = uc.loc[uc_tags.index, "article_id"]
     return uc_tags
 
 
 def load_model_categories(data_folder=__data_folder):
-    tcr_names = ['id', 'relevance', 'category_id', 'coding_id']
-    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id',
-                'sentiment']
+    tcr_names = ["id", "relevance", "category_id", "coding_id"]
+    tc_names = ["id", "date", "model_info", "relevance", "article_id", "sentiment"]
 
     tcr = pd.read_csv(
-        os.path.join(data_folder, 'newsarticles_trainedcategoryrelevance.csv'),
-        names=tcr_names
+        os.path.join(data_folder, "newsarticles_trainedcategoryrelevance.csv.gz"),
+        names=tcr_names,
+        compression="gzip"
     )
     tc = pd.read_csv(
-        os.path.join(data_folder, 'newsarticles_trainedcoding.csv'),
-        names=tc_names
-    ).set_index('id', drop=True)
-    tcr['article_id'] = tc.loc[tcr['coding_id']]['article_id'].values
+        os.path.join(data_folder, "newsarticles_trainedcoding.csv.gz"), names=tc_names, compression="gzip"
+    ).set_index("id", drop=True)
+    tcr["article_id"] = tc.loc[tcr["coding_id"]]["article_id"].values
     return tcr
 
 
 def load_model_locations(data_folder=__data_folder):
-    tl_names = ['id', 'text', 'latitude', 'longitude', 'coding_id',
-                'confidence', 'neighborhood']
-    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id',
-                'sentiment']
+    tl_names = [
+        "id",
+        "text",
+        "latitude",
+        "longitude",
+        "coding_id",
+        "confidence",
+        "neighborhood",
+    ]
+    tc_names = ["id", "date", "model_info", "relevance", "article_id", "sentiment"]
 
     tl = pd.read_csv(
-        os.path.join(data_folder, 'newsarticles_trainedlocation.csv'),
-        names=tl_names
+        os.path.join(data_folder, "newsarticles_trainedlocation.csv.gz"), names=tl_names, compression="gzip"
     )
     tc = pd.read_csv(
-        os.path.join(data_folder, 'newsarticles_trainedcoding.csv'),
-        names=tc_names
-    ).set_index('id', drop=True)
-    tl['article_id'] = tc.loc[tl['coding_id']]['article_id'].values
+        os.path.join(data_folder, "newsarticles_trainedcoding.csv.gz"), names=tc_names, compression="gzip"
+    ).set_index("id", drop=True)
+    tl["article_id"] = tc.loc[tl["coding_id"]]["article_id"].values
     return tl
 
 
 def load_locations(data_folder=__data_folder):
     """Load the human-extracted locations from the articles."""
-    uc_column_names = ['id', 'date', 'relevant', 'article_id',
-                       'user_id', 'locations', 'sentiment']
-
-    uc = pd.read_csv(os.path.join(data_folder,
-                                  'newsarticles_usercoding.csv'),
-                     header=None,
-                     names=uc_column_names)
+    uc_column_names = [
+        "id",
+        "date",
+        "relevant",
+        "article_id",
+        "user_id",
+        "locations",
+        "sentiment",
+    ]
+
+    uc = pd.read_csv(
+        os.path.join(data_folder, "newsarticles_usercoding.csv.gz"),
+        header=None,
+        names=uc_column_names,
+        compression="gzip"
+    )
 
-    uc['locations'] = uc['locations'].apply(lambda x: json.loads(x))
+    uc["locations"] = uc["locations"].apply(lambda x: json.loads(x))
 
     return uc
 
 
 def load_categories(data_folder=__data_folder):
     """Loads the mapping of id to names/abbrevations of categories"""
-    column_names = ['id', 'category_name', 'abbreviation', 'created',
-                    'active', 'kind']
+    column_names = ["id", "category_name", "abbreviation", "created", "active", "kind"]
 
-    return pd.read_csv(os.path.join(data_folder, 'newsarticles_category.csv'),
-                       header=None,
-                       names=column_names)
+    return pd.read_csv(
+        os.path.join(data_folder, "newsarticles_category.csv.gz"),
+        header=None,
+        names=column_names,
+        compression="gzip"
+    )
 
 
 def load_data(data_folder=__data_folder, nrows=None):
@@ -154,33 +184,38 @@ def load_data(data_folder=__data_folder, nrows=None):
     """
 
     df = load_articles(data_folder=data_folder, nrows=nrows)
-    df['relevant'] = df['relevant'] == 't'
-    df.rename(columns={'id': 'article_id'}, inplace=True)
-    df.set_index('article_id', drop=True, inplace=True)
+    df["relevant"] = df["relevant"] == "t"
+    df.rename(columns={"id": "article_id"}, inplace=True)
+    df.set_index("article_id", drop=True, inplace=True)
     # hopefully this will save some memory/space, can add back if needed
-    del(df['orig_html'])
+    del (df["orig_html"])
 
     tags_df = load_taggings(data_folder)
     # will help cacheing
-    tags_df.sort_values(by='article_id', inplace=True)
-    tags_df = tags_df.loc[tags_df['article_id'].isin(
-        df.index.intersection(tags_df['article_id']))]
+    tags_df.sort_values(by="article_id", inplace=True)
+    tags_df = tags_df.loc[
+        tags_df["article_id"].isin(df.index.intersection(tags_df["article_id"]))
+    ]
 
     locs_df = load_locations(data_folder)
-    locs_df.sort_values(by='article_id', inplace=True)
-    locs_df = locs_df.loc[locs_df['article_id'].isin(
-        df.index.intersection(locs_df['article_id']))]
+    locs_df.sort_values(by="article_id", inplace=True)
+    locs_df = locs_df.loc[
+        locs_df["article_id"].isin(df.index.intersection(locs_df["article_id"]))
+    ]
 
     model_tags_df = load_model_categories(data_folder)
     # will help cacheing
-    model_tags_df.sort_values(by='article_id', inplace=True)
-    model_tags_df = model_tags_df.loc[model_tags_df['article_id'].isin(
-        df.index.intersection(model_tags_df['article_id']))]
+    model_tags_df.sort_values(by="article_id", inplace=True)
+    model_tags_df = model_tags_df.loc[
+        model_tags_df["article_id"].isin(
+            df.index.intersection(model_tags_df["article_id"])
+        )
+    ]
 
     # init with empty lists
-    df['locations'] = np.empty([df.shape[0], 0]).tolist()
-    loc_article_ids = locs_df['article_id'].values
-    df.loc[loc_article_ids, 'locations'] = locs_df['locations'].values
+    df["locations"] = np.empty([df.shape[0], 0]).tolist()
+    loc_article_ids = locs_df["article_id"].values
+    df.loc[loc_article_ids, "locations"] = locs_df["locations"].values
 
     def find_loc_in_string(locs, string):
         """
@@ -200,12 +235,12 @@ def find_loc_in_string(locs, string):
         """
 
         for i, loc in enumerate(locs):
-            loc_txt = loc['text']
+            loc_txt = loc["text"]
 
             loc_txt = clean_string(loc_txt)
             string = clean_string(string)
 
-            loc['cleaned text'] = loc_txt
+            loc["cleaned text"] = loc_txt
 
             spans = [x.span() for x in re.finditer(re.escape(loc_txt), string)]
             if spans:
@@ -213,53 +248,55 @@ def find_loc_in_string(locs, string):
                 # spans don't line up perfectly we can't know which one is the
                 # "correct" one. Best we can do is find the python span closest
                 # to the expected javascript span.
-                closest = np.argmin(np.abs(
-                    np.array([x[0] for x in spans]) - loc['start']
-                ))
-                loc['cleaned span'] = spans[closest]
+                closest = np.argmin(
+                    np.abs(np.array([x[0] for x in spans]) - loc["start"])
+                )
+                loc["cleaned span"] = spans[closest]
 
             locs[i] = loc
 
         return locs
 
-    df['locations'] = df.apply(
-        lambda r: find_loc_in_string(r['locations'], r['bodytext']),
-        axis=1
+    df["locations"] = df.apply(
+        lambda r: find_loc_in_string(r["locations"], r["bodytext"]), axis=1
     )
 
-    num_no_match = df['locations'].apply(
-        lambda locs: any([('cleaned span' not in loc) for loc in locs])
-    ).sum()
+    num_no_match = (
+        df["locations"]
+        .apply(lambda locs: any([("cleaned span" not in loc) for loc in locs]))
+        .sum()
+    )
     if num_no_match:
-        warnings.warn(('{} location strings were not found in'
-                       ' the bodytext.').format(num_no_match),
-                      RuntimeWarning)
+        warnings.warn(
+            ("{} location strings were not found in" " the bodytext.").format(
+                num_no_match
+            ),
+            RuntimeWarning,
+        )
 
     model_locations_df = load_model_locations(data_folder)
-    model_locations_df = model_locations_df.set_index('article_id')
-    model_locations_gb = model_locations_df.groupby('article_id')
-    model_locations_text = model_locations_gb['text'].apply(list)
-    df['model_location_text'] = model_locations_text
+    model_locations_df = model_locations_df.set_index("article_id")
+    model_locations_gb = model_locations_df.groupby("article_id")
+    model_locations_text = model_locations_gb["text"].apply(list)
+    df["model_location_text"] = model_locations_text
 
     categories_df = load_categories(data_folder)
-    categories_df.set_index('id', drop=True, inplace=True)
+    categories_df.set_index("id", drop=True, inplace=True)
 
     # tags_df['category_id'] = tags_df['category_id'].astype(str)
-    tags_df['category_abbreviation'] = (categories_df
-                                        ['abbreviation']
-                                        [tags_df['category_id']]
-                                        .values)
-    model_tags_df['category_abbreviation'] = (categories_df
-                                              ['abbreviation']
-                                              [model_tags_df['category_id']]
-                                              .values)
-
-    if np.setdiff1d(tags_df['article_id'].values, df.index.values).size:
-        warnings.warn('Tags were found for article IDs that do not exist.',
-                      RuntimeWarning)
-
-    def update_df_with_categories(article_ids, cat_abbreviations, vals,
-                                  is_model):
+    tags_df["category_abbreviation"] = categories_df["abbreviation"][
+        tags_df["category_id"]
+    ].values
+    model_tags_df["category_abbreviation"] = categories_df["abbreviation"][
+        model_tags_df["category_id"]
+    ].values
+
+    if np.setdiff1d(tags_df["article_id"].values, df.index.values).size:
+        warnings.warn(
+            "Tags were found for article IDs that do not exist.", RuntimeWarning
+        )
+
+    def update_df_with_categories(article_ids, cat_abbreviations, vals, is_model):
         # for some reason, some articles that are tagged don't show up
         # in the articles CSV. filter those out.
         existing_ids_filter = np.isin(article_ids, df.index.values)
@@ -269,37 +306,36 @@ def update_df_with_categories(article_ids, cat_abbreviations, vals,
         vals = vals[existing_ids_filter]
 
         for i in range(categories_df.shape[0]):
-            cat_name = categories_df.loc[i+1, 'abbreviation']
+            cat_name = categories_df.loc[i + 1, "abbreviation"]
             if is_model:
-                cat_name += '_model'
+                cat_name += "_model"
             df[cat_name] = 0
             if not is_model:
-                df[cat_name] = df[cat_name].astype('int8')
+                df[cat_name] = df[cat_name].astype("int8")
             matches = cat_abbreviations == cat_name
             if not matches.sum():
                 continue
             df.loc[article_ids[matches], cat_name] = vals[matches]
 
     update_df_with_categories(
-        model_tags_df['article_id'].values,
-        model_tags_df['category_abbreviation'].values + '_model',
-        model_tags_df['relevance'].values,
-        is_model=True
+        model_tags_df["article_id"].values,
+        model_tags_df["category_abbreviation"].values + "_model",
+        model_tags_df["relevance"].values,
+        is_model=True,
     )
     update_df_with_categories(
-        tags_df['article_id'].values,
-        tags_df['category_abbreviation'].values,
-        np.ones((tags_df['article_id'].values.shape), dtype='int8'),
-        is_model=False
+        tags_df["article_id"].values,
+        tags_df["category_abbreviation"].values,
+        np.ones((tags_df["article_id"].values.shape), dtype="int8"),
+        is_model=False,
     )
 
-    df.loc[df['bodytext'].isnull(), 'bodytext'] = ''
+    df.loc[df["bodytext"].isnull(), "bodytext"] = ""
 
     return df
 
 
-def subsample_and_resave(out_folder, n=5, input_folder=__data_folder,
-                         random_seed=5):
+def subsample_and_resave(out_folder, n=5, input_folder=__data_folder, random_seed=5):
     """
     Subsamples the CSV data files so that we have at least
     `n` articles from each type-of-crime tag as determined
@@ -323,120 +359,116 @@ def subsample_and_resave(out_folder, n=5, input_folder=__data_folder,
     out_folder = str(Path(out_folder).expanduser().absolute())
     input_folder = str(Path(input_folder).expanduser().absolute())
     if out_folder == input_folder:
-        raise RuntimeError('out_folder cannot match input_folder.')
+        raise RuntimeError("out_folder cannot match input_folder.")
 
     random_state = np.random.RandomState(random_seed)
 
     df = load_data(input_folder)
     chosen_indexes = []
-    for crime_type in df.loc[:, 'OEMC':].columns:
+    for crime_type in df.loc[:, "OEMC":].columns:
         is_type = df[crime_type].astype(bool)
         n_samps = min(n, is_type.sum())
-        chosen_indexes += (df.loc[is_type, :]
-                           .sample(n_samps, random_state=random_state)
-                           .index
-                           .tolist())
+        chosen_indexes += (
+            df.loc[is_type, :].sample(n_samps, random_state=random_state).index.tolist()
+        )
     del df
 
     chosen_indexes = sorted(list(set(chosen_indexes)))
 
     # newsarticles_article.csv
     articles_df = load_articles(input_folder)
-    sample = (articles_df
-              .reset_index()
-              .set_index('id')
-              .loc[chosen_indexes, 'index'])
+    sample = articles_df.reset_index().set_index("id").loc[chosen_indexes, "index"]
     articles_df = articles_df.loc[sample, :]
     # garble garble
-    articles_df['bodytext'] = articles_df['bodytext'].astype(str).apply(
-        lambda x: codecs.encode(x, 'rot-13')
+    articles_df["bodytext"] = (
+        articles_df["bodytext"].astype(str).apply(lambda x: codecs.encode(x, "rot-13"))
+    )
+    articles_df.to_csv(
+        os.path.join(out_folder, "newsarticles_article.csv"), header=None, index=False
     )
-    articles_df.to_csv(os.path.join(out_folder, 'newsarticles_article.csv'),
-                       header=None, index=False)
     del articles_df
 
     # newsarticles_category.csv
-    shutil.copyfile(os.path.join(input_folder, 'newsarticles_category.csv'),
-                    os.path.join(out_folder, 'newsarticles_category.csv'))
+    shutil.copyfile(
+        os.path.join(input_folder, "newsarticles_category.csv"),
+        os.path.join(out_folder, "newsarticles_category.csv"),
+    )
 
     # newsarticles_usercoding.csv
-    uc_column_names = ['id', 'date', 'relevant',
-                       'article_id', 'user_id', 'locations']
+    uc_column_names = ["id", "date", "relevant", "article_id", "user_id", "locations"]
 
-    uc_df = pd.read_csv(os.path.join(input_folder,
-                                     'newsarticles_usercoding.csv'),
-                        header=None,
-                        names=uc_column_names)
+    uc_df = pd.read_csv(
+        os.path.join(input_folder, "newsarticles_usercoding.csv"),
+        header=None,
+        names=uc_column_names,
+    )
 
-    sample = np.where(uc_df['article_id'].isin(chosen_indexes))[0]
+    sample = np.where(uc_df["article_id"].isin(chosen_indexes))[0]
     uc_df.loc[sample, :].to_csv(
-        os.path.join(out_folder, 'newsarticles_usercoding.csv'),
-        header=None, index=False
+        os.path.join(out_folder, "newsarticles_usercoding.csv"),
+        header=None,
+        index=False,
     )
 
-    uc_tags_column_names = ['id', 'usercoding_id', 'category_id']
+    uc_tags_column_names = ["id", "usercoding_id", "category_id"]
 
     # newsarticles_usercoding_categories.csv
     uc_tags_df = pd.read_csv(
-        os.path.join(input_folder,
-                     'newsarticles_usercoding_categories.csv'),
+        os.path.join(input_folder, "newsarticles_usercoding_categories.csv"),
         header=None,
         names=uc_tags_column_names,
-        dtype={'id': int, 'usercoding_id': int, 'category_id': int}
+        dtype={"id": int, "usercoding_id": int, "category_id": int},
     )
-    sample = np.where(uc_df
-                      .set_index('id')
-                      .loc[uc_tags_df['usercoding_id'], 'article_id']
-                      .isin(chosen_indexes)
-                      )[0]
+    sample = np.where(
+        uc_df.set_index("id")
+        .loc[uc_tags_df["usercoding_id"], "article_id"]
+        .isin(chosen_indexes)
+    )[0]
     uc_tags_df = uc_tags_df.loc[sample, :]
     uc_tags_df.to_csv(
-        os.path.join(out_folder, 'newsarticles_usercoding_categories.csv'),
-        header=None, index=False
+        os.path.join(out_folder, "newsarticles_usercoding_categories.csv"),
+        header=None,
+        index=False,
     )
 
     # newsarticles_trainedcoding
-    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id']
-    tc = pd.read_csv(
-        'tagnews/data/newsarticles_trainedcoding.csv',
-        names=tc_names
-    )
-    tc = tc.loc[tc['article_id'].isin(chosen_indexes)]
+    tc_names = ["id", "date", "model_info", "relevance", "article_id"]
+    tc = pd.read_csv("tagnews/data/newsarticles_trainedcoding.csv", names=tc_names)
+    tc = tc.loc[tc["article_id"].isin(chosen_indexes)]
     tc.to_csv(
-        os.path.join(out_folder, 'newsarticles_trainedcoding.csv'),
-        header=False, index=False
+        os.path.join(out_folder, "newsarticles_trainedcoding.csv"),
+        header=False,
+        index=False,
     )
 
     # newsarticles_trainedcategoryrelevance
-    tcr_names = ['id', 'relevance', 'category_id', 'coding_id']
+    tcr_names = ["id", "relevance", "category_id", "coding_id"]
     tcr = pd.read_csv(
-        'tagnews/data/newsarticles_trainedcategoryrelevance.csv',
-        names=tcr_names
+        "tagnews/data/newsarticles_trainedcategoryrelevance.csv", names=tcr_names
     )
-    tcr = tcr.loc[tcr['coding_id'].isin(tc['id'])]
+    tcr = tcr.loc[tcr["coding_id"].isin(tc["id"])]
     tcr.to_csv(
-        os.path.join(out_folder, 'newsarticles_trainedcategoryrelevance.csv'),
-        header=False, index=False
+        os.path.join(out_folder, "newsarticles_trainedcategoryrelevance.csv"),
+        header=False,
+        index=False,
     )
 
     # newsarticles_trainedlocation
-    tl_names = ['id', 'text', 'latitude', 'longitude', 'coding_id']
-    tl = pd.read_csv(
-        'tagnews/data/newsarticles_trainedlocation.csv',
-        names=tl_names
-    )
-    tl = tl.loc[tl['coding_id'].isin(tc['id'])]
+    tl_names = ["id", "text", "latitude", "longitude", "coding_id"]
+    tl = pd.read_csv("tagnews/data/newsarticles_trainedlocation.csv", names=tl_names)
+    tl = tl.loc[tl["coding_id"].isin(tc["id"])]
     tl.to_csv(
-        os.path.join(out_folder, 'newsarticles_trainedlocation.csv'),
-        header=False, index=False
+        os.path.join(out_folder, "newsarticles_trainedlocation.csv"),
+        header=False,
+        index=False,
     )
 
 
 def load_crime_data(data_folder=__data_folder):
-    crimes = pd.read_csv(os.path.join(data_folder, 'Crimes.csv'))
-    crimes = crimes[crimes['Year'] > 2010]
+    crimes = pd.read_csv(os.path.join(data_folder, "Crimes.csv"))
+    crimes = crimes[crimes["Year"] > 2010]
 
-    crime_string = pd.Series('', crimes.index)
+    crime_string = pd.Series("", crimes.index)
 
     # ['ID', 'Case Number', 'Date', 'Block', 'IUCR', 'Primary Type',
     #  'Description', 'Location Description', 'Arrest', 'Domestic', 'Beat',
@@ -446,37 +478,35 @@ def load_crime_data(data_folder=__data_folder):
 
     # TODO: synonyms on this for month name, weekday name,
     # time of day (e.g. afternoon), etc.
-    crime_string += crimes['Date'] + ' '
+    crime_string += crimes["Date"] + " "
 
     # TODO: synonyms?
-    crime_string += crimes['Primary Type'] + ' '
+    crime_string += crimes["Primary Type"] + " "
 
     # TODO: synonyms?
-    crime_string += crimes['Description'] + ' '
+    crime_string += crimes["Description"] + " "
 
     # TODO: synonyms?
-    crime_string += crimes['Location Description'] + ' '
+    crime_string += crimes["Location Description"] + " "
 
     # TODO: synonyms?
-    iucr = pd.read_csv(os.path.join(data_folder, 'IUCR.csv'))
-    iucr.set_index('IUCR', drop=True, inplace=True)
+    iucr = pd.read_csv(os.path.join(data_folder, "IUCR.csv"))
+    iucr.set_index("IUCR", drop=True, inplace=True)
     idx = iucr.index
     idx_values = idx.values
-    idx_values[idx.str.len() == 3] = '0' + idx_values[idx.str.len() == 3]
-    crime_string += (iucr.loc[crimes['IUCR'], 'PRIMARY DESCRIPTION']
-                     .fillna('')
-                     .values
-                     + ' ')
-    crime_string += (iucr.loc[crimes['IUCR'], 'SECONDARY DESCRIPTION']
-                     .fillna('')
-                     .values
-                     + ' ')
-    community_areas = pd.read_csv(os.path.join(data_folder, 'CommAreas.csv'))
-    community_areas.set_index('AREA_NUM_1', inplace=True, drop=True)
-    crime_string += (community_areas.loc[crimes['Community Area'], 'COMMUNITY']
-                     .fillna('')
-                     .values
-                     + ' ')
+    idx_values[idx.str.len() == 3] = "0" + idx_values[idx.str.len() == 3]
+    crime_string += (
+        iucr.loc[crimes["IUCR"], "PRIMARY DESCRIPTION"].fillna("").values + " "
+    )
+    crime_string += (
+        iucr.loc[crimes["IUCR"], "SECONDARY DESCRIPTION"].fillna("").values + " "
+    )
+    community_areas = pd.read_csv(os.path.join(data_folder, "CommAreas.csv"))
+    community_areas.set_index("AREA_NUM_1", inplace=True, drop=True)
+    crime_string += (
+        community_areas.loc[crimes["Community Area"], "COMMUNITY"].fillna("").values
+        + " "
+    )
 
     return crimes, crime_string
 
@@ -489,16 +519,18 @@ def load_ner_data(data_folder=__data_folder):
     the row corresponds to the entity "geo". Typically, you will
     want to use column 'word' to predict the column 'stag'.
     """
-    df = pd.read_csv(os.path.join(data_folder, 'ner.csv'),
-                     encoding="ISO-8859-1",
-                     error_bad_lines=False,
-                     index_col=0)
+    df = pd.read_csv(
+        os.path.join(data_folder, "ner.csv"),
+        encoding="ISO-8859-1",
+        error_bad_lines=False,
+        index_col=0,
+    )
 
-    df.dropna(subset=['word', 'tag'], inplace=True)
+    df.dropna(subset=["word", "tag"], inplace=True)
     df.reset_index(inplace=True, drop=True)
-    df['stag'] = (df['tag'] == 'B-geo') | (df['tag'] == 'I-geo')
-    df['all_tags'] = df['tag']
-    df['tag'] = df['stag']
-    df = df[['word', 'all_tags', 'tag']]
+    df["stag"] = (df["tag"] == "B-geo") | (df["tag"] == "I-geo")
+    df["all_tags"] = df["tag"]
+    df["tag"] = df["stag"]
+    df = df[["word", "all_tags", "tag"]]
 
     return df
diff --git a/lib/tagnews/utils/load_vectorizer.py b/lib/tagnews/utils/load_vectorizer.py
index fb67235..ec7d7be 100644
--- a/lib/tagnews/utils/load_vectorizer.py
+++ b/lib/tagnews/utils/load_vectorizer.py
@@ -23,7 +23,7 @@ def load_glove(vectors_file, normalize=False):
 
     Sample usage:
 
-        >>> vectors = load_glove('tagnews/data/glove.6B.50d.txt')
+        >>> vectors = load_glove('tagnews/geoloc/glove.6B.50d.txt')
         >>> text = 'This is a sentence and stuff.'
         >>> # you should use an actual tokenizer for this step.
         >>> vectorized_text = vectors.loc[[word.lower()
diff --git a/setup.py b/setup.py
index 71a08c2..6797f41 100644
--- a/setup.py
+++ b/setup.py
@@ -4,9 +4,10 @@
 
 import os
 
-with open('README.md') as f:
+with open('README.md', "r") as f:
     long_description = f.read()
 
+
 init_file = os.path.join(os.path.split(__file__)[0], 'lib/tagnews/__init__.py')
 with open(init_file) as f:
     try:

From f6976d738b567afe186915f2e5a998454851dd4f Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 14 Jan 2020 20:38:47 -0600
Subject: [PATCH 21/22] imports

---
 CODEOWNERS              | 2 +-
 lib/tagnews/__init__.py | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 5f5a7cf..bc7c430 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -1 +1 @@
-* @jherzberg @mchladek
\ No newline at end of file
+* @jherzberg @mchladek @RJWorth
\ No newline at end of file
diff --git a/lib/tagnews/__init__.py b/lib/tagnews/__init__.py
index 93596d8..c3732d2 100644
--- a/lib/tagnews/__init__.py
+++ b/lib/tagnews/__init__.py
@@ -2,13 +2,12 @@
 from . import crimetype
 
 from .crimetype.tag import CrimeTags
+from .senteval.eval import SentimentGoogler
 from .geoloc.tag import GeoCoder, get_lat_longs_from_geostrings
 from .utils.load_data import load_data
 from .utils.load_vectorizer import load_glove
-from .senteval.eval import SentimentGoogler
-from .senteval.police_words import police_words_list, bins
 
 __all__ = [utils, crimetype, CrimeTags, GeoCoder, SentimentGoogler,
-           get_lat_longs_from_geostrings, load_data, load_glove, police_words_list, bins]
+           get_lat_longs_from_geostrings, load_data, load_glove]
 
-__version__ = '1.2.5'
+__version__ = '1.3.0'

From e3d13dd20f363b5d424400a94c41c890b1df1698 Mon Sep 17 00:00:00 2001
From: josh herzberg <jlherzberg@gmail.com>
Date: Tue, 14 Jan 2020 20:52:15 -0600
Subject: [PATCH 22/22] revert

---
 lib/tagnews/utils/load_data.py | 480 +++++++++++++++------------------
 1 file changed, 222 insertions(+), 258 deletions(-)

diff --git a/lib/tagnews/utils/load_data.py b/lib/tagnews/utils/load_data.py
index 1112025..9aea5d2 100644
--- a/lib/tagnews/utils/load_data.py
+++ b/lib/tagnews/utils/load_data.py
@@ -16,9 +16,7 @@
 # Caution! Modifying this in code will have no effect since the
 # default arguments are populated with this reference at creation
 # time, so post-hoc modifications will do nothing.
-
-# __data_folder = os.path.join(os.path.split(__file__)[0], "..", "data")
-__data_folder = "/Users/joshherzberg/Documents/chihack/article-tagging/lib/tagnews/data/cjp_tables/"
+__data_folder = os.path.join(os.path.split(__file__)[0], '..', 'data')
 
 
 def clean_string(s):
@@ -27,7 +25,7 @@ def clean_string(s):
     Replaces newlines with spaces.
     """
 
-    return s.replace("\r", "").replace("\n", " ").replace("\xa0", " ").strip()
+    return s.replace('\r', '').replace('\n', ' ').replace('\xa0', ' ').strip()
 
 
 def load_articles(data_folder=__data_folder, nrows=None):
@@ -35,137 +33,109 @@ def load_articles(data_folder=__data_folder, nrows=None):
     Loads the articles CSV. Can optionally only load the first
     `nrows` number of rows.
     """
-    column_names = [
-        "id",
-        "feedname",
-        "url",
-        "orig_html",
-        "title",
-        "bodytext",
-        "relevant",
-        "created",
-        "last_modified",
-        "news_source_id",
-        "author",
-    ]
-
-    return pd.read_csv(
-        os.path.join(data_folder, "newsarticles_article.csv.gz"),
-        header=None,
-        names=column_names,
-        nrows=nrows,
-        dtype={"orig_html": str, "author": str},
-        compression="gzip",
-    )
+    column_names = ['id',
+                    'feedname',
+                    'url',
+                    'orig_html',
+                    'title',
+                    'bodytext',
+                    'relevant',
+                    'created',
+                    'last_modified',
+                    'news_source_id',
+                    'author']
+
+    return pd.read_csv(os.path.join(data_folder,
+                                    'newsarticles_article.csv'),
+                       header=None,
+                       names=column_names,
+                       nrows=nrows,
+                       dtype={'orig_html': str, 'author': str})
 
 
 def load_taggings(data_folder=__data_folder):
     """Loads the type-of-crime human tagging of the articles."""
-    uc_column_names = [
-        "id",
-        "date",
-        "relevant",
-        "article_id",
-        "user_id",
-        "locations",
-        "sentiment",
-    ]
-
-    uc = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_usercoding.csv.gz"),
-        header=None,
-        names=uc_column_names,
-        compression="gzip",
-    )
+    uc_column_names = ['id', 'date', 'relevant', 'article_id',
+                       'user_id', 'locations', 'sentiment']
+
+    uc = pd.read_csv(os.path.join(data_folder,
+                                  'newsarticles_usercoding.csv'),
+                     header=None,
+                     names=uc_column_names)
 
-    uc.set_index("id", drop=True, inplace=True)
+    uc.set_index('id', drop=True, inplace=True)
 
-    uc_tags_column_names = ["id", "usercoding_id", "category_id"]
+    uc_tags_column_names = ['id', 'usercoding_id', 'category_id']
 
     uc_tags = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_usercoding_categories.csv.gz"),
+        os.path.join(data_folder, 'newsarticles_usercoding_categories.csv'),
         header=None,
-        names=uc_tags_column_names,
-        compression="gzip",
+        names=uc_tags_column_names
     )
-    uc_tags.set_index("usercoding_id", drop=True, inplace=True)
+    uc_tags.set_index('usercoding_id', drop=True, inplace=True)
 
-    uc_tags["article_id"] = uc.loc[uc_tags.index, "article_id"]
+    uc_tags['article_id'] = uc.loc[uc_tags.index, 'article_id']
     return uc_tags
 
 
 def load_model_categories(data_folder=__data_folder):
-    tcr_names = ["id", "relevance", "category_id", "coding_id"]
-    tc_names = ["id", "date", "model_info", "relevance", "article_id", "sentiment"]
+    tcr_names = ['id', 'relevance', 'category_id', 'coding_id']
+    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id',
+                'sentiment']
 
     tcr = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_trainedcategoryrelevance.csv.gz"),
-        names=tcr_names,
-        compression="gzip"
+        os.path.join(data_folder, 'newsarticles_trainedcategoryrelevance.csv'),
+        names=tcr_names
     )
     tc = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_trainedcoding.csv.gz"), names=tc_names, compression="gzip"
-    ).set_index("id", drop=True)
-    tcr["article_id"] = tc.loc[tcr["coding_id"]]["article_id"].values
+        os.path.join(data_folder, 'newsarticles_trainedcoding.csv'),
+        names=tc_names
+    ).set_index('id', drop=True)
+    tcr['article_id'] = tc.loc[tcr['coding_id']]['article_id'].values
     return tcr
 
 
 def load_model_locations(data_folder=__data_folder):
-    tl_names = [
-        "id",
-        "text",
-        "latitude",
-        "longitude",
-        "coding_id",
-        "confidence",
-        "neighborhood",
-    ]
-    tc_names = ["id", "date", "model_info", "relevance", "article_id", "sentiment"]
+    tl_names = ['id', 'text', 'latitude', 'longitude', 'coding_id',
+                'confidence', 'neighborhood']
+    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id',
+                'sentiment']
 
     tl = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_trainedlocation.csv.gz"), names=tl_names, compression="gzip"
+        os.path.join(data_folder, 'newsarticles_trainedlocation.csv'),
+        names=tl_names
     )
     tc = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_trainedcoding.csv.gz"), names=tc_names, compression="gzip"
-    ).set_index("id", drop=True)
-    tl["article_id"] = tc.loc[tl["coding_id"]]["article_id"].values
+        os.path.join(data_folder, 'newsarticles_trainedcoding.csv'),
+        names=tc_names
+    ).set_index('id', drop=True)
+    tl['article_id'] = tc.loc[tl['coding_id']]['article_id'].values
     return tl
 
 
 def load_locations(data_folder=__data_folder):
     """Load the human-extracted locations from the articles."""
-    uc_column_names = [
-        "id",
-        "date",
-        "relevant",
-        "article_id",
-        "user_id",
-        "locations",
-        "sentiment",
-    ]
-
-    uc = pd.read_csv(
-        os.path.join(data_folder, "newsarticles_usercoding.csv.gz"),
-        header=None,
-        names=uc_column_names,
-        compression="gzip"
-    )
+    uc_column_names = ['id', 'date', 'relevant', 'article_id',
+                       'user_id', 'locations', 'sentiment']
+
+    uc = pd.read_csv(os.path.join(data_folder,
+                                  'newsarticles_usercoding.csv'),
+                     header=None,
+                     names=uc_column_names)
 
-    uc["locations"] = uc["locations"].apply(lambda x: json.loads(x))
+    uc['locations'] = uc['locations'].apply(lambda x: json.loads(x))
 
     return uc
 
 
 def load_categories(data_folder=__data_folder):
     """Loads the mapping of id to names/abbrevations of categories"""
-    column_names = ["id", "category_name", "abbreviation", "created", "active", "kind"]
+    column_names = ['id', 'category_name', 'abbreviation', 'created',
+                    'active', 'kind']
 
-    return pd.read_csv(
-        os.path.join(data_folder, "newsarticles_category.csv.gz"),
-        header=None,
-        names=column_names,
-        compression="gzip"
-    )
+    return pd.read_csv(os.path.join(data_folder, 'newsarticles_category.csv'),
+                       header=None,
+                       names=column_names)
 
 
 def load_data(data_folder=__data_folder, nrows=None):
@@ -174,7 +144,6 @@ def load_data(data_folder=__data_folder, nrows=None):
     into columns called cat_NUMBER. The k-hot encoding is done assuming that
     the categories are 1-indexed and there are as many categories as the
     maximum value of the numerical cateogry_id column.
-
     Inputs:
         data_folder:
             A folder containing the data files in CSV format.
@@ -184,38 +153,33 @@ def load_data(data_folder=__data_folder, nrows=None):
     """
 
     df = load_articles(data_folder=data_folder, nrows=nrows)
-    df["relevant"] = df["relevant"] == "t"
-    df.rename(columns={"id": "article_id"}, inplace=True)
-    df.set_index("article_id", drop=True, inplace=True)
+    df['relevant'] = df['relevant'] == 't'
+    df.rename(columns={'id': 'article_id'}, inplace=True)
+    df.set_index('article_id', drop=True, inplace=True)
     # hopefully this will save some memory/space, can add back if needed
-    del (df["orig_html"])
+    del(df['orig_html'])
 
     tags_df = load_taggings(data_folder)
     # will help cacheing
-    tags_df.sort_values(by="article_id", inplace=True)
-    tags_df = tags_df.loc[
-        tags_df["article_id"].isin(df.index.intersection(tags_df["article_id"]))
-    ]
+    tags_df.sort_values(by='article_id', inplace=True)
+    tags_df = tags_df.loc[tags_df['article_id'].isin(
+        df.index.intersection(tags_df['article_id']))]
 
     locs_df = load_locations(data_folder)
-    locs_df.sort_values(by="article_id", inplace=True)
-    locs_df = locs_df.loc[
-        locs_df["article_id"].isin(df.index.intersection(locs_df["article_id"]))
-    ]
+    locs_df.sort_values(by='article_id', inplace=True)
+    locs_df = locs_df.loc[locs_df['article_id'].isin(
+        df.index.intersection(locs_df['article_id']))]
 
     model_tags_df = load_model_categories(data_folder)
     # will help cacheing
-    model_tags_df.sort_values(by="article_id", inplace=True)
-    model_tags_df = model_tags_df.loc[
-        model_tags_df["article_id"].isin(
-            df.index.intersection(model_tags_df["article_id"])
-        )
-    ]
+    model_tags_df.sort_values(by='article_id', inplace=True)
+    model_tags_df = model_tags_df.loc[model_tags_df['article_id'].isin(
+        df.index.intersection(model_tags_df['article_id']))]
 
     # init with empty lists
-    df["locations"] = np.empty([df.shape[0], 0]).tolist()
-    loc_article_ids = locs_df["article_id"].values
-    df.loc[loc_article_ids, "locations"] = locs_df["locations"].values
+    df['locations'] = np.empty([df.shape[0], 0]).tolist()
+    loc_article_ids = locs_df['article_id'].values
+    df.loc[loc_article_ids, 'locations'] = locs_df['locations'].values
 
     def find_loc_in_string(locs, string):
         """
@@ -224,7 +188,6 @@ def find_loc_in_string(locs, string):
         neatly. This function will hopefully performa all necessary
         transformations to find the given location text within the
         larger string.
-
         Inputs:
             locs: list of locations as loaded by load_locations
             string: bodytext of article in which to find locs
@@ -235,12 +198,12 @@ def find_loc_in_string(locs, string):
         """
 
         for i, loc in enumerate(locs):
-            loc_txt = loc["text"]
+            loc_txt = loc['text']
 
             loc_txt = clean_string(loc_txt)
             string = clean_string(string)
 
-            loc["cleaned text"] = loc_txt
+            loc['cleaned text'] = loc_txt
 
             spans = [x.span() for x in re.finditer(re.escape(loc_txt), string)]
             if spans:
@@ -248,55 +211,53 @@ def find_loc_in_string(locs, string):
                 # spans don't line up perfectly we can't know which one is the
                 # "correct" one. Best we can do is find the python span closest
                 # to the expected javascript span.
-                closest = np.argmin(
-                    np.abs(np.array([x[0] for x in spans]) - loc["start"])
-                )
-                loc["cleaned span"] = spans[closest]
+                closest = np.argmin(np.abs(
+                    np.array([x[0] for x in spans]) - loc['start']
+                ))
+                loc['cleaned span'] = spans[closest]
 
             locs[i] = loc
 
         return locs
 
-    df["locations"] = df.apply(
-        lambda r: find_loc_in_string(r["locations"], r["bodytext"]), axis=1
+    df['locations'] = df.apply(
+        lambda r: find_loc_in_string(r['locations'], r['bodytext']),
+        axis=1
     )
 
-    num_no_match = (
-        df["locations"]
-        .apply(lambda locs: any([("cleaned span" not in loc) for loc in locs]))
-        .sum()
-    )
+    num_no_match = df['locations'].apply(
+        lambda locs: any([('cleaned span' not in loc) for loc in locs])
+    ).sum()
     if num_no_match:
-        warnings.warn(
-            ("{} location strings were not found in" " the bodytext.").format(
-                num_no_match
-            ),
-            RuntimeWarning,
-        )
+        warnings.warn(('{} location strings were not found in'
+                       ' the bodytext.').format(num_no_match),
+                      RuntimeWarning)
 
     model_locations_df = load_model_locations(data_folder)
-    model_locations_df = model_locations_df.set_index("article_id")
-    model_locations_gb = model_locations_df.groupby("article_id")
-    model_locations_text = model_locations_gb["text"].apply(list)
-    df["model_location_text"] = model_locations_text
+    model_locations_df = model_locations_df.set_index('article_id')
+    model_locations_gb = model_locations_df.groupby('article_id')
+    model_locations_text = model_locations_gb['text'].apply(list)
+    df['model_location_text'] = model_locations_text
 
     categories_df = load_categories(data_folder)
-    categories_df.set_index("id", drop=True, inplace=True)
+    categories_df.set_index('id', drop=True, inplace=True)
 
     # tags_df['category_id'] = tags_df['category_id'].astype(str)
-    tags_df["category_abbreviation"] = categories_df["abbreviation"][
-        tags_df["category_id"]
-    ].values
-    model_tags_df["category_abbreviation"] = categories_df["abbreviation"][
-        model_tags_df["category_id"]
-    ].values
-
-    if np.setdiff1d(tags_df["article_id"].values, df.index.values).size:
-        warnings.warn(
-            "Tags were found for article IDs that do not exist.", RuntimeWarning
-        )
-
-    def update_df_with_categories(article_ids, cat_abbreviations, vals, is_model):
+    tags_df['category_abbreviation'] = (categories_df
+                                        ['abbreviation']
+                                        [tags_df['category_id']]
+                                        .values)
+    model_tags_df['category_abbreviation'] = (categories_df
+                                              ['abbreviation']
+                                              [model_tags_df['category_id']]
+                                              .values)
+
+    if np.setdiff1d(tags_df['article_id'].values, df.index.values).size:
+        warnings.warn('Tags were found for article IDs that do not exist.',
+                      RuntimeWarning)
+
+    def update_df_with_categories(article_ids, cat_abbreviations, vals,
+                                  is_model):
         # for some reason, some articles that are tagged don't show up
         # in the articles CSV. filter those out.
         existing_ids_filter = np.isin(article_ids, df.index.values)
@@ -306,36 +267,37 @@ def update_df_with_categories(article_ids, cat_abbreviations, vals, is_model):
         vals = vals[existing_ids_filter]
 
         for i in range(categories_df.shape[0]):
-            cat_name = categories_df.loc[i + 1, "abbreviation"]
+            cat_name = categories_df.loc[i+1, 'abbreviation']
             if is_model:
-                cat_name += "_model"
+                cat_name += '_model'
             df[cat_name] = 0
             if not is_model:
-                df[cat_name] = df[cat_name].astype("int8")
+                df[cat_name] = df[cat_name].astype('int8')
             matches = cat_abbreviations == cat_name
             if not matches.sum():
                 continue
             df.loc[article_ids[matches], cat_name] = vals[matches]
 
     update_df_with_categories(
-        model_tags_df["article_id"].values,
-        model_tags_df["category_abbreviation"].values + "_model",
-        model_tags_df["relevance"].values,
-        is_model=True,
+        model_tags_df['article_id'].values,
+        model_tags_df['category_abbreviation'].values + '_model',
+        model_tags_df['relevance'].values,
+        is_model=True
     )
     update_df_with_categories(
-        tags_df["article_id"].values,
-        tags_df["category_abbreviation"].values,
-        np.ones((tags_df["article_id"].values.shape), dtype="int8"),
-        is_model=False,
+        tags_df['article_id'].values,
+        tags_df['category_abbreviation'].values,
+        np.ones((tags_df['article_id'].values.shape), dtype='int8'),
+        is_model=False
     )
 
-    df.loc[df["bodytext"].isnull(), "bodytext"] = ""
+    df.loc[df['bodytext'].isnull(), 'bodytext'] = ''
 
     return df
 
 
-def subsample_and_resave(out_folder, n=5, input_folder=__data_folder, random_seed=5):
+def subsample_and_resave(out_folder, n=5, input_folder=__data_folder,
+                         random_seed=5):
     """
     Subsamples the CSV data files so that we have at least
     `n` articles from each type-of-crime tag as determined
@@ -343,7 +305,6 @@ def subsample_and_resave(out_folder, n=5, input_folder=__data_folder, random_see
     into `out_folder`. If there are fewer than `n` articles
     tagged with a type-of-crime, then we will use all of
     the articles with that tag.
-
     Inputs
     ------
     out_folder : str
@@ -359,116 +320,120 @@ def subsample_and_resave(out_folder, n=5, input_folder=__data_folder, random_see
     out_folder = str(Path(out_folder).expanduser().absolute())
     input_folder = str(Path(input_folder).expanduser().absolute())
     if out_folder == input_folder:
-        raise RuntimeError("out_folder cannot match input_folder.")
+        raise RuntimeError('out_folder cannot match input_folder.')
 
     random_state = np.random.RandomState(random_seed)
 
     df = load_data(input_folder)
     chosen_indexes = []
-    for crime_type in df.loc[:, "OEMC":].columns:
+    for crime_type in df.loc[:, 'OEMC':].columns:
         is_type = df[crime_type].astype(bool)
         n_samps = min(n, is_type.sum())
-        chosen_indexes += (
-            df.loc[is_type, :].sample(n_samps, random_state=random_state).index.tolist()
-        )
+        chosen_indexes += (df.loc[is_type, :]
+                           .sample(n_samps, random_state=random_state)
+                           .index
+                           .tolist())
     del df
 
     chosen_indexes = sorted(list(set(chosen_indexes)))
 
     # newsarticles_article.csv
     articles_df = load_articles(input_folder)
-    sample = articles_df.reset_index().set_index("id").loc[chosen_indexes, "index"]
+    sample = (articles_df
+              .reset_index()
+              .set_index('id')
+              .loc[chosen_indexes, 'index'])
     articles_df = articles_df.loc[sample, :]
     # garble garble
-    articles_df["bodytext"] = (
-        articles_df["bodytext"].astype(str).apply(lambda x: codecs.encode(x, "rot-13"))
-    )
-    articles_df.to_csv(
-        os.path.join(out_folder, "newsarticles_article.csv"), header=None, index=False
+    articles_df['bodytext'] = articles_df['bodytext'].astype(str).apply(
+        lambda x: codecs.encode(x, 'rot-13')
     )
+    articles_df.to_csv(os.path.join(out_folder, 'newsarticles_article.csv'),
+                       header=None, index=False)
     del articles_df
 
     # newsarticles_category.csv
-    shutil.copyfile(
-        os.path.join(input_folder, "newsarticles_category.csv"),
-        os.path.join(out_folder, "newsarticles_category.csv"),
-    )
+    shutil.copyfile(os.path.join(input_folder, 'newsarticles_category.csv'),
+                    os.path.join(out_folder, 'newsarticles_category.csv'))
 
     # newsarticles_usercoding.csv
-    uc_column_names = ["id", "date", "relevant", "article_id", "user_id", "locations"]
+    uc_column_names = ['id', 'date', 'relevant',
+                       'article_id', 'user_id', 'locations']
 
-    uc_df = pd.read_csv(
-        os.path.join(input_folder, "newsarticles_usercoding.csv"),
-        header=None,
-        names=uc_column_names,
-    )
+    uc_df = pd.read_csv(os.path.join(input_folder,
+                                     'newsarticles_usercoding.csv'),
+                        header=None,
+                        names=uc_column_names)
 
-    sample = np.where(uc_df["article_id"].isin(chosen_indexes))[0]
+    sample = np.where(uc_df['article_id'].isin(chosen_indexes))[0]
     uc_df.loc[sample, :].to_csv(
-        os.path.join(out_folder, "newsarticles_usercoding.csv"),
-        header=None,
-        index=False,
+        os.path.join(out_folder, 'newsarticles_usercoding.csv'),
+        header=None, index=False
     )
 
-    uc_tags_column_names = ["id", "usercoding_id", "category_id"]
+    uc_tags_column_names = ['id', 'usercoding_id', 'category_id']
 
     # newsarticles_usercoding_categories.csv
     uc_tags_df = pd.read_csv(
-        os.path.join(input_folder, "newsarticles_usercoding_categories.csv"),
+        os.path.join(input_folder,
+                     'newsarticles_usercoding_categories.csv'),
         header=None,
         names=uc_tags_column_names,
-        dtype={"id": int, "usercoding_id": int, "category_id": int},
+        dtype={'id': int, 'usercoding_id': int, 'category_id': int}
     )
-    sample = np.where(
-        uc_df.set_index("id")
-        .loc[uc_tags_df["usercoding_id"], "article_id"]
-        .isin(chosen_indexes)
-    )[0]
+    sample = np.where(uc_df
+                      .set_index('id')
+                      .loc[uc_tags_df['usercoding_id'], 'article_id']
+                      .isin(chosen_indexes)
+                      )[0]
     uc_tags_df = uc_tags_df.loc[sample, :]
     uc_tags_df.to_csv(
-        os.path.join(out_folder, "newsarticles_usercoding_categories.csv"),
-        header=None,
-        index=False,
+        os.path.join(out_folder, 'newsarticles_usercoding_categories.csv'),
+        header=None, index=False
     )
 
     # newsarticles_trainedcoding
-    tc_names = ["id", "date", "model_info", "relevance", "article_id"]
-    tc = pd.read_csv("tagnews/data/newsarticles_trainedcoding.csv", names=tc_names)
-    tc = tc.loc[tc["article_id"].isin(chosen_indexes)]
+    tc_names = ['id', 'date', 'model_info', 'relevance', 'article_id']
+    tc = pd.read_csv(
+        'tagnews/data/newsarticles_trainedcoding.csv',
+        names=tc_names
+    )
+    tc = tc.loc[tc['article_id'].isin(chosen_indexes)]
     tc.to_csv(
-        os.path.join(out_folder, "newsarticles_trainedcoding.csv"),
-        header=False,
-        index=False,
+        os.path.join(out_folder, 'newsarticles_trainedcoding.csv'),
+        header=False, index=False
     )
 
     # newsarticles_trainedcategoryrelevance
-    tcr_names = ["id", "relevance", "category_id", "coding_id"]
+    tcr_names = ['id', 'relevance', 'category_id', 'coding_id']
     tcr = pd.read_csv(
-        "tagnews/data/newsarticles_trainedcategoryrelevance.csv", names=tcr_names
+        'tagnews/data/newsarticles_trainedcategoryrelevance.csv',
+        names=tcr_names
     )
-    tcr = tcr.loc[tcr["coding_id"].isin(tc["id"])]
+    tcr = tcr.loc[tcr['coding_id'].isin(tc['id'])]
     tcr.to_csv(
-        os.path.join(out_folder, "newsarticles_trainedcategoryrelevance.csv"),
-        header=False,
-        index=False,
+        os.path.join(out_folder, 'newsarticles_trainedcategoryrelevance.csv'),
+        header=False, index=False
     )
 
     # newsarticles_trainedlocation
-    tl_names = ["id", "text", "latitude", "longitude", "coding_id"]
-    tl = pd.read_csv("tagnews/data/newsarticles_trainedlocation.csv", names=tl_names)
-    tl = tl.loc[tl["coding_id"].isin(tc["id"])]
+    tl_names = ['id', 'text', 'latitude', 'longitude', 'coding_id']
+    tl = pd.read_csv(
+        'tagnews/data/newsarticles_trainedlocation.csv',
+        names=tl_names
+    )
+    tl = tl.loc[tl['coding_id'].isin(tc['id'])]
     tl.to_csv(
-        os.path.join(out_folder, "newsarticles_trainedlocation.csv"),
-        header=False,
-        index=False,
+        os.path.join(out_folder, 'newsarticles_trainedlocation.csv'),
+        header=False, index=False
     )
 
 
 def load_crime_data(data_folder=__data_folder):
-    crimes = pd.read_csv(os.path.join(data_folder, "Crimes.csv"))
-    crimes = crimes[crimes["Year"] > 2010]
+    crimes = pd.read_csv(os.path.join(data_folder, 'Crimes.csv'))
+    crimes = crimes[crimes['Year'] > 2010]
 
-    crime_string = pd.Series("", crimes.index)
+    crime_string = pd.Series('', crimes.index)
 
     # ['ID', 'Case Number', 'Date', 'Block', 'IUCR', 'Primary Type',
     #  'Description', 'Location Description', 'Arrest', 'Domestic', 'Beat',
@@ -478,35 +443,37 @@ def load_crime_data(data_folder=__data_folder):
 
     # TODO: synonyms on this for month name, weekday name,
     # time of day (e.g. afternoon), etc.
-    crime_string += crimes["Date"] + " "
+    crime_string += crimes['Date'] + ' '
 
     # TODO: synonyms?
-    crime_string += crimes["Primary Type"] + " "
+    crime_string += crimes['Primary Type'] + ' '
 
     # TODO: synonyms?
-    crime_string += crimes["Description"] + " "
+    crime_string += crimes['Description'] + ' '
 
     # TODO: synonyms?
-    crime_string += crimes["Location Description"] + " "
+    crime_string += crimes['Location Description'] + ' '
 
     # TODO: synonyms?
-    iucr = pd.read_csv(os.path.join(data_folder, "IUCR.csv"))
-    iucr.set_index("IUCR", drop=True, inplace=True)
+    iucr = pd.read_csv(os.path.join(data_folder, 'IUCR.csv'))
+    iucr.set_index('IUCR', drop=True, inplace=True)
     idx = iucr.index
     idx_values = idx.values
-    idx_values[idx.str.len() == 3] = "0" + idx_values[idx.str.len() == 3]
-    crime_string += (
-        iucr.loc[crimes["IUCR"], "PRIMARY DESCRIPTION"].fillna("").values + " "
-    )
-    crime_string += (
-        iucr.loc[crimes["IUCR"], "SECONDARY DESCRIPTION"].fillna("").values + " "
-    )
-    community_areas = pd.read_csv(os.path.join(data_folder, "CommAreas.csv"))
-    community_areas.set_index("AREA_NUM_1", inplace=True, drop=True)
-    crime_string += (
-        community_areas.loc[crimes["Community Area"], "COMMUNITY"].fillna("").values
-        + " "
-    )
+    idx_values[idx.str.len() == 3] = '0' + idx_values[idx.str.len() == 3]
+    crime_string += (iucr.loc[crimes['IUCR'], 'PRIMARY DESCRIPTION']
+                     .fillna('')
+                     .values
+                     + ' ')
+    crime_string += (iucr.loc[crimes['IUCR'], 'SECONDARY DESCRIPTION']
+                     .fillna('')
+                     .values
+                     + ' ')
+    community_areas = pd.read_csv(os.path.join(data_folder, 'CommAreas.csv'))
+    community_areas.set_index('AREA_NUM_1', inplace=True, drop=True)
+    crime_string += (community_areas.loc[crimes['Community Area'], 'COMMUNITY']
+                     .fillna('')
+                     .values
+                     + ' ')
 
     return crimes, crime_string
 
@@ -514,23 +481,20 @@ def load_crime_data(data_folder=__data_folder):
 def load_ner_data(data_folder=__data_folder):
     """
     Loads ner.csv from the specified data folder.
-
     The column 'stag' is a binary value indicating whether or not
     the row corresponds to the entity "geo". Typically, you will
     want to use column 'word' to predict the column 'stag'.
     """
-    df = pd.read_csv(
-        os.path.join(data_folder, "ner.csv"),
-        encoding="ISO-8859-1",
-        error_bad_lines=False,
-        index_col=0,
-    )
+    df = pd.read_csv(os.path.join(data_folder, 'ner.csv'),
+                     encoding="ISO-8859-1",
+                     error_bad_lines=False,
+                     index_col=0)
 
-    df.dropna(subset=["word", "tag"], inplace=True)
+    df.dropna(subset=['word', 'tag'], inplace=True)
     df.reset_index(inplace=True, drop=True)
-    df["stag"] = (df["tag"] == "B-geo") | (df["tag"] == "I-geo")
-    df["all_tags"] = df["tag"]
-    df["tag"] = df["stag"]
-    df = df[["word", "all_tags", "tag"]]
+    df['stag'] = (df['tag'] == 'B-geo') | (df['tag'] == 'I-geo')
+    df['all_tags'] = df['tag']
+    df['tag'] = df['stag']
+    df = df[['word', 'all_tags', 'tag']]
 
-    return df
+    return df
\ No newline at end of file