tfidf-benchmark/NLP-pipeline-sklearn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b6754f50-9d5e-47f4-9353-72b8c79ebe31",
   "metadata": {},
   "source": [
    "# NLP tf-idf pipeline with scikit-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "639f8a3c-70da-4dd3-8e2e-655452dfa306",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from tqdm import tqdm\n",
    "from sklearn.feature_extraction.text import HashingVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "import nltk\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb82536f-408a-4ca9-865d-4406899fb987",
   "metadata": {},
   "source": [
    "### Import other utility functions for benchmarking purposes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b1b38723-f7fe-4e3c-a960-fb637e0bca1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import SimpleTimer, ResultsLogger, visualize_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5699ef8d-5bbb-4343-9815-e4635e1c6e32",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Benchmarking Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a866429-73aa-4973-8934-35818b075131",
   "metadata": {},
   "source": [
    "### Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7e870804-3011-4eb7-afa9-8836cf46cb9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     /home/nfs/anirband/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "nltk.download('stopwords')\n",
    "STOPWORDS = set(nltk.corpus.stopwords.words('english')) # converting the list to set will decrease latency in the pandas apply function: O(1) lookup\n",
    "PUNCTUATIONS = ['!', '\"', '#', '$', '%', '&', '(', ')', '*', '+', '-', '.',\n",
    "                '/', '\\\\', ':', ';', '<', '=', '>', '?', '@', '[', ']', '^',\n",
    "                '_', '`', '{', '|', '}', '\\t','\\n', \"'\", \",\", '~' , '—']\n",
    "\n",
    "def read_data(parquet_path):\n",
    "    data = pd.read_parquet(parquet_path, columns=[\"review_body\"])\n",
    "    return data\n",
    "\n",
    "\n",
    "def text_preprocessor(data, column_name, PUNCTUATIONS, STOPWORDS):\n",
    "    data = data[data[column_name].notna()]\n",
    "    # from https://stackoverflow.com/questions/50444346/fast-punctuation-removal-with-pandas\n",
    "    transtable = str.maketrans(dict.fromkeys(\"\".join(PUNCTUATIONS), ''))\n",
    "    data.loc[:,column_name] = (data[column_name].str.lower()\n",
    "                           .str.translate(transtable)\n",
    "                           .str.strip())\n",
    "    data.loc[:,column_name] = data[column_name].apply(lambda x: ' '.join([word for word in x.split() if word not in STOPWORDS]))                    \n",
    "    return data\n",
    "\n",
    "\n",
    "def hashing_vectorizer(data, column_name):\n",
    "    vectorizer = HashingVectorizer(stop_words=None, preprocessor=None)\n",
    "    hashing_vectorized = vectorizer.fit_transform(data[column_name])\n",
    "    return hashing_vectorized\n",
    "\n",
    "\n",
    "def tfidf_transformer(hashing_vectorized, column_name):\n",
    "    transformer = TfidfTransformer()\n",
    "    result = transformer.fit_transform(hashing_vectorized)\n",
    "    return result\n",
    "\n",
    "\n",
    "def execute_full_pipeline(n, i, parquet_path):\n",
    "    sample_record = {\"overall\":0, \"data_read\":0, \"hashing_vectorizer\":0, \"tfid_transformer\":0, \"data_preprocessing\":0, \"nrows\":0}\n",
    "    with SimpleTimer() as timer:\n",
    "        data = read_data(parquet_path)\n",
    "    sample_record[\"data_read\"]=timer.elapsed/1e9\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        data = text_preprocessor(data, \"review_body\", PUNCTUATIONS, STOPWORDS)\n",
    "    sample_record[\"data_preprocessing\"]=timer.elapsed/1e9\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        hashing_vectorized = hashing_vectorizer(data,\"review_body\")\n",
    "    sample_record[\"hashing_vectorizer\"]=timer.elapsed/1e9\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        result = tfidf_transformer(hashing_vectorized, \"review_body\")\n",
    "    sample_record[\"tfidf_transformer\"]=timer.elapsed/1e9\n",
    "\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished loading data in {sample_record['data_read']}s\")\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished preprocessing data in {sample_record['data_preprocessing']}s\")\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished fitting HashVectorizer in {sample_record['hashing_vectorizer']}s\")\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished fitting IDF Transformer in {sample_record['tfidf_transformer']}s\")\n",
    "    return data, result, sample_record\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d295c9d0-afae-4b68-8bfc-95e7d50cb911",
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_numbers(parquet_path, worker_counts=[1], samples=1, result_path=\"./results.csv\"):\n",
    "    \"\"\"\n",
    "    Main function to perform the performance sweep\n",
    "    \"\"\"\n",
    "    results_logger = ResultsLogger(result_path)\n",
    "    for n in worker_counts: \n",
    "        for i in tqdm(range(samples)): \n",
    "            with SimpleTimer() as overalltimer:\n",
    "                data, result, sample_record = execute_full_pipeline(n, i, parquet_path)\n",
    "            sample_record[\"overall\"]=overalltimer.elapsed/1e9\n",
    "            sample_record[\"nrows\"]=data.shape[0]\n",
    "            sample_record[\"n_workers\"]=n\n",
    "            sample_record[\"sample_run\"]=i\n",
    "            print(f\"Workers:{n}, Sample Run:{i}, Finished executing full pipeline in {overalltimer.elapsed/1e9}s\")\n",
    "            results_logger.log(sample_record)\n",
    "    results_logger.write()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d6d27907-94d5-414a-93ae-0997a887ff44",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = \"Books\"\n",
    "parquet_path = f'./data/product_category={dataset}'\n",
    "samples = 3\n",
    "worker_counts = [1]\n",
    "result_path = f\"./results/result_poc_nlp_sklearn_{dataset}.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "4da2c546-c633-4f77-9220-e0067add959c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                                                                                                                                                      | 0/3 [00:00<?, ?it/s]/home/nfs/anirband/anaconda3/envs/rapids-21.08/lib/python3.8/site-packages/pandas/core/indexing.py:1843: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  self.obj[item_labels[indexer[info_axis]]] = value\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished loading data in 27.176626497s\n",
      "Workers:1, Sample Run:0, Finished preprocessing data in 1241.842861926s\n",
      "Workers:1, Sample Run:0, Finished fitting HashVectorizer in 731.965263292s\n",
      "Workers:1, Sample Run:0, Finished fitting IDF Transformer in 123.351881592s\n",
      "Workers:1, Sample Run:0, Finished executing full pipeline in 2124.653676701s"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 33%|████████████████████████████████████████████████████████▋                                                                                                                 | 1/3 [35:24<1:10:49, 2124.65s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 67%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████▎                                                        | 2/3 [1:10:27<35:11, 2111.69s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished loading data in 26.745783126s\n",
      "Workers:1, Sample Run:1, Finished preprocessing data in 1239.419621929s\n",
      "Workers:1, Sample Run:1, Finished fitting HashVectorizer in 715.500205747s\n",
      "Workers:1, Sample Run:1, Finished fitting IDF Transformer in 120.634073774s\n",
      "Workers:1, Sample Run:1, Finished executing full pipeline in 2102.609042801s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 3/3 [1:45:45<00:00, 2115.24s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished loading data in 29.64475292s\n",
      "Workers:1, Sample Run:2, Finished preprocessing data in 1242.092643499s\n",
      "Workers:1, Sample Run:2, Finished fitting HashVectorizer in 719.101140476s\n",
      "Workers:1, Sample Run:2, Finished fitting IDF Transformer in 127.356223578s\n",
      "Workers:1, Sample Run:2, Finished executing full pipeline in 2118.43830324s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1h 43min 22s, sys: 11min 39s, total: 1h 55min 2s\n",
      "Wall time: 1h 46min 12s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "performance_numbers(parquet_path=parquet_path, worker_counts=worker_counts, samples=samples,result_path=result_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3bd627f9-0878-4296-bf73-151ec1b1bec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data, melt_data = visualize_data(result_path)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "3464bc13-4855-496e-8be8-235b028ca673",
   "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>overall</th>\n",
       "      <th>data_read</th>\n",
       "      <th>hashing_vectorizer</th>\n",
       "      <th>tfid_transformer</th>\n",
       "      <th>data_preprocessing</th>\n",
       "      <th>nrows</th>\n",
       "      <th>tfidf_transformer</th>\n",
       "      <th>n_workers</th>\n",
       "      <th>sample_run</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2124.653677</td>\n",
       "      <td>27.176626</td>\n",
       "      <td>731.965263</td>\n",
       "      <td>0</td>\n",
       "      <td>1241.842862</td>\n",
       "      <td>20725971</td>\n",
       "      <td>123.351882</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2102.609043</td>\n",
       "      <td>26.745783</td>\n",
       "      <td>715.500206</td>\n",
       "      <td>0</td>\n",
       "      <td>1239.419622</td>\n",
       "      <td>20725971</td>\n",
       "      <td>120.634074</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2118.438303</td>\n",
       "      <td>29.644753</td>\n",
       "      <td>719.101140</td>\n",
       "      <td>0</td>\n",
       "      <td>1242.092643</td>\n",
       "      <td>20725971</td>\n",
       "      <td>127.356224</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       overall  data_read  hashing_vectorizer  tfid_transformer  \\\n",
       "0  2124.653677  27.176626          731.965263                 0   \n",
       "1  2102.609043  26.745783          715.500206                 0   \n",
       "2  2118.438303  29.644753          719.101140                 0   \n",
       "\n",
       "   data_preprocessing     nrows  tfidf_transformer  n_workers  sample_run  \n",
       "0         1241.842862  20725971         123.351882          1           0  \n",
       "1         1239.419622  20725971         120.634074          1           1  \n",
       "2         1242.092643  20725971         127.356224          1           2  "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "36dc1a20-d436-4362-af91-75d4b6e829b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "groupy = data.groupby(\"n_workers\").agg(['mean', 'std', 'count'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c0ac4d3f-5d2f-4941-a984-adad8d15edb8",
   "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 tr th {\n",
       "        text-align: left;\n",
       "    }\n",
       "\n",
       "    .dataframe thead tr:last-of-type th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th colspan=\"3\" halign=\"left\">overall</th>\n",
       "      <th colspan=\"3\" halign=\"left\">data_read</th>\n",
       "      <th colspan=\"3\" halign=\"left\">hashing_vectorizer</th>\n",
       "      <th>tfid_transformer</th>\n",
       "      <th>...</th>\n",
       "      <th>data_preprocessing</th>\n",
       "      <th colspan=\"3\" halign=\"left\">nrows</th>\n",
       "      <th colspan=\"3\" halign=\"left\">tfidf_transformer</th>\n",
       "      <th colspan=\"3\" halign=\"left\">sample_run</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th></th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>...</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>count</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>n_workers</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2115.233674</td>\n",
       "      <td>11.366341</td>\n",
       "      <td>3</td>\n",
       "      <td>27.855721</td>\n",
       "      <td>1.564252</td>\n",
       "      <td>3</td>\n",
       "      <td>722.18887</td>\n",
       "      <td>8.655928</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>3</td>\n",
       "      <td>20725971</td>\n",
       "      <td>0.0</td>\n",
       "      <td>3</td>\n",
       "      <td>123.780726</td>\n",
       "      <td>3.381532</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "               overall                   data_read                  \\\n",
       "                  mean        std count       mean       std count   \n",
       "n_workers                                                            \n",
       "1          2115.233674  11.366341     3  27.855721  1.564252     3   \n",
       "\n",
       "          hashing_vectorizer                 tfid_transformer  ...  \\\n",
       "                        mean       std count             mean  ...   \n",
       "n_workers                                                      ...   \n",
       "1                  722.18887  8.655928     3                0  ...   \n",
       "\n",
       "          data_preprocessing     nrows            tfidf_transformer            \\\n",
       "                       count      mean  std count              mean       std   \n",
       "n_workers                                                                       \n",
       "1                          3  20725971  0.0     3        123.780726  3.381532   \n",
       "\n",
       "                sample_run             \n",
       "          count       mean  std count  \n",
       "n_workers                              \n",
       "1             3          1  1.0     3  \n",
       "\n",
       "[1 rows x 24 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "groupy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1443da3b-d74f-4369-b479-a0d31c436672",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}