tfidf-benchmark/NLP-pipeline-spark.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "826409b0-2bf6-403e-967b-2dda741e3577",
   "metadata": {},
   "source": [
    "# NLP tf-idf pipeline with Apache Spark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "639f8a3c-70da-4dd3-8e2e-655452dfa306",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from pyspark import SparkContext\n",
    "from pyspark.sql import SparkSession\n",
    "from pyspark import SparkConf, StorageLevel\n",
    "from tqdm import tqdm\n",
    "from pyspark.ml.feature import HashingTF, IDF, Tokenizer, StopWordsRemover\n",
    "import pyspark.sql.functions as f\n",
    "import nltk"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35119fcb-db90-4ee7-8afd-2d815ac64cb2",
   "metadata": {},
   "source": [
    "### Import other utility functions for benchmarking purposes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b9726f45-c428-4811-ad0e-f6dc6f62a2ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "from utils import SimpleTimer, ResultsLogger, visualize_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "163a5306-0e9d-47a8-af9e-3aa252b0277c",
   "metadata": {},
   "source": [
    "## Setting up the spark cluster"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4fb60a49-0290-4f68-ba72-14d148de6565",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "21/08/11 08:43:57 WARN Utils: Your hostname, dgx05 resolves to a loopback address: 127.0.0.1; using 10.33.227.155 instead (on interface enp1s0f0)\n",
      "21/08/11 08:43:57 WARN Utils: Set SPARK_LOCAL_IP if you need to bind to another address\n",
      "WARNING: An illegal reflective access operation has occurred\n",
      "WARNING: Illegal reflective access by org.apache.spark.unsafe.Platform (file:/home/nfs/anirband/anaconda3/envs/rapids-21.08/lib/python3.8/site-packages/pyspark/jars/spark-unsafe_2.12-3.1.2.jar) to constructor java.nio.DirectByteBuffer(long,int)\n",
      "WARNING: Please consider reporting this to the maintainers of org.apache.spark.unsafe.Platform\n",
      "WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations\n",
      "WARNING: All illegal access operations will be denied in a future release\n",
      "21/08/11 08:43:58 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n",
      "Using Spark's default log4j profile: org/apache/spark/log4j-defaults.properties\n",
      "Setting default log level to \"WARN\".\n",
      "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n",
      "21/08/11 08:43:58 WARN SparkConf: Note that spark.local.dir will be overridden by the value set by the cluster manager (via SPARK_LOCAL_DIRS in mesos/standalone/kubernetes and LOCAL_DIRS in YARN).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('spark.driver.maxResultSize', '20G'), ('spark.app.id', 'local-1628696639107'), ('spark.driver.host', '10.33.227.155'), ('spark.executor.id', 'driver'), ('spark.driver.port', '42921'), ('spark.local.dir', '/raid/tfidf_benchmark/'), ('spark.app.startTime', '1628696638294'), ('spark.rdd.compress', 'True'), ('spark.network.timeout', '7200s'), ('spark.app.name', 'SparkVectorizer'), ('spark.serializer.objectStreamReset', '100'), ('spark.driver.memory', '300G'), ('spark.master', 'local[*]'), ('spark.submit.pyFiles', ''), ('spark.submit.deployMode', 'client'), ('spark.ui.showConsoleProgress', 'true')]\n"
     ]
    }
   ],
   "source": [
    "conf = (SparkConf().setMaster(\"local[*]\")\n",
    "                .setAppName(\"SparkVectorizer\")\n",
    "                .set('spark.driver.memory', '300G')\n",
    "                .set('spark.driver.maxResultSize', '20G')\n",
    "                .set('spark.network.timeout', '7200s')\n",
    "                .set('spark.local.dir', '/raid/tfidf_benchmark/'))\n",
    "\n",
    "sc = SparkContext(conf=conf)\n",
    "sc.setLogLevel(\"FATAL\")\n",
    "spark = SparkSession(sc)\n",
    "print(sc._conf.getAll()) # check context settings"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76d60928-fd60-4129-b7d8-3dfacdeee210",
   "metadata": {},
   "source": [
    "## Benchmarking Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5de53ec-c7db-4039-8dc6-17c4e974cbaa",
   "metadata": {},
   "source": [
    "### Helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7cc38aaa-02ab-40d3-83bf-c3d00b0bf701",
   "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 = nltk.corpus.stopwords.words('english')\n",
    "PUNCTUATIONS = \"\"\"[!\"#$%&()*+-.\\/\\\\:;<=>?@\\[\\]^_`{|}\\t\\n\\',~—]\"\"\"\n",
    "\n",
    "def read_data(spark, parquet_path, benchmark=True):\n",
    "    data = spark.read.parquet(parquet_path, columns=[\"review_body\"])\n",
    "    if benchmark:\n",
    "        data.write.format(\"noop\").mode(\"overwrite\").save()\n",
    "    return data\n",
    "\n",
    "\n",
    "def text_preprocessor(data, column_name, PUNCTUATIONS, STOPWORDS, benchmark=True):\n",
    "    data = data.na.drop(subset=[column_name])\n",
    "    data = data.withColumn(column_name,f.lower(f.col(column_name)))\n",
    "    data = data.withColumn(column_name,f.regexp_replace(f.col(column_name), PUNCTUATIONS, ' '))\n",
    "    data = data.withColumn(column_name,f.trim(f.col(column_name)))\n",
    "    tokenizer = Tokenizer(inputCol=column_name, outputCol=\"words\")\n",
    "    data = tokenizer.transform(data)                  \n",
    "    stopwordsRemover = StopWordsRemover(inputCol=\"words\", outputCol=\"filtered\", stopWords=STOPWORDS)\n",
    "    data = stopwordsRemover.transform(data)\n",
    "    if benchmark:\n",
    "        data.write.format(\"noop\").mode(\"overwrite\").save()\n",
    "    return data\n",
    "\n",
    "\n",
    "def hashing_vectorizer(data, benchmark):\n",
    "    hashingTF = HashingTF(inputCol=\"filtered\", outputCol=\"rawFeatures\", numFeatures=2**20)\n",
    "    data = hashingTF.transform(data)\n",
    "    if benchmark:\n",
    "        data.write.format(\"noop\").mode(\"overwrite\").save()\n",
    "    return data\n",
    "\n",
    "\n",
    "def tfidf_transformer(data, benchmark):\n",
    "    idf = IDF(inputCol=\"rawFeatures\", outputCol=\"finalFeatures\").fit(data)\n",
    "    data = idf.transform(data)\n",
    "    if benchmark:\n",
    "        data.write.format(\"noop\").mode(\"overwrite\").save()\n",
    "    return data\n",
    "\n",
    "\n",
    "def execute_full_pipeline(n, i, spark, parquet_path, worker_counts=[1], samples=1, result_path=\"./results.csv\", benchmark=True):\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(spark, parquet_path, benchmark)\n",
    "    sample_record[\"data_read\"]=timer.elapsed/1e9\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished loading data in {sample_record['data_read']}s\")\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        data = text_preprocessor(data, \"review_body\", PUNCTUATIONS, STOPWORDS, benchmark)\n",
    "    sample_record[\"data_preprocessing\"]=timer.elapsed/1e9\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished preprocessing data in {sample_record['data_preprocessing']}s\")\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        data = hashing_vectorizer(data, benchmark)\n",
    "    sample_record[\"hashing_vectorizer\"]=timer.elapsed/1e9\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished fitting HashVectorizer in {sample_record['hashing_vectorizer']}s\")\n",
    "\n",
    "    with SimpleTimer() as timer:\n",
    "        data = tfidf_transformer(data, benchmark=True)\n",
    "    sample_record[\"tfidf_transformer\"]=timer.elapsed/1e9\n",
    "\n",
    "    print(f\"Workers:{n}, Sample Run:{i}, Finished fitting IDF Transformer in {sample_record['tfidf_transformer']}s\")\n",
    "    return data, sample_record\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "47062b33-ddf0-4de4-b319-af3b0f63fb31",
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_numbers(parquet_path, worker_counts=[1], samples=1, result_path=\"./results.csv\", benchmark=True):\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, sample_record = execute_full_pipeline(n, i, spark, parquet_path, worker_counts=[1], samples=1, result_path=result_path, benchmark=benchmark)                \n",
    "            sample_record[\"overall\"]=overalltimer.elapsed/1e9\n",
    "            sample_record[\"nrows\"]=  data.count()\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": 6,
   "id": "d6d27907-94d5-414a-93ae-0997a887ff44",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = \"Books\"\n",
    "parquet_path = f'/raid/amazon_reviews_dataset/product_category={dataset}'\n",
    "samples = 5\n",
    "worker_counts = [1]\n",
    "result_path = f\"./results/result_poc_nlp_spark_{dataset}_persist.csv\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3414a428-14a1-4712-b9a3-6ea6cf460a4a",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Benchmark latency by materializing the intermediate dataframe(s) in every stage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6313056b-2cf0-44f4-a3c9-a6e101e74c17",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                                                                                           | 0/5 [00:00<?, ?it/s]\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished loading data in 15.23985286s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished preprocessing data in 107.494748581s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished fitting HashVectorizer in 202.877945115s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished fitting IDF Transformer in 487.954867778s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██████████████████████████████████▌                                                                                                                                          | 1/5 [13:37<54:28, 817.20s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished executing full pipeline in 813.567748678s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished loading data in 5.969575999s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished preprocessing data in 86.506390094s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished fitting HashVectorizer in 234.087781579s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished fitting IDF Transformer in 482.773021563s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|█████████████████████████████████████████████████████████████████████▏                                                                                                       | 2/5 [27:10<40:44, 814.72s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished executing full pipeline in 809.337087717s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished loading data in 4.935677043s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished preprocessing data in 88.406996062s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished fitting HashVectorizer in 241.706533445s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished fitting IDF Transformer in 498.943133027s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|███████████████████████████████████████████████████████████████████████████████████████████████████████▊                                                                     | 3/5 [41:07<27:30, 825.11s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished executing full pipeline in 833.99270305s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished loading data in 5.483239637s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished preprocessing data in 90.119382662s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished fitting HashVectorizer in 235.081407943s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished fitting IDF Transformer in 498.222800809s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍                                  | 4/5 [54:59<13:47, 827.96s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished executing full pipeline in 828.90735261s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished loading data in 4.991638449s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished preprocessing data in 86.70907281s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished fitting HashVectorizer in 248.295504954s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished fitting IDF Transformer in 480.932740433s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [1:08:44<00:00, 824.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished executing full pipeline in 820.92951352s\n",
      "CPU times: user 2.29 s, sys: 831 ms, total: 3.12 s\n",
      "Wall time: 1h 8min 44s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "performance_numbers(parquet_path=parquet_path, worker_counts=worker_counts, samples=samples, result_path=result_path, benchmark=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cc55ef40-905f-4399-a600-b5af67d6ea8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>821.346881</td>\n",
       "      <td>10.271341</td>\n",
       "      <td>5</td>\n",
       "      <td>7.323997</td>\n",
       "      <td>4.444873</td>\n",
       "      <td>5</td>\n",
       "      <td>232.409835</td>\n",
       "      <td>17.470464</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>5</td>\n",
       "      <td>20725971</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5</td>\n",
       "      <td>489.765313</td>\n",
       "      <td>8.454964</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>1.581139</td>\n",
       "      <td>5</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          821.346881  10.271341     5  7.323997  4.444873     5   \n",
       "\n",
       "          hashing_vectorizer                  tfid_transformer  ...  \\\n",
       "                        mean        std count             mean  ...   \n",
       "n_workers                                                       ...   \n",
       "1                 232.409835  17.470464     5                0  ...   \n",
       "\n",
       "          data_preprocessing     nrows            tfidf_transformer            \\\n",
       "                       count      mean  std count              mean       std   \n",
       "n_workers                                                                       \n",
       "1                          5  20725971  0.0     5        489.765313  8.454964   \n",
       "\n",
       "                sample_run                  \n",
       "          count       mean       std count  \n",
       "n_workers                                   \n",
       "1             5          2  1.581139     5  \n",
       "\n",
       "[1 rows x 24 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data, melt_data = visualize_data(result_path) \n",
    "groupy = data.groupby(\"n_workers\").agg(['mean', 'std', 'count'])\n",
    "groupy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b14a7165-f091-45ee-b042-4cfaaf033597",
   "metadata": {},
   "source": [
    "## Benchmark latency without materializing the intermediate dataframe(s) except for the last stage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "55edff6b-909c-4c38-ad20-0648ecabdf5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = \"Books\"\n",
    "parquet_path = f'/raid/amazon_reviews_dataset/product_category={dataset}'\n",
    "samples = 5\n",
    "worker_counts = [1]\n",
    "result_path = f\"./results/result_poc_nlp_spark_{dataset}_nonpersist.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f1cfb423-382d-4ebe-80ea-97613c2cdcbd",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|                                                                                                                                                                                      | 0/5 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished loading data in 0.050798674s\n",
      "Workers:1, Sample Run:0, Finished preprocessing data in 0.09297889s\n",
      "Workers:1, Sample Run:0, Finished fitting HashVectorizer in 0.012221278s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished fitting IDF Transformer in 486.358867514s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 20%|██████████████████████████████████▌                                                                                                                                          | 1/5 [08:09<32:39, 489.89s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:0, Finished executing full pipeline in 486.515158753s\n",
      "Workers:1, Sample Run:1, Finished loading data in 0.050539651s\n",
      "Workers:1, Sample Run:1, Finished preprocessing data in 0.088441056s\n",
      "Workers:1, Sample Run:1, Finished fitting HashVectorizer in 0.010710309s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished fitting IDF Transformer in 478.03716527s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 40%|█████████████████████████████████████████████████████████████████████▏                                                                                                       | 2/5 [16:11<24:14, 484.95s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:1, Finished executing full pipeline in 478.187114776s\n",
      "Workers:1, Sample Run:2, Finished loading data in 0.050383766s\n",
      "Workers:1, Sample Run:2, Finished preprocessing data in 0.10429752s\n",
      "Workers:1, Sample Run:2, Finished fitting HashVectorizer in 0.013528535s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished fitting IDF Transformer in 493.773125929s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 60%|███████████████████████████████████████████████████████████████████████████████████████████████████████▊                                                                     | 3/5 [24:28<16:21, 490.66s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:2, Finished executing full pipeline in 493.941810846s\n",
      "Workers:1, Sample Run:3, Finished loading data in 0.050379153s\n",
      "Workers:1, Sample Run:3, Finished preprocessing data in 0.08857387s\n",
      "Workers:1, Sample Run:3, Finished fitting HashVectorizer in 0.011128956s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished fitting IDF Transformer in 476.473840903s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      " 80%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▍                                  | 4/5 [32:28<08:06, 486.51s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:3, Finished executing full pipeline in 476.62420887s\n",
      "Workers:1, Sample Run:4, Finished loading data in 0.051789292s\n",
      "Workers:1, Sample Run:4, Finished preprocessing data in 0.088651124s\n",
      "Workers:1, Sample Run:4, Finished fitting HashVectorizer in 0.010708737s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished fitting IDF Transformer in 477.363643936s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [40:30<00:00, 486.13s/it]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Workers:1, Sample Run:4, Finished executing full pipeline in 477.515079373s\n",
      "CPU times: user 1.47 s, sys: 396 ms, total: 1.86 s\n",
      "Wall time: 40min 30s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "performance_numbers(parquet_path=parquet_path, worker_counts=worker_counts, samples=samples, result_path=result_path, benchmark=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ef97ce8b-7075-4caf-8d41-bf330b52b787",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "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>482.556675</td>\n",
       "      <td>7.49993</td>\n",
       "      <td>5</td>\n",
       "      <td>0.050778</td>\n",
       "      <td>0.00059</td>\n",
       "      <td>5</td>\n",
       "      <td>0.01166</td>\n",
       "      <td>0.001214</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>5</td>\n",
       "      <td>20725971</td>\n",
       "      <td>0.0</td>\n",
       "      <td>5</td>\n",
       "      <td>482.401329</td>\n",
       "      <td>7.492316</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>1.581139</td>\n",
       "      <td>5</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          482.556675  7.49993     5  0.050778  0.00059     5   \n",
       "\n",
       "          hashing_vectorizer                 tfid_transformer  ...  \\\n",
       "                        mean       std count             mean  ...   \n",
       "n_workers                                                      ...   \n",
       "1                    0.01166  0.001214     5                0  ...   \n",
       "\n",
       "          data_preprocessing     nrows            tfidf_transformer            \\\n",
       "                       count      mean  std count              mean       std   \n",
       "n_workers                                                                       \n",
       "1                          5  20725971  0.0     5        482.401329  7.492316   \n",
       "\n",
       "                sample_run                  \n",
       "          count       mean       std count  \n",
       "n_workers                                   \n",
       "1             5          2  1.581139     5  \n",
       "\n",
       "[1 rows x 24 columns]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data, melt_data = visualize_data(result_path) \n",
    "groupy = data.groupby(\"n_workers\").agg(['mean', 'std', 'count'])\n",
    "groupy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38d800a3-6c16-46f1-927a-31208341a712",
   "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
}