Final Post Processing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing modules \n",
    "import json \n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import csv\n",
    "from fuzzywuzzy import fuzz, process\n",
    "import re\n",
    "from timeit import default_timer as timer\n",
    "import random\n",
    "import matplotlib.pyplot as plt\n",
    "from itertools import islice\n",
    "import pkg_resources\n",
    "from symspellpy import SymSpell, Verbosity\n",
    "\n",
    "# test file path\n",
    "path = \"./test_directory_files/\"\n",
    "tsv = \"tsv/\"\n",
    "locations = \"4b119360-317a-0134-9131-00505686a51c_locations.tsv\"\n",
    "occupations = \"4b119360-317a-0134-9131-00505686a51c_occupations.tsv\"\n",
    "subjects = \"4b119360-317a-0134-9131-00505686a51c_subjects.tsv\"\n",
    "test_json = \"119.56837603.5abc93e0-6e04-0134-173e-00505686a51c_labeled.json\"\n",
    "street_names_txt = \"./city-directory-entry-parser-master/streetnames.txt\"\n",
    "\n",
    "sym_spell = SymSpell()\n",
    "dictionary_path = pkg_resources.resource_filename(\n",
    "    \"symspellpy\", \"frequency_dictionary_en_82_765.txt\")\n",
    "sym_spell.load_dictionary(dictionary_path, 0, 1)\n",
    "\n",
    "# set seed\n",
    "random.seed(160220)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print out first 5 elements to demonstrate that dictionary is\n",
    "# successfully loaded\n",
    "##print(list(islice(sym_spell.words.items(), 5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Open tsvs and streetnames\n",
    "## From Nick: Columns are the directory uuid, page uuid, entry uuid, the number (in 0,1,2,3 index order) of the entry \n",
    "##            (remember that there could be more than one subject per entry, more than one occupation, etc.).Most are \n",
    "##            entry 0, but sometimes you might find an entry 1 if there are multiple subjects/occupations/locations. \n",
    "##            Then an offset number, e.g. the order of the token from the start of the entry. So a 0th token, 1st token,\n",
    "##            2nd token, etc. And finally the token itself in the last column.\n",
    "##            Remember that we have to keep that entry and offset number linked to each token otherwise we won't be able \n",
    "##            to swap any corrections back into the JSON file once we have a listed of recommended edits.\n",
    "\n",
    "locations_tsv = pd.read_csv(path + tsv + locations, \n",
    "                           sep = \"\\t\",\n",
    "                           quoting = csv.QUOTE_NONE)\n",
    "occupations_tsv = pd.read_csv(path + tsv + occupations, \n",
    "                           sep = \"\\t\",\n",
    "                           quoting = csv.QUOTE_NONE)\n",
    "subjects_tsv = pd.read_csv(path + tsv + subjects, \n",
    "                           sep = \"\\t\",\n",
    "                           quoting = csv.QUOTE_NONE)\n",
    "master_street_names = pd.read_csv(street_names_txt, \n",
    "                                  header = None)\n",
    "master_street_names = master_street_names[0].tolist()\n",
    "#master_street_names"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Locations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Objectives:**  \n",
    "1) Find common Tesseract tokens  \n",
    "2) Assign level of confidence  \n",
    "3) Swap out those with high level of confidence  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(locations_tsv.entry_uuid.nunique())\n",
    "#locations_tsv.head(n = 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function remove punctuation and default to lowercase\n",
    "def clean_token(token):\n",
    "    token_lower = token.lower()\n",
    "    token_clean = ''.join(t for t in token_lower if t.isalnum())\n",
    "    return token_clean\n",
    "\n",
    "# apply to column and create new column\n",
    "locations_tsv[\"token_re\"] = locations_tsv[\"token\"].apply(clean_token)\n",
    "\n",
    "# drop rows with just whitespace\n",
    "locations_tsv = locations_tsv.drop(locations_tsv[(locations_tsv.token_re == '')].index)\n",
    "\n",
    "# create trial pd\n",
    "locations_tsv_trunc = locations_tsv.sample(n = 500)\n",
    "#locations_tsv_trunc.head(n=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fuzzywuzzy\n",
    "The following trials a fuzzy matching approach to the problem of correcting location entries based on a dictionary of known street names.   \n",
    "The threshold is set at 90%. Only entries that are at least 90% similar to the list of known locations are successfully replaced. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.721390900000003\n"
     ]
    }
   ],
   "source": [
    "# timer\n",
    "start = timer()\n",
    "\n",
    "# Create lists for similar and dissimilar tokens\n",
    "tesseract_s = []\n",
    "pct_similarity_s = []\n",
    "best_guess_s = []\n",
    "tesseract_d = []\n",
    "pct_similarity_d = []\n",
    "best_guess_d = []\n",
    "def fuzzy_match(x, choices=master_street_names, scorer=fuzz.token_sort_ratio, threshold = 90,\n",
    "                tesseract_s = tesseract_s, pct_similarity_s = pct_similarity_s, best_guess_s = best_guess_s,\n",
    "                tesseract_d = tesseract_d, pct_similarity_d = pct_similarity_d, best_guess_d = best_guess_d):\n",
    "    n = 0\n",
    "    # check if numeric:\n",
    "    digit_check = x.isdigit()\n",
    "    if digit_check is True:\n",
    "        return x\n",
    "    else:\n",
    "        best_guess, pct_similarity = process.extractOne(x, choices=choices, scorer=scorer)\n",
    "        if pct_similarity >= threshold:\n",
    "            tesseract_s.append(x)\n",
    "            pct_similarity_s.append(pct_similarity)\n",
    "            best_guess_s.append(best_guess)\n",
    "            return best_guess\n",
    "        else:\n",
    "            tesseract_d.append(x)\n",
    "            pct_similarity_d.append(pct_similarity)\n",
    "            best_guess_d.append(best_guess)\n",
    "            return None\n",
    "            \n",
    "        #print(best_guess)\n",
    "        #print(pct_similarity)\n",
    "\n",
    "        \n",
    "        \n",
    "# create a second truncated df to trial\n",
    "locations_tsv_trunc_2 = locations_tsv_trunc\n",
    "    \n",
    "# Following post explains why token_sort_ratio might be best \n",
    "## https://medium.com/analytics-vidhya/matching-messy-pandas-columns-with-fuzzywuzzy-4adda6c7994f\n",
    "## tldr: converts each word to a token, then sorts aphabetically. \n",
    "## Streetnames that are abbrievated and in full both start with the same letter so this avoids errors like bway -> w  \n",
    "\n",
    "#### FULL DATASET\n",
    "\n",
    "#locations_tsv[\"token_replaced\"] = locations_tsv[\"token_re\"].apply(\n",
    "#    fuzzy_match\n",
    "#    ,args=(\n",
    "#        master_street_names,\n",
    "#        fuzz.token_sort_ratio\n",
    "#    )\n",
    "#)\n",
    " \n",
    "#### SAMPLE DATASET  \n",
    "\n",
    "locations_tsv_trunc[\"token_replaced\"] = locations_tsv_trunc[\"token_re\"].apply(fuzzy_match)\n",
    "    \n",
    "## timer\n",
    "end = timer()\n",
    "print(end - start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Put the lists from replacement fn above into a df\n",
    "## Dissimilarity\n",
    "dissimilar_frequency_df = pd.DataFrame({\"Tesseract\": tesseract_d,\n",
    "                    \"Guess\": best_guess_d,\n",
    "                    \"Similarity\": pct_similarity_d}) \n",
    "## Similarity\n",
    "similar_frequency_df = pd.DataFrame({\"Tesseract\": tesseract_s,\n",
    "                    \"Guess\": best_guess_s,\n",
    "                    \"Similarity\": pct_similarity_s}) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Tesseract</th>\n",
       "      <th>Guess</th>\n",
       "      <th>Similarity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ninth</td>\n",
       "      <td>Ninth</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>bway</td>\n",
       "      <td>Bway</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>av</td>\n",
       "      <td>Av</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>38th</td>\n",
       "      <td>38th</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>houston</td>\n",
       "      <td>Houston</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>237</th>\n",
       "      <td>seventh</td>\n",
       "      <td>Seventh</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>238</th>\n",
       "      <td>renwick</td>\n",
       "      <td>Renwick</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>239</th>\n",
       "      <td>34th</td>\n",
       "      <td>34th</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>240</th>\n",
       "      <td>third</td>\n",
       "      <td>Third</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>241</th>\n",
       "      <td>third</td>\n",
       "      <td>Third</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>242 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Tesseract    Guess  Similarity\n",
       "0       ninth    Ninth         100\n",
       "1        bway     Bway         100\n",
       "2          av       Av         100\n",
       "3        38th     38th         100\n",
       "4     houston  Houston         100\n",
       "..        ...      ...         ...\n",
       "237   seventh  Seventh         100\n",
       "238   renwick  Renwick         100\n",
       "239      34th     34th         100\n",
       "240     third    Third         100\n",
       "241     third    Third         100\n",
       "\n",
       "[242 rows x 3 columns]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similar_frequency_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The histogram suggests that for most replacement tokens, there is little variance in the tokens they replace. When performing swaps at a very high confidence level as measured by the degree of similarity, it is mostly a 1:1 swap. The case where a swap replaces multiple Tesseract tokens does not occur too frequently and rapidly drops off.  \n",
    "There are 804 unique Tesseract tokens in this directory. 600 of them show up less than or equal to 150 times. Some, such as \"w\" and \"av\" show up more than 20,000 times.\n",
    "On the complete dataset, the mean number of unique Tesseract tokens each replacement accounts for is **2.16**. For example, \"Ave\" might be the replacement for \"av\" and \"ave\" only, even we know that \"av\" alone shows up more than 20,000 times.  \n",
    "This implies that Tesseract is consistent in its recognition of text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Count')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAWuklEQVR4nO3de7gkdX3n8fdHhouCIoQBCWoGFfEWRTMq4m0UNEFdQSMRYxQNyhqv0TUr0V0vG7PBRH1INKIsRlCJikgEjaCAiFEUGO4gErwiijBqDKJZCfDNH/U72nPmzEwPM3UOh9/79Tzn6brXt7r6fLq6uutXqSokSf24w0IXIEmaXwa/JHXG4Jekzhj8ktQZg1+SOrNkoQuYxg477FDLli1b6DIkaVE577zzflRVS2cPXxTBv2zZMlauXLnQZUjSopLku3MN91SPJHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1ZlFcuSvdVi079J8XbN3fOeypC7ZuLW4e8UtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SerMqMGf5NVJLktyaZKPJNkqyfZJTk1yZXvcbswaJEmrGy34k+wCvBJYXlUPAjYDDgQOBU6vqt2A01u/JGmejH2qZwlwxyRLgDsBPwD2A45p448B9h+5BknShNGCv6q+D7wduAq4Bvj3qvocsFNVXdOmuQbYcawaJElrGvNUz3YMR/e7Ar8JbJ3kjzZg/kOSrEyyctWqVWOVKUndGfNUzz7At6tqVVX9J3ACsBdwbZKdAdrjdXPNXFVHVtXyqlq+dOnSEcuUpL6MGfxXAXsmuVOSAHsDlwMnAQe1aQ4CThyxBknSLEvGWnBVnZ3keOB84CbgAuBIYBvguCQHM7w5HDBWDZKkNY0W/ABV9SbgTbMG/5Lh6F+StAC8cleSOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SerMqMGf5K5Jjk/y9SSXJ3lUku2TnJrkyva43Zg1SJJWN/YR/98Cp1TV/YCHAJcDhwKnV9VuwOmtX5I0T0YL/iR3AR4HvB+gqm6sqp8C+wHHtMmOAfYfqwZJ0prGPOK/F7AK+ECSC5IclWRrYKequgagPe44Yg2SpFnGDP4lwMOAI6rqocDP2YDTOkkOSbIyycpVq1aNVaMkdWfM4L8auLqqzm79xzO8EVybZGeA9njdXDNX1ZFVtbyqli9dunTEMiWpL6MFf1X9EPhekt3boL2BrwEnAQe1YQcBJ45VgyRpTUtGXv4rgGOTbAF8C3ghw5vNcUkOBq4CDhi5BknShFGDv6ouBJbPMWrvMdcrSVo7r9yVpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnZkq+JM8epphkqTbvmmP+N815TBJ0m3cOi/gSvIoYC9gaZLXTIy6C7DZmIVJksaxvit3twC2adPdeWL49cCzxipKkjSedQZ/VZ0JnJnk6Kr67jzVJEka0bRt9WyZ5Ehg2eQ8VfXEMYqSJI1n2uD/OPBe4Cjg5vHKkSSNbdrgv6mqjhi1EknSvJj255yfSvLSJDsn2X7mb9TKJEmjmPaIf+aOWX82MawYbqguSVpEpgr+qtp17EIkSfNjquBP8vy5hlfVBzdtOZKksU17qufhE91bMdw68XzA4JekRWbaUz2vmOxPsi3woVEqkiSN6tY2y/wLYLdNWYgkaX5Me47/Uwy/4oGhcbb7A8eNVZQkaTzTnuN/+0T3TcB3q+rqEeqRJI1sqlM9rbG2rzO00LkdcOOYRUmSxjPtHbj+ADgHOAD4A+DsJDbLLEmL0LSnet4APLyqrgNIshQ4DTh+rMIkSeOY9lc9d5gJ/ebHGzCvJOk2ZNoj/lOSfBb4SOt/NvCZcUqSJI1pfffcvQ+wU1X9WZJnAo8BAnwFOHYe6pMkbWLrO11zOPAzgKo6oapeU1WvZjjaP3zs4iRJm976gn9ZVV08e2BVrWS4DaMkaZFZX/BvtY5xd9yUhUiS5sf6gv/cJC+ePTDJwcB545QkSRrT+n7V86fAPyV5Lr8O+uXAFsAzxixMkjSOdQZ/VV0L7JXkCcCD2uB/rqrPj16ZJGkU07bHfwZwxsi1SJLmwehX3ybZLMkFST7d+rdPcmqSK9vjdmPXIEn6tfloduFVwOUT/YcCp1fVbsDprV+SNE9GDf4kdweeChw1MXg/4JjWfQyw/5g1SJJWN/YR/+HA/wRumRi2U1VdA9Aed5xrxiSHJFmZZOWqVatGLlOS+jFa8Cd5GnBdVd2q3/tX1ZFVtbyqli9dunQTVydJ/Zq2dc5b49HA05M8heEK4Lsk+TBwbZKdq+qaJDsD161zKZKkTWq0I/6q+vOquntVLQMOBD5fVX8EnAQc1CY7CDhxrBokSWtaiJupHAY8KcmVwJNavyRpnox5qudXquoLwBda94+BvedjvZKkNXn7REnqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTOjBX+SeyQ5I8nlSS5L8qo2fPskpya5sj1uN1YNkqQ1jXnEfxPwP6rq/sCewMuSPAA4FDi9qnYDTm/9kqR5MlrwV9U1VXV+6/4ZcDmwC7AfcEyb7Bhg/7FqkCStaV7O8SdZBjwUOBvYqaqugeHNAdhxLfMckmRlkpWrVq2ajzIlqQujB3+SbYBPAH9aVddPO19VHVlVy6tq+dKlS8crUJI6M2rwJ9mcIfSPraoT2uBrk+zcxu8MXDdmDZKk1Y35q54A7wcur6p3Tow6CTiodR8EnDhWDZKkNS0ZcdmPBp4HXJLkwjbs9cBhwHFJDgauAg4YsQZJ0iyjBX9VfQnIWkbvPdZ6JUnr5pW7ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZwx+SeqMwS9JnTH4JakzBr8kdcbgl6TOGPyS1BmDX5I6Y/BLUmcMfknqjMEvSZ0x+CWpMwa/JHXG4Jekzhj8ktQZg1+SOmPwS1JnDH5J6ozBL0mdMfglqTMGvyR1xuCXpM4Y/JLUGYNfkjpj8EtSZxYk+JP8XpIrknwjyaELUYMk9Wregz/JZsDfA/sCDwCek+QB812HJPVqIY74HwF8o6q+VVU3Ah8F9luAOiSpS0sWYJ27AN+b6L8aeOTsiZIcAhzSem9IcsU81Lap7QD8aKGLmEe9bS8s4DbnbQuxVsD9vJj81lwDFyL4M8ewWmNA1ZHAkeOXM54kK6tq+ULXMV96215wm3txe9vmhTjVczVwj4n+uwM/WIA6JKlLCxH85wK7Jdk1yRbAgcBJC1CHJHVp3k/1VNVNSV4OfBbYDPiHqrpsvuuYJ4v6VNWt0Nv2gtvci9vVNqdqjdPrkqTbMa/claTOGPyS1BmDfyNN0/xEkhVJLkxyWZIz57vGTW1925xk2ySfSnJR2+YXLkSdm0qSf0hyXZJL1zI+Sf6uPR8XJ3nYfNe4qU2xzc9t23pxkrOSPGS+a9zU1rfNE9M9PMnNSZ41X7Vtagb/Rpim+YkkdwXeAzy9qh4IHDDvhW5CUza58TLga1X1EGAF8I72C67F6mjg99Yxfl9gt/Z3CHDEPNQ0tqNZ9zZ/G3h8VT0Y+AtuH19+Hs26t3nm9f82hh+nLFoG/8aZpvmJPwROqKqrAKrqunmucVObZpsLuHOSANsAPwFumt8yN52q+iLDNqzNfsAHa/BV4K5Jdp6f6saxvm2uqrOq6t9a71cZrsdZ1KbYzwCvAD4BLOr/Y4N/48zV/MQus6a5L7Bdki8kOS/J8+etunFMs83vBu7PcGHeJcCrquqW+SlvQUzznNyeHQycvNBFjC3JLsAzgPcudC0bayGabLg9mab5iSXA7wB7A3cEvpLkq1X1r2MXN5Jptvl3gQuBJwL3Bk5N8i9Vdf3YxS2QqZohuT1K8gSG4H/MQtcyDw4HXldVNw8fZhcvg3/jTNP8xNXAj6rq58DPk3wReAiwWIN/mm1+IXBYDReJfCPJt4H7AefMT4nzrstmSJI8GDgK2LeqfrzQ9cyD5cBHW+jvADwlyU1V9cmFLWvDeapn40zT/MSJwGOTLElyJ4aWSC+f5zo3pWm2+SqGTzgk2QnYHfjWvFY5v04Cnt9+3bMn8O9Vdc1CFzWmJPcETgCet4g/vW6Qqtq1qpZV1TLgeOClizH0wSP+jbK25ieSvKSNf29VXZ7kFOBi4BbgqKpa58/Fbsum2WaGX3kcneQShtMgr6uqxdikLQBJPsLw66QdklwNvAnYHH61vZ8BngJ8A/gFwyeeRW2KbX4j8BvAe9oR8E2LvfXKKbb5dsMmGySpM57qkaTOGPyS1BmDX5I6Y/BLUmcMfknqjMF/KySpJO+Y6H9tkjdvomUfPR+t/iU5IMnlSc7YBMt6+tpaJt0UkryhtW56YWsVcab7lWOtc2Ml2X7mJ64bMm7WdPskWZS/E99YSV6U5PCFrmMaSf44yd0Wuo4NYfDfOr8Enplkh4UuZFJrOXBaBzNcgPKEjV1vVZ1UVYdt7HLWsfy/rKo9qmoP4D9muqvq78Za52xJNvSal+2BtYX7usYtOut7bjbwdbkY/TFg8HfgJoZmaF89e8TsI/YkN7THFUnOTHJckn9Nclhr0/ycJJckuffEYvZJ8i9tuqe1+TdL8jdJzm1toP/3ieWekeQfGRpEm13Pc9ryL03ytjbsjQxtq7w3yd/Mmn5Fkk9P9L87yQta93eSvCXJ+W2Z92vDX5Dk3a171yRfaXX+xaztX9tyf6c9N+cl+Ww2oGXLJDslOSHJyvZc7tmGPzHD/QAubPVunWSXJF9qwy5Nslebdt9W8/lJPpZk6zb86iT/O8mXgWckeUnbrouSfDzJHdt0d0tyYtsvFyV5JHAYsHtb1+w3xdXGJblDkne2mi6Z6xNfkke2+pYl2aa9zs5JckGS/9ameVGS49tzeGWSv2rDlyT50MTrYI1PSkk+nOSIidfdvhPzvrOt6+IkL2rD90lyWpKPAhfMWtaSJD9N8tYk5wCPyNCG/cw+PjnDFd20/XF4e/4vSbLGRWBJ9ktydtvWzyXZsQ2/c5Jj2nwXJ9l/iv35l0m+2vbjw9ryvpnkxRPrO3Rie9/Yht2nPXfvz3CPiZOTbJXk2cAewMfa/lwczY9XlX8b+AfcANwF+A6wLfBa4M1t3NHAsyanbY8rgJ8COwNbAt8H3tLGvQo4fGL+UxjelHdjaAdmK4Z23v9Xm2ZLYCWwa1vuz4Fd56jzNxmaT1jKcJX254H927gvAMvnmGcF8OmJ/ncDL2jd3wFe0bpfynAVMsALgHe37pOA57ful83a/jWWy3Bl5FnA0jb82QxXA6/1uZ/V/zFgz9a9DLi0dZ8MPLJ1b8NwlfHrGK4ipvVvA+wInAncqQ1/A/D61n018JqJdf3GRPdhwJ+07k8AL2/dSxheG/cBLlzLNqw2rm3zKa2muzG09LkjsA/wSeCxbX/fvU3/18CBrXs7hnaftgJeBFwJ3JmhQcDvtdfAI4GTJ9Z31zlq+jDwaYbX3e5t3i3bfj504nV3AXDPVtsNwD3nWNYShkbqnjkx31nADq3/ucCRrftLwBGt+4kzz0vblsMntnHmYtOXAG9r3e8A3t6606Zb3/58cet+V9uWrYGdgB+24U9huH9G2nNxCrBX22f/Cfx2m+6EiX3wJWCPhc6lDfmzyYZbqaquT/JB4JXAf0w527nV2nBJ8k3gc234JcDkKZfjamjG+Mok32Jo4OzJwIMnjga3ZXhjuBE4p6q+Pcf6Hg58oapWtXUeCzyOIUxurRPa43nAM+cY/2jg91v3hxhuWrEuuwMPYmjBE4bw25B2bvZhOHqe6d+uHYl/GTg8wyehT1TVDUnOBd6XZCvgk1V1UZJ9GG4oc1ZbxhYM/8gzPjbR/eAk/we4K0O4znyCWcHQZhFVdRNw/cxR6ZQeA/xjVd0M/DDJlxgaBLuR4bl5D/Ckqvphm/7JwL759fcqWzGEMcBpVfUzgCRfb8OvbM/R3zI0LzHzuptt5nV3RZLvMby+ngzcP8mBbZqZ1x3AV6rdZ2IONwL/1LrvDzwQOG1iH189Me1HAKrq80l2TLLNrGXdEzguw3n0Lfl1A4f7APu3eQv4t3bUv679OdOu1CXAkvp144m3tPU+meHGOjOfYrZhaFr9Oob7UMx8qj6P4UBjUTL4N87hwPnAByaG3UQ7hZbhlTf50e+XE923TPTfwur7YnY7GsVwBPKKqlrtzj9JVjAc8c/l1rQd+6v6m61mjZ+p+WbW/vqZqx2QtS03wGVV9agNrHNGgEfUcFOYSW9NchLwVODcJCtasKxow45tp0J+AZxSVc9by/Inn9sPMrREeWk75bHnxLiNaftkXfvpBwxHpXswHH3OTL9/VX1ztYUkj2P119jNDOH24wwtae7LcKDy+wyfIGdb2+vupVV1+qx17cPaX3cwfBczs7wAF1fVY9cy7VzrnfT3wP+tqs+09c684WWOacO69+fk/9zs/8clbf63VtX7V1toch/meG7Xso7bPM/xb4Sq+glwHMMXpTO+w9D+Pgx3Ztr8Viz6gAznfe8N3Au4gqFRtD9JsjlAkvvOnLtch7OBxyfZIcMXbM9h+Bi8Lt8FHpBkyyTb0lrZ3ABfph39MnykX99yrwCWJnkUQJLNkzxwA9Z3GsMpJdr8e7THe1fVxVX1VwxHb7sn+S2Gj/RHMpxSeyjDKYjHJ7lXm2/rJLsxt60Zjsg3Z7iz2owzaF/WZvgu5i7Azxg+Fcxl9rgvAge2eXdi+NS0so37CfA04K+TzATnZxkCfGabH7qW9cyMX8pwquTjDA2Pre2ewAdkcF+GZqavbOt6adoXuEl2b5+oNsTXgF2SPKItY4tZ+/jZbfgK4Np2FD5pW+D77UDqoInhnwNe3uZNku3YsP05l88CB098L3D3rP9HHOva17dJBv/GewdD29wz/h/DC+8chnOr6zoqWpsrGAL6ZOAlVfX/Gdo9/xpwfoabQb+P9RxxtNNKf84QTBcB51fVieuZ53sMb2YXA8cy64u7KbwKeFk7rbLt+pbbjtSfBbwtyUUMN3DZawPW9zLg0e2LuK8BM1/SvbZ9GXcxw3crn2N4s7koyQUMb8rvqqprGd64P9bWfxbDR/u5vJHhngKnMuyLGS8HfjdDa6Qrgfu15a7M8MXjal/uzjHueODrDPvoNIbvFa6bmP4a4OkMp6mWA28B7tTmvwx483qeo3sAX0xyIcPr8/Vrme4bDG9CnwIOafvmfQxvABe2190RbOCRblX9kmEfv7M9xxcw/G/MuD7JWQzn3V88xyLezHDa6Ezg2onhbwF2anVdCDx2A/fnXLV+hmF/fLXtz+MYTvesyweAoxbTl7u2zqlRJbmhqtb3j6MFluTDwPE1z+3Lt+8zXl5VF87nenvnEb8kdcYjfknqjEf8ktQZg1+SOmPwS1JnDH5J6ozBL0md+S/Gfk2vOHWfIAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "similar_frequency_df2 = similar_frequency_df.groupby(\"Guess\", as_index = True).Tesseract.nunique()\n",
    "# similar_frequency_df2\n",
    "print(similar_frequency_df2.mean())\n",
    "plt.hist(similar_frequency_df2)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens per replacement\")\n",
    "plt.ylabel(\"Count\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tesseract_frequency = similar_frequency_df.Tesseract.value_counts()\n",
    "plt.hist(tesseract_frequency, 200)\n",
    "plt.xlabel(\"Unique tokens' frequency of appearance\")\n",
    "#plt.show suppresses the annoying array printout\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The scatter plot below plots number of unique Teseract tokens for each replacement token against the mean of the degree to which they are similar. The histogram above suggests that there are many 1:1 unique replacements. However, the degrees of similarities are very much clustered and show little variance as compared to the other replacement tokens. Suprisingly, the mean degree of similarity are rather *uniformly high*. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Degree similarity (%)')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## agg fn allows insertion of functions or list of functions which are then returned as multindex cols\n",
    "similar_frequency_df3 = similar_frequency_df.groupby(\"Guess\", as_index = False).agg({\n",
    "    \"Tesseract\": \"nunique\",\n",
    "    \"Similarity\": \"mean\"\n",
    "})\n",
    "plt.scatter(similar_frequency_df3.Tesseract, similar_frequency_df3.Similarity)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens\")\n",
    "plt.ylabel(\"Degree similarity (%)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Guess</th>\n",
       "      <th>Tesseract</th>\n",
       "      <th>Similarity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10th</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>11th</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>13th</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>17th</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>19th</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>89</th>\n",
       "      <td>Watts</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>90</th>\n",
       "      <td>West</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>91</th>\n",
       "      <td>Willett</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>92</th>\n",
       "      <td>William</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>93</th>\n",
       "      <td>Wooster</td>\n",
       "      <td>1</td>\n",
       "      <td>100</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>94 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      Guess  Tesseract  Similarity\n",
       "0      10th          1         100\n",
       "1      11th          1         100\n",
       "2      13th          1         100\n",
       "3      17th          1         100\n",
       "4      19th          1         100\n",
       "..      ...        ...         ...\n",
       "89    Watts          1         100\n",
       "90     West          1         100\n",
       "91  Willett          1         100\n",
       "92  William          1         100\n",
       "93  Wooster          1         100\n",
       "\n",
       "[94 rows x 3 columns]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "similar_frequency_df3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As compared to the highly similar tokens and their replacements, the number of unique Tesseract tokens for each **dissimilar** replacement token has increased dramatically. But at the same time, most Tesseract tokens occur at very low frequencies. That is to say, Tesseract's recognition and rendition of these tokens is inconsistent. This interpretation of the data implies that the master list against which this is compared is exhaustive and correct; as a result, if Tesseract is consistent, there should be less unique tokens, but they should occur more frequently.  \n",
    "On the other hand, it might just be the case that the master list is *non-exhaustive* and does not capture the full variance of street names in NYC at the turn of the 20th century. In this case, the questions becomes, \"How can Tesseract's output be verified?\" "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Count')"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dissimilar_frequency_df2 = dissimilar_frequency_df.groupby(\"Guess\", as_index = True).Tesseract.nunique()\n",
    "#dissimilar_frequency_df2\n",
    "#dissimilar_frequency_df2.mean()\n",
    "plt.hist(dissimilar_frequency_df2)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens per replacement\")\n",
    "plt.ylabel(\"Count\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "tesseract_frequency_dissimilar = dissimilar_frequency_df.Tesseract.value_counts()\n",
    "plt.hist(tesseract_frequency_dissimilar, 100)\n",
    "plt.xlabel(\"Unique tokens' frequency of appearance\")\n",
    "#plt.show suppresses the annoying array printout\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Degree similarity (%)')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "## agg fn allows insertion of functions or list of functions which are then returned as multindex cols\n",
    "dissimilar_frequency_df3 = dissimilar_frequency_df.groupby(\"Guess\", as_index = False).agg({\n",
    "    \"Tesseract\": \"nunique\",\n",
    "    \"Similarity\": \"mean\"\n",
    "})\n",
    "plt.scatter(dissimilar_frequency_df3.Tesseract, dissimilar_frequency_df3.Similarity)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens\")\n",
    "plt.ylabel(\"Degree similarity (%)\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, some occur more frequently than others. Examples include \"bway\", \"bklyn\", \"mkt\", and \"gwich\" which we intuitively know to be Broadway, Brooklyn, Market, and Greenwich."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Guess</th>\n",
       "      <th>Similarity</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tesseract</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>j</th>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bklyn</th>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>pl</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>a</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>st</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ek</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ct</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>c</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>see</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>eb</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ay</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ke</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>i</th>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>m</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mkt</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hs</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hr</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mundell</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>138th</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>r</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>newcomb</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>h379</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>richardson</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>t</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>tremont</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>var</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>washn</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>way</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>highth</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>g</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>h18</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>cheever</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>62d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>88th</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>b</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>baltic</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>bwa</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>h</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dugan</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>emg</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>england</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>ewt</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>fifck</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>frederick</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22d</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>greenpoint</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>westchester</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Guess  Similarity\n",
       "Tesseract                     \n",
       "j                4           4\n",
       "bklyn            4           4\n",
       "pl               3           3\n",
       "a                3           3\n",
       "st               2           2\n",
       "ek               2           2\n",
       "ct               2           2\n",
       "c                2           2\n",
       "see              2           2\n",
       "eb               2           2\n",
       "ay               2           2\n",
       "ke               2           2\n",
       "i                2           2\n",
       "m                1           1\n",
       "mkt              1           1\n",
       "hs               1           1\n",
       "hr               1           1\n",
       "mundell          1           1\n",
       "138th            1           1\n",
       "r                1           1\n",
       "newcomb          1           1\n",
       "h379             1           1\n",
       "richardson       1           1\n",
       "t                1           1\n",
       "tremont          1           1\n",
       "var              1           1\n",
       "washn            1           1\n",
       "way              1           1\n",
       "highth           1           1\n",
       "g                1           1\n",
       "h18              1           1\n",
       "cheever          1           1\n",
       "23d              1           1\n",
       "32d              1           1\n",
       "33d              1           1\n",
       "62d              1           1\n",
       "88th             1           1\n",
       "b                1           1\n",
       "baltic           1           1\n",
       "bwa              1           1\n",
       "d                1           1\n",
       "h                1           1\n",
       "dugan            1           1\n",
       "emg              1           1\n",
       "england          1           1\n",
       "ewt              1           1\n",
       "fifck            1           1\n",
       "frederick        1           1\n",
       "22d              1           1\n",
       "greenpoint       1           1\n",
       "westchester      1           1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dissimilar_frequency_df.groupby(\"Tesseract\").count().sort_values(by=\"Guess\", ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Symspell\n",
    "This is an alternative to fuzzy matching that should be faster. Like fuzzy matching, it matches entries with known values from an imported dictionary that is streetnames text file. Like fuzzy matching, it is a form of character embedding.\n",
    "Unlike fuzzy matching, the metric of concern here is the number of edits required to make a match. In this case, we have set the maximum number of edits to be 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding to the dictionary\n",
    "sym_spell = SymSpell(max_dictionary_edit_distance=5)\n",
    "sym_spell.create_dictionary(street_names_txt)\n",
    "# print(sym_spell.words)\n",
    "\n",
    "# Creating a vector of tokens\n",
    "## Sample\n",
    "locations_vec = locations_tsv_trunc.token_re.tolist()\n",
    "## Population\n",
    "#locations_vec = locations_tsv.token_re.tolist()\n",
    "\n",
    "def replacement(tokens):\n",
    "\n",
    "    # Creating lists to populate\n",
    "    num_edits = []\n",
    "    distance = []\n",
    "    replacement = []\n",
    "    \n",
    "    # Starting replacement\n",
    "    for token in tokens:\n",
    "        suggestion = sym_spell.lookup(token, Verbosity.TOP, max_edit_distance = 5, include_unknown = True)\n",
    "        \n",
    "        for suggestions in suggestion:\n",
    "            suggestitem = str(suggestions)\n",
    "            suggestitem = suggestitem.split(\",\")\n",
    "            replacement.append(suggestitem[0])\n",
    "            num_edits.append(suggestitem[1])\n",
    "            distance.append(suggestitem[2])\n",
    "    \n",
    "    # Creating a replacement df\n",
    "    replacement_df = pd.DataFrame({\"Tesseract\": tokens,\n",
    "                    \"Guess\": replacement,\n",
    "                    \"Edits\": num_edits,               \n",
    "                    \"Similarity\": distance})\n",
    "    return replacement_df\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.22062129999994795\n"
     ]
    }
   ],
   "source": [
    "start = timer()\n",
    "replacement_df = replacement(locations_vec)\n",
    "end = timer()\n",
    "print(end - start)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But looking at this, some things do not make sense. For example, why is the similarity 6 when number of edits = 0? Or, why is the similarity the same for tokens that were edited and those that were not? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Tesseract</th>\n",
       "      <th>Guess</th>\n",
       "      <th>Edits</th>\n",
       "      <th>Similarity</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>249</th>\n",
       "      <td>47th</td>\n",
       "      <td>47th</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>335</th>\n",
       "      <td>e</td>\n",
       "      <td>e</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>333</th>\n",
       "      <td>e</td>\n",
       "      <td>e</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>332</th>\n",
       "      <td>269</td>\n",
       "      <td>26th</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>331</th>\n",
       "      <td>470</td>\n",
       "      <td>47th</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>205</th>\n",
       "      <td>first</td>\n",
       "      <td>first</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>460</th>\n",
       "      <td>seventh</td>\n",
       "      <td>seventh</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>164</th>\n",
       "      <td>seventh</td>\n",
       "      <td>seventh</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ninth</td>\n",
       "      <td>ninth</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>fifck</td>\n",
       "      <td>fifty</td>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>500 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Tesseract    Guess Edits Similarity\n",
       "249      47th     47th     0          1\n",
       "335         e        e     0          1\n",
       "333         e        e     0          1\n",
       "332       269     26th     2          1\n",
       "331       470     47th     2          1\n",
       "..        ...      ...   ...        ...\n",
       "205     first    first     0          6\n",
       "460   seventh  seventh     0          6\n",
       "164   seventh  seventh     0          6\n",
       "0       ninth    ninth     0          6\n",
       "95      fifck    fifty     2          9\n",
       "\n",
       "[500 rows x 4 columns]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "replacement_df.sort_values(by = \"Similarity\", ascending = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### chars2vec\n",
    "\n",
    "https://medium.com/hackernoon/chars2vec-character-based-language-model-for-handling-real-world-texts-with-spelling-errors-and-a3e4053a147d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a good way to visualize but I am not sure what we can achieve with this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import chars2vec\n",
    "import sklearn.decomposition\n",
    "\n",
    "# Load model\n",
    "c2v_model = chars2vec.load_model('eng_300')\n",
    "\n",
    "# Streetnames\n",
    "locations = []\n",
    "locations.extend(street_names_txt)\n",
    "## Population\n",
    "#locations_vec = locations_tsv.token_re.tolist()\n",
    "\n",
    "\n",
    "# Create word embeddings based on a list of location tokens\n",
    "embeddings = c2v_model.vectorize_words(locations_vec)\n",
    "\n",
    "# Project embeddings on plane using PCA\n",
    "projection_2d = sklearn.decomposition.PCA(n_components=2).fit_transform(embeddings)\n",
    "\n",
    "# Plot\n",
    "f = plt.figure(figsize=(8, 6))\n",
    "for j in range(len(projection_2d)):\n",
    "    plt.scatter(projection_2d[j, 0], projection_2d[j, 1],\n",
    "                marker=('$' + locations_vec[j] + '$'),\n",
    "                s=100 * len(locations_vec[j]), label=j,\n",
    "                facecolors='green' if locations_vec[j] \n",
    "                           in street_names_txt else 'black')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Occupations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print((occupations_tsv.token.nunique()))\n",
    "occupations_tsv.head(n = 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some pre-processing here:  \n",
    "1) Removed punctuation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function remove punctuation; converts plural to singular; removing single-lettered entries; remove names; remove completely capitalized nouns \n",
    "def clean_token(token):\n",
    "    token = str(token)\n",
    "    # check for names\n",
    "    title_case = token.istitle()\n",
    "    if title_case is True:\n",
    "        token = \"\"\n",
    "        return token\n",
    "    else:\n",
    "        # check and correct for punctuation\n",
    "        token = ''.join(t for t in token if t.isalnum())\n",
    "        # check for numbers\n",
    "        numeral = token.isdigit()\n",
    "        if numeral is True:\n",
    "            token = \"\"\n",
    "            return token\n",
    "        # remove single entries\n",
    "        if len(token) == 1: \n",
    "            token = \"\"\n",
    "            return token\n",
    "        # remove completely capitalized words because they might be from adverts\n",
    "        caps = token.isupper()\n",
    "        if caps is True:\n",
    "            token = \"\"\n",
    "            return token\n",
    "        # check and stems plural nouns\n",
    "        elif token.endswith(\"s\"):\n",
    "            token = token.rstrip(\"s\")\n",
    "            return token\n",
    "        else:\n",
    "            return token\n",
    "\n",
    "# apply to column and create new column\n",
    "occupations_tsv_working_copy = occupations_tsv\n",
    "occupations_tsv_working_copy[\"token_re\"] = occupations_tsv_working_copy[\"token\"].apply(clean_token)\n",
    "\n",
    "# drop rows with just whitespace\n",
    "occupations_tsv_working_copy = occupations_tsv_working_copy.drop(occupations_tsv_working_copy[(occupations_tsv_working_copy.token_re == '')].index)\n",
    "\n",
    "occupations_freq = occupations_tsv_working_copy[\"token_re\"].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupations_freq.head(n = 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupations_freq.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assuming that Tesseract makes text recognition errors systematically and randomly, it can therefore be expected that variations of the same word is scattered throughout the dataset. Hence, less frequently occuring words can be matched to more frequently occurring one repeatedly until it coalesces to a more \"correct\" list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupations_freq_df = pd.DataFrame(occupations_tsv_working_copy.groupby(\"token_re\", \n",
    "                                                                        as_index = False)[\"token\"].count()).sort_values(by = \"token\",\n",
    "                                                                                                                        ascending = False).reset_index(drop = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Take each quartiles and compare similarities\n",
    "q1 = int(len(occupations_freq_df)/4)\n",
    "occupations_freq_q4 = occupations_freq_df.tail(n = q1)\n",
    "occupations_freq_q3 = occupations_freq_df.iloc[2*q1:3*q1,]\n",
    "occupations_freq_q1 = occupations_freq_df.iloc[:q1, ]\n",
    "occupations_freq_q234 = occupations_freq_df.iloc[q1:,]\n",
    "\n",
    "# Reuse the fuzzy_match function from before\n",
    "# Create lists for similar and dissimilar tokens\n",
    "choices = occupations_freq_q1.token_re.tolist()\n",
    "occ_tesseract_s = []\n",
    "occ_pct_similarity_s = []\n",
    "occ_best_guess_s = []\n",
    "occ_tesseract_d = []\n",
    "occ_pct_similarity_d = []\n",
    "occ_best_guess_d = []\n",
    "occ_overall_similarity = []\n",
    "#def fuzzy_match(x, choices=master_street_names, scorer=fuzz.token_sort_ratio, \n",
    "#                tesseract_s = tesseract_s, pct_similarity_s = pct_similarity_s, best_guess_s = best_guess_s,\n",
    "#                tesseract_d = tesseract_d, pct_similarity_d = pct_similarity_d, best_guess_d = best_guess_d)\n",
    "\n",
    "occupations_freq_q234.loc[\"token_replaced\"] = occupations_freq_q234[\"token_re\"].apply(\n",
    "    fuzzy_match,\n",
    "    args = (choices,\n",
    "            fuzz.token_sort_ratio,\n",
    "            90,\n",
    "            occ_tesseract_s,\n",
    "            occ_pct_similarity_s,\n",
    "            occ_best_guess_s,\n",
    "            occ_tesseract_d,\n",
    "            occ_pct_similarity_d,\n",
    "            occ_best_guess_d)\n",
    ")\n",
    "\n",
    "# Put the lists from replacement fn above into a df\n",
    "## Dissimilarity\n",
    "occ_dissimilar_frequency_df_q234vq1 = pd.DataFrame({\"Tesseract\": occ_tesseract_d,\n",
    "                    \"Guess\": occ_best_guess_d,\n",
    "                    \"Similarity\": occ_pct_similarity_d}) \n",
    "## Similarity\n",
    "occ_similar_frequency_df_q234vq1 = pd.DataFrame({\"Tesseract\": occ_tesseract_s,\n",
    "                    \"Guess\": occ_best_guess_s,\n",
    "                    \"Similarity\": occ_pct_similarity_s}) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occupations_freq_q1.token.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First round of fuzzy matching with the first quartile used as a basis of comparison. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Similarity distribution\n",
    "occ_overall_similarity = pd.concat([occ_dissimilar_frequency_df_q234vq1, occ_similar_frequency_df_q234vq1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_overall_similarity.extend(occ_pct_similarity_d)\n",
    "occ_overall_similarity = np.array(occ_overall_similarity)\n",
    "#occ_overall_similarity = pd.DataFrame(occ_overall_similarity.append(occ_pct_similarity_s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_overall_similarity.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.hist(occ_overall_similarity.Similarity, bins = 20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Second round of fuzzy matching: The basis of comparison are the ones that were successfully matched. This enables mapping onto the first quartile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "choices = occ_similar_frequency_df_q234vq1.Tesseract.tolist()\n",
    "occ_tesseract_s = []\n",
    "occ_pct_similarity_s = []\n",
    "occ_best_guess_s = []\n",
    "occ_tesseract_d = []\n",
    "occ_pct_similarity_d = []\n",
    "occ_best_guess_d = []\n",
    "occ_dissimilar_frequency_df_q234vq1.loc[\"Guess2\"] = occ_dissimilar_frequency_df_q234vq1[\"Tesseract\"].apply(\n",
    "    fuzzy_match,\n",
    "    args = (choices,\n",
    "            fuzz.token_sort_ratio,\n",
    "            80,\n",
    "            occ_tesseract_s,\n",
    "            occ_pct_similarity_s,\n",
    "            occ_best_guess_s,\n",
    "            occ_tesseract_d,\n",
    "            occ_pct_similarity_d,\n",
    "            occ_best_guess_d)\n",
    ")\n",
    "# Put the lists from replacement fn above into a df\n",
    "## Dissimilarity\n",
    "occ_q234_remainder_dissimilar_frequency_df = pd.DataFrame({\"Tesseract\": occ_tesseract_d,\n",
    "                    \"Guess\": occ_best_guess_d,\n",
    "                    \"Similarity\": occ_pct_similarity_d}) \n",
    "## Similarity\n",
    "occ_q234_remainder_similar_frequency_df = pd.DataFrame({\"Tesseract\": occ_tesseract_s,\n",
    "                    \"Guess\": occ_best_guess_s,\n",
    "                    \"Similarity\": occ_pct_similarity_s})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_q234_remainder_similar_frequency_df.iloc[620:680,]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "occ_q234_remainder_similar_frequency_df.Tesseract.value_counts().sort_values(ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_q234_remainder_similar_frequency_df.Guess.value_counts().sort_values(ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_q234_remainder_dissimilar_frequency_df.Tesseract.value_counts().sort_values(ascending = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorted by frequency of occurrence, 12% of the tokens in the bottom 75% can be mapped with a high level of confidence to those in the first quartile.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df_q234vq1.Tesseract.value_counts().sort_values(ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df_q234vq1.sort_values(by = 'Similarity')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df_q234vq1.Guess.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this suggests that there is great variance in Tesseract's text recognition\n",
    "occ_similar_frequency_df_q234vq1.Tesseract.value_counts().sort_values(ascending = False).head(n = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df2_q234vq1 = occ_similar_frequency_df_q234vq1.groupby(\"Guess\", as_index = True).Tesseract.nunique()\n",
    "plt.hist(occ_similar_frequency_df2_q234vq1, 35)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens per replacement\")\n",
    "plt.ylabel(\"Count\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_dissimilar_frequency_df_q234vq1.Guess.value_counts().head(n = 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_dissimilar_frequency_df_q234vq1.Tesseract.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df_q4vq1.sort_values(by = 'Similarity')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_dissimilar_frequency_df_q4vq1.sort_values(by=\"Similarity\", ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_dissimilar_frequency_df_q4vq1.Guess.value_counts().head(n = 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with the addresses, most Q3 replacements only have one corresponding Q4 token. Further, all of these tokens are unique. Previously, *dissimilarity* with addresses was positively correlated with higher variance in Tesseract's recognition of the same \"correct\" token. Likewise, this has occurred here where less frequently occurring tokens are part of Tesseract's recognition error.    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_similar_frequency_df2_q4vq1 = occ_similar_frequency_df_q4vq1.groupby(\"Guess\", as_index = True).Tesseract.nunique()\n",
    "plt.hist(occ_similar_frequency_df2_q4vq1)\n",
    "plt.xlabel(\"Number of unique Tesseract tokens per replacement\")\n",
    "plt.ylabel(\"Count\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_tesseract_frequency = occ_similar_frequency_df.Tesseract.value_counts()\n",
    "plt.hist(occ_tesseract_frequency)\n",
    "plt.xlabel(\"Unique tokens' frequency of appearance\")\n",
    "#plt.show suppresses the annoying array printout\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "occ_dissimilar_frequency_df.sort_values(by = \"Similarity\", ascending = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "int(len(occupations_freq_df)/4)\n",
    "len(occupations_freq_q4)\n",
    "choices = occupations_freq_q3.token_re.tolist()\n",
    "choices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subjects/Names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(subjects_tsv.entry_uuid.nunique())\n",
    "subjects_tsv.head(n = 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discarded | Obsolete Code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initially, I thought that we might be able to correct some of the spelling errors presented by Tesseract. To test this, I applied this to a sample of occupations given that occupations are more likely to be found in a proper English dictionary than street and human names. However, the results are extremely poor due to the abbrieviations and Tesseract-errors. Furthermore, some words such as `segars` are the antiquated form of modern words such as `cigars` which the module does not pick up on. Instead, it suggests `sugars`, which is not technically wrong from a word-matching and spell-check standpoint. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.clips.uantwerpen.be/pages/pattern-en#spelling\n",
    "# https://rustyonrampage.github.io/text-mining/2017/11/28/spelling-correction-with-python-and-nltk.html\n",
    "# https://www.nltk.org/\n",
    "\n",
    "\"\"\"\"\n",
    "from pattern.en import suggest\n",
    "\n",
    "#occupations sample\n",
    "occupations_sample = occupations_freq_res.loc[:, [\"original\"]].sample(n = 100)\n",
    "occupations_freq_res = occupations_freq.reset_index()\n",
    "occupations_freq_res = occupations_freq_res.rename(columns = {\"index\": \"original\"})\n",
    "occupations_freq_res = occupations_freq_res.astype({\"original\": str})\n",
    "\n",
    "# spellcheck function with suggest\n",
    "def spellcheck(token):\n",
    "    digit_check = token.isdigit()\n",
    "    if digit_check is True:\n",
    "        return token\n",
    "    else:\n",
    "        checked = suggest(token)\n",
    "        return checked\n",
    "    \n",
    "# Apply to sample\n",
    "occupations_sample[\"corrected\"] = occupations_sample[\"original\"].apply(spellcheck)\n",
    "\n",
    "# Glimpse into result\n",
    "occupations_sample.head(n = 60)\n",
    "\"\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Link](https://stackoverflow.com/questions/40712178/reading-the-json-file-with-multiple-objects-in-python) to help with decoding this particular JSON object. Multiple JSON object within one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Opens the file and saves it to a pandas df\n",
    "##with open(path + test_json) as f:\n",
    "##    df = pd.read_json(f, lines=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quick look into the JSON table to check\n",
    "##df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Manual uniqueness check\n",
    "##line_number = np.array(df.original_hocr_line_number)\n",
    "##unique_elements, counts_elements = np.unique(line_number, return_counts=True)\n",
    "##print(\"Frequency of unique values of the said array:\")\n",
    "##print(np.asarray((unique_elements, counts_elements)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Labels \"a\", \"h\", and \"r\" represent the relative addresses, and address types such as houses, and rear."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Quick glimpse of how the last column might actually look like\n",
    "## df.iloc[124,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df.iloc[110,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df.iloc[10,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df.iloc[4,-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df.iloc[147, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df_labeled_entry = df.labeled_entry.apply(pd.Series)\n",
    "##df_locations = df_labeled_entry[\"locations\"]\n",
    "##df_locations = pd.concat([df_locations, df.original_hocr_line_number], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df_locations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df_locations.iloc[147,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##type(df_locations.iloc[147,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##type(df_locations.iloc[147,0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df_locations.iloc[147][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, each labeled entry's location is stored as a list of _n_ dictionaries with two key-value pairs of `value` and `labels`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##df_locations.iloc[3][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##type(df_locations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This checks for existence of labels, duly records the (non)existence, strips it out, appends to another list\n",
    "# This is done w/o loss to order\n",
    "\n",
    "#line_num_list = []\n",
    "#complete_street_name = []\n",
    "#split_street_name = []\n",
    "#labels = []\n",
    "#for entry in range(0,len(df_locations)):\n",
    "#    #print(df_locations.iloc[entry])\n",
    "#    for dicts in df_locations.iloc[entry][0]:\n",
    "#        if 'labels' in dicts:\n",
    "#            for key, value in dicts.items():\n",
    "#                #line_num_list.append(df_locations.iloc[entry][1])\n",
    "#                if key == 'labels':\n",
    "#                    labels.append(value)\n",
    "#                else:\n",
    "#                    complete_street_name.append(value)\n",
    "#                    street_name_split = str(value).split()\n",
    "#                    split_street_name.append(street_name_split)\n",
    "#                    line_num_list.append(df_locations.iloc[entry][1])\n",
    "#        else:\n",
    "#            for key, value in dicts.items():\n",
    "#                line_num_list.append(df_locations.iloc[entry][1])\n",
    "#                labels.append(\" \")\n",
    "#                complete_street_name.append(value)\n",
    "#                street_name_split = str(value).split()\n",
    "#                split_street_name.append(street_name_split)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that avenues are spelled out and streets are enumerated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#split_street_name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#unlisted_location = pd.concat([pd.Series(complete_street_name), pd.Series(split_street_name), pd.Series(labels), pd.Series(line_num_list)], axis = 1)\n",
    "#unlisted_location.columns = [\"complete_street_name\", \"split_street_name\", \"labels\", \"line_number\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#len(line_num_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#unlisted_location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# first order of business is to test if string is a street number\n",
    "# if it is not, then it is probably a street name, and a comparison can be made\n",
    "# Perform regex to remove the periods\n",
    "# https://www.datacamp.com/community/tutorials/fuzzy-string-python\n",
    "# https://datascience.stackexchange.com/questions/29775/how-to-check-and-correct-misspelling-in-the-data-of-pairs-of-words\n",
    "# http://blog.keyrus.co.uk/fuzzy_matching_101_part_i.html\n",
    "# http://blog.keyrus.co.uk/fuzzy_matching_101_part_ii.html\n",
    "\n",
    "#for i in range(0, len(unlisted_location)):\n",
    "#    non_numeric_street_name = []\n",
    "#    for address_component in unlisted_location.iloc[i, 1]:\n",
    "#        if address_component.isnumeric() == False:\n",
    "#            non_numeric_street_name.append(address_component)\n",
    "#            print(non_numeric_street_name)\n",
    "#        unlisted_location.iloc[i][\"non_numeric\"] = non_numeric_street_name\n",
    "            \n",
    "#        #print(address_component.isnumeric())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#unlisted_location"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}