{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TF-IDF for tabular data featurization and classification\n",
    "\n",
    "This notebook describes applying TF-IDF to database columns. It generate some synthetic data, featurizers the data, applies TF-IDF and visualizes the results with t-SNE. There is a corresponding blog post at [LINK HERE]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Load some libraries and set some plotting configurations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set()\n",
    "sns.set_style(\"whitegrid\")\n",
    "sns.set_context(\"paper\", \n",
    "                rc={\"font.size\":8,\"axes.labelsize\":10,\n",
    "                    \"xtick.labelsize\":10, \"ytick.labelsize\":10})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.manifold import TSNE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import OrderedDict, Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from faker import Faker\n",
    "fake = Faker()\n",
    "fake.seed(101)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some useful functions and variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "synthetic_data_factories = OrderedDict({\"email\": fake.email, \n",
    "             \"phone_number\": fake.phone_number, \n",
    "             \"float_number\": lambda: str(np.random.uniform(-180, 180)), \n",
    "             \"binary_number\": lambda: str(np.random.randint(0, 2)),\n",
    "             \"UUID\": fake.uuid4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "placeholders = OrderedDict({\"-\": 1, \"\": 1, \"0\": 1})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def simulated_column_data(factory, num_rows, placeholders, placeholder_probability=0):\n",
    "    column = []\n",
    "    placeholder_selection_frequency = [\n",
    "        val / sum(placeholders.values()) for val in placeholders.values()\n",
    "    ]\n",
    "    for _ in range(num_rows):\n",
    "        is_placeholder = np.random.uniform(0, 1) < placeholder_probability\n",
    "        placeholder_value = np.random.choice(\n",
    "            list(placeholders.keys()), \n",
    "            size=1, \n",
    "            p=placeholder_selection_frequency)[0]\n",
    "        if is_placeholder:\n",
    "            cell_value = placeholder_value\n",
    "        else:\n",
    "            cell_value = factory()\n",
    "        column.append(cell_value)\n",
    "    return column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### generate the synthetic data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe_list = []\n",
    "placeholder_prob = 0.9\n",
    "columns_per_class = 20\n",
    "labels = []\n",
    "for data_class, synthetic_data_factory in synthetic_data_factories.items():\n",
    "    for column_idx in range(columns_per_class):\n",
    "        labels.append(data_class)\n",
    "        \n",
    "        df = pd.DataFrame(\n",
    "            {\"column_name\": \"{}{:03d}\".format(data_class, column_idx+1),\n",
    "             \"data_class\": data_class, \n",
    "             \"cell_value\": simulated_column_data(\n",
    "                 synthetic_data_factory, \n",
    "                 100, \n",
    "                 placeholders, \n",
    "                 placeholder_prob\n",
    "             )\n",
    "            }\n",
    "        )\n",
    "        dataframe_list.append(df)\n",
    "df = pd.concat(dataframe_list, axis=0)\n",
    "labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common values. Note that values are typically very common (placeholders) or unique (authentic data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('0', 3083),\n",
       " ('', 3057),\n",
       " ('-', 2950),\n",
       " ('1', 102),\n",
       " ('sanfordsandra@yahoo.com', 1),\n",
       " ('walkerkeith@hotmail.com', 1),\n",
       " ('kjones@carrillo.com', 1),\n",
       " ('richard31@torres-rodriguez.net', 1),\n",
       " ('nicole66@gmail.com', 1),\n",
       " ('robert73@reed-johnson.info', 1)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(df.cell_value).most_common(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Featurizers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "import uuid\n",
    "import phonenumbers\n",
    "\n",
    "def regex_feature(value, patt):\n",
    "    return re.search(patt, value.strip().lower()) is not None\n",
    "       \n",
    "def matches_email(value):\n",
    "    patt = (\n",
    "        r\"^([a-z0-9!#$%&'*+\\/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+\\/=?^_`{|}~-]+)*\"\n",
    "        # Doesn't start with a period\n",
    "        r\"(@|\\sat\\s)\"  # requires `at` clause\n",
    "        r\"(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\"  # domain name doesn't start or end with a hyphen\n",
    "        r\"(\\.|\\sdot\\s))+\"  # one or more second level domains\n",
    "        r\"[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)$\"  # top level domain doesn't start or end in a hyphen\n",
    "    )\n",
    "    return regex_feature(value, patt)\n",
    "\n",
    "def matches_uuid(value):\n",
    "    try:\n",
    "        uuid.UUID(value)\n",
    "        return True\n",
    "    except ValueError:\n",
    "        return False\n",
    "\n",
    "def matches_phone_number(value):\n",
    "    regions = [\"US\", None]\n",
    "    for region in regions:\n",
    "        try:\n",
    "            phone_number = phonenumbers.parse(value, region)\n",
    "            if phonenumbers.is_valid_number(phone_number):\n",
    "                return True\n",
    "        except phonenumbers.NumberParseException:\n",
    "            pass\n",
    "    return False\n",
    "\n",
    "def is_float(value):\n",
    "    try:\n",
    "        _ = float(value)\n",
    "        return True\n",
    "    except:\n",
    "        return False\n",
    "\n",
    "def is_int(value):\n",
    "    try:\n",
    "        _ = int(value)\n",
    "        return True\n",
    "    except:\n",
    "        return False\n",
    "    \n",
    "def is_len1(value):\n",
    "    return len(value) == 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "featurizers = OrderedDict({\n",
    "    \"email\": matches_email,\n",
    "    \"uuid\": matches_uuid,\n",
    "    \"phone_number\": matches_phone_number,\n",
    "    \"is_float\": is_float,\n",
    "    \"is_int\": is_int,\n",
    "    \"is_len1\": is_len1\n",
    "})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def featurize(value, featurizers):\n",
    "    return OrderedDict({feature_name: feature_value(value) for feature_name, feature_value in featurizers.items()})\n",
    "\n",
    "def stringify_features(value, featurizers):\n",
    "    return ''.join([str(int(binary_feature)) for binary_feature in featurize(value, featurizers).values()])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here are a few examples of featurization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('email', False),\n",
       "             ('uuid', False),\n",
       "             ('phone_number', False),\n",
       "             ('is_float', False),\n",
       "             ('is_int', False),\n",
       "             ('is_len1', False)])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featurize(\"---\", featurizers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('email', False),\n",
       "             ('uuid', False),\n",
       "             ('phone_number', False),\n",
       "             ('is_float', False),\n",
       "             ('is_int', False),\n",
       "             ('is_len1', True)])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featurize(\"-\", featurizers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('email', False),\n",
       "             ('uuid', False),\n",
       "             ('phone_number', True),\n",
       "             ('is_float', True),\n",
       "             ('is_int', True),\n",
       "             ('is_len1', False)])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "featurize(\"18005551212\", featurizers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of stringifying a feature set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'001110'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stringify_features(\"18005551212\", featurizers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the featurizers to the data and update the data frame. The Boolean features are turned into strings of 0 and 1 values which then form the **words** of our document set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[:, \"word\"] = df.cell_value.apply(lambda x: stringify_features(x, featurizers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most common feature words. Note that the bifurcation into placeholders and unique values has been removed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('000000', 3186),\n",
       " ('000111', 3185),\n",
       " ('000001', 2950),\n",
       " ('000100', 209),\n",
       " ('100000', 202),\n",
       " ('010000', 191),\n",
       " ('001000', 56),\n",
       " ('000110', 21)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(df.word).most_common()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generating documents\n",
    "\n",
    "Here we generate documents composed of feature words "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for actual terms\n",
    "docs_value = []\n",
    "for column_name in df.column_name.unique():\n",
    "    docs_value.append(\n",
    "        list(\n",
    "            df.query(\"column_name == \\\"{}\\\"\".format(column_name)).cell_value\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for feature words\n",
    "docs_words = []\n",
    "for column_name in df.column_name.unique():\n",
    "    docs_words.append(\n",
    "        list(\n",
    "            df.query(\"column_name == \\\"{}\\\"\".format(column_name)).word\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for unique values, i.e. sub-linear (binary) term frequency \n",
    "docs_unique = []\n",
    "for column_name in df.column_name.unique():\n",
    "    docs_unique.append(\n",
    "        list(\n",
    "            np.unique(df.query(\"column_name == \\\"{}\\\"\".format(column_name)).word)\n",
    "        )\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### TF-IDF vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# need an identity function to pass to TF-IDF \n",
    "# since we've already parsed the terms into documents\n",
    "def identity_fun(x):\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we define the TF-IDF vectorizer. The relevant arguments are:\n",
    "\n",
    "* `analyzer`: we analyze at the word level, as opposed to character n-gram level\n",
    "* `preprocessor`: function to preprocess the values. Because we've already processed them, the identity function is used.\n",
    "* `tokenizer`: function to tokenize the values. Because we've already tokenized them, the identity function is used.\n",
    "* `token_pattern`: regular expression to tokenize the inputs. Because we've already tokenized them, the identity function is used.\n",
    "* `sublinear_tf`: Boolean to apply sublinear (logarithmic) term-frequency. A sublinear (binary) term-frequency is more appropriate for this problem so we apply it in a preporocessing step below. \n",
    "* `smooth_idf`: Boolean to apply smooth inverse-document-frequency. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instantiate the TF-IDF vectorizer\n",
    "tfidf_mod = TfidfVectorizer(\n",
    "    analyzer='word',\n",
    "    preprocessor=identity_fun,\n",
    "    tokenizer=identity_fun,\n",
    "    token_pattern=None,\n",
    "    sublinear_tf=False,\n",
    "    smooth_idf=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate the TF-IDF vectors for each of the three variations of document\n",
    "tfidf_value = tfidf_mod.fit_transform(docs_value)\n",
    "tfidf_words = tfidf_mod.fit_transform(docs_words)\n",
    "tfidf_unique = tfidf_mod.fit_transform(docs_unique)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualizing results with T-SNE plotting\n",
    "\n",
    "Here we apply t-distributed stochastic neighbor embedding (t-SNE) to the TF-IDF vectors to visualize similarities. This algorithm provides a way of visualizing similarities between points in a high dimensional space by projecting them to a lower dimensional space (e.g. 2-dimensions) while approximately maintaining relative distances. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne_mod = TSNE(metric=\"cosine\", perplexity=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The actual-terms documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = tsne_mod.fit_transform(tfidf_value.todense())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_df = pd.DataFrame(Y).rename(columns={0: \"x1\", 1: \"x2\"})\n",
    "pl_df = pl_df.assign(data_class = labels)\n",
    "pl_df.to_csv(\"tsne_terms.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.scatterplot(x=\"x1\", y=\"x2\", hue=\"data_class\", style=\"data_class\", data=pl_df)\n",
    "plt.title(\"t-SNE: document actual terms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The feature-words documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = tsne_mod.fit_transform(tfidf_words.todense())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_df = pd.DataFrame(Y).rename(columns={0: \"x1\", 1: \"x2\"})\n",
    "pl_df = pl_df.assign(data_class = labels)\n",
    "pl_df.to_csv(\"tsne_tfidf.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = sns.scatterplot(x=\"x1\", y=\"x2\", hue=\"data_class\", style=\"data_class\", data=pl_df)\n",
    "plt.title(\"t-SNE: document feature words\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The feature-words documents with sub-linear (binary) term frequencies"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y = tsne_mod.fit_transform(tfidf_unique.todense())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_df = pd.DataFrame(Y).rename(columns={0: \"x1\", 1: \"x2\"})\n",
    "pl_df = pl_df.assign(data_class = labels)\n",
    "pl_df.to_csv(\"tsne_tfidf_uniq.csv\", index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = sns.scatterplot(x=\"x1\", y=\"x2\", hue=\"data_class\", style=\"data_class\", data=pl_df)\n",
    "plt.title(\"t-SNE: document feature words with binary term-frequency\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inverse-document values for the feature words, and the actual terms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 1.        , 2.57059808, 2.90707032, 1.        ,\n",
       "       2.67068154, 2.57059808, 2.57059808])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tfidf_mod.fit_transform(docs_words)\n",
    "tfidf_mod.idf_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 4.92197334, 4.92197334, 4.92197334, 4.92197334])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tfidf_mod.fit_transform(docs_value)\n",
    "tfidf_mod.idf_[0:5]"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}