reviewed_grapes.feature_eng.pyspark.v1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ef359050-0948-401b-833a-ee6999a59f66",
   "metadata": {},
   "source": [
    "# Feature Creation\n",
    "\n",
    "---\n",
    "\n",
    "This concerns the steps 2 & 3 from the [General Model Approach](./README.md#General-Model-Approach):\n",
    "\n",
    "**2. Render each word in the review text to a canonical form.**\n",
    "\n",
    "**3. Use a predefined set of words, a _target word set_, to create a feature vector of binary features, each indicating the presence or absence of one of the words in the target word set.**\n",
    "\n",
    "\n",
    "**Step 2** will be the same for all models we define.\n",
    "\n",
    "**Step 3** is similar to what we did for the labels in our [baseline model](./reviwed_grapes.method_baseline.pyspark.v1.ipynb) but this time we do it for the canonical words in the reviews.\n",
    "\n",
    "We carry out different approaches for step 3, leading to different target word sets: \n",
    "\n",
    "- [Most Common Word](#Most-Common-Words)\n",
    "\n",
    "- [Word2Vector Based](#Word2Vec-Based)\n",
    "  - [Similar Words](#Similar-Words)\n",
    "  - [Dissimilar Words](#Dissimilar-Words)\n",
    "  - [Extremes Word Set](#Extremes-Word-Set)\n",
    "  - [Low Entropy Word Set](#Low-Entropy-Word-Set)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3e819e18-06a5-482b-9e1c-634deb9df13d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import numpy as np\n",
    "from pyspark.sql import SparkSession, SQLContext\n",
    "from pyspark.ml import Pipeline\n",
    "from pyspark.ml.feature import StringIndexer\n",
    "from pyspark.sql.functions import udf, col\n",
    "from pyspark.sql.types import ArrayType, StringType\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.display import Markdown, display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a1451965-1773-42f1-8822-977c691d2fd4",
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "def warn(string):\n",
    "    display(Markdown('<span style=\"color:red\">'+string+'</span>'))\n",
    "def info(string):\n",
    "    display(Markdown('<span style=\"color:blue\">'+string+'</span>'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e5212fc9-1df3-43b8-85ed-511fae859e80",
   "metadata": {},
   "outputs": [],
   "source": [
    "spark = SparkSession.builder \\\n",
    "    .master(\"local[*]\") \\\n",
    "    .config(\"spark.driver.maxResultSize\", \"1g\") \\\n",
    "    .config(\"spark.driver.memory\", \"20g\") \\\n",
    "    .appName(\"jojoSparkSession\") \\\n",
    "    .getOrCreate()\n",
    "    # .config(\"spark.driver.memory\", \"20g\") \\\n",
    "    # .config(\"spark.default.parallelism\", \"16\") \\\n",
    "    # .config(\"spark.executor.cores\", \"16\") \\\n",
    "sc = spark.sparkContext\n",
    "sqlContext = SQLContext(sc) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "47745d7c-50dd-4904-85f8-5e593cca8563",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----+--------------------+------------------+\n",
      "|index|         description|           variety|\n",
      "+-----+--------------------+------------------+\n",
      "|    0|aromas include tr...|       white blend|\n",
      "|    1|this is ripe and ...|    portuguese red|\n",
      "|    2|tart and snappy, ...|        pinot gris|\n",
      "|    3|pineapple rind, l...|          riesling|\n",
      "|    4|much like the reg...|        pinot noir|\n",
      "|    7|this dry and rest...|    gewürztraminer|\n",
      "|    8|savory dried thym...|    gewürztraminer|\n",
      "|    9|this has great de...|        pinot gris|\n",
      "|   10|soft, supple plum...|cabernet sauvignon|\n",
      "|   11|this is a dry win...|    gewürztraminer|\n",
      "|   12|slightly reduced,...|cabernet sauvignon|\n",
      "|   14|building on 150 y...|        chardonnay|\n",
      "|   15|zesty orange peel...|          riesling|\n",
      "|   16|baked plum, molas...|            malbec|\n",
      "|   17|raw black-cherry ...|            malbec|\n",
      "|   18|desiccated blackb...| tempranillo blend|\n",
      "|   19|red fruit aromas ...|          meritage|\n",
      "|   20|ripe aromas of da...|         red blend|\n",
      "|   21|a sleek mix of ta...|        pinot noir|\n",
      "|   22|delicate aromas r...|       white blend|\n",
      "+-----+--------------------+------------------+\n",
      "only showing top 20 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# load the dataset\n",
    "reviews_sdf = spark.read.parquet('data/reviews_cleaned')\n",
    "reviews_sdf.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18c5d655-e03c-4307-ac54-840c2cf3a110",
   "metadata": {},
   "source": [
    "## Canonical Words (step 2)\n",
    "\n",
    "As a first feature engineering step we will take the text in the `description` column and convert it to a list of canonical words.\n",
    "\n",
    "Naively, we could simply split the text into single words.\n",
    "However, since words change with declination we need to convert them to a canonical form.\n",
    "The python package [nltk](https://www.nltk.org/) can help us here and we use what is called [Lemmatisation](https://en.wikipedia.org/wiki/Lemmatisation).\n",
    "\n",
    "Also we get rid of common [stopwords](https://en.wikipedia.org/wiki/Stop_words), i.e. words that are common but without relevant information content and we define a custom _blacklist_ of words we are sure will not help us for the prediction.\n",
    "\n",
    "To start, we get common English stopwords from the nltk package:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c5d6d7f6-3d1d-4f7e-bf88-3039db774351",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to /home/jonas/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('stopwords')\n",
    "from nltk.corpus import stopwords\n",
    "# get common english stopwords:\n",
    "en_stopwords = set(stopwords.words('english'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa71e1a0-2688-4f19-979d-82b497bf60bb",
   "metadata": {},
   "source": [
    "Now we define our own blacklist of words, i.e. words we do not want to include in the tarcking set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "46f49e33-efa3-488c-ac8c-d49cbce9de91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# our custom blacklist:\n",
    "blacklist = set(['wine', 'drink', 'variety', 'show', 'offer', 'make', 'give', 'well',\n",
    "                 'open', 'come', 'years', 'bottle', 'mouth', 'like', 'also', 'along',\n",
    "                 'alongside', 'vineyard', 'ready', 'great', 'one', 'slightly', 'deliver',\n",
    "                 'yet', 'add', 'need', 'big', 'bring', 'easy', 'oral', 'best', 'end', 'alcohol'])\n",
    "# now we combine it with the stopwords\n",
    "stop_words = list(en_stopwords.union(blacklist))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd1566b1-a6e5-4330-95ff-c72f34f05377",
   "metadata": {},
   "source": [
    "Up next we need to write a routine that processes the text in the `description` column by lemmatizing the words and creating a set of words that occur.\n",
    "\n",
    "Also for this we define a custom transformer, we'll call _NLTKLemmatizer_, by sub-classing pyspark's [Transformer](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.ml.Transformer.html).\n",
    "\n",
    "The class is defined in [./reviewed_grapes/transformers.py](./reviewed_grapes/transformers.py) and can simply be used like any other pyspark Transformer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5d7d8d8f-f970-47a3-b72a-1b948deffa5f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/jonas/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /home/jonas/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "# import the custom Transformer class\n",
    "from reviewed_grapes.transformers import NLTKLemmatizer\n",
    "# instatiate our transformer:\n",
    "nltkl = NLTKLemmatizer(inputCol='description', outputCol='words', stopWords=stop_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "786851b9-a6bb-4ea7-bd37-9225a92bb047",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text:\n",
      "\taromas include tropical fruit, broom, brimstone and dried herb. the palate isn't overly expressive, offering unripened apple, citrus and dried sage alongside brisk acidity.\n",
      "Lemmatized Words:\n",
      "\t['herb', 'overly', 'offer', 'tropical', 'expressive', 'include', 'broom', 'unripened', 'aromas', 'palate', 'brimstone', 'sage', 'dry', 'brisk', 'fruit', 'acidity', 'apple', 'citrus']\n",
      "\n",
      "\n",
      "Text:\n",
      "\tthis is ripe and fruity, a wine that is smooth while still structured. firm tannins are filled out with juicy red berry fruits and freshened with acidity. it's  already drinkable, although it will certainly be better from 2016.\n",
      "Lemmatized Words:\n",
      "\t['still', 'better', 'certainly', 'drinkable', 'fruit', 'fill', 'fruity', 'structure', 'berry', 'freshen', 'acidity', 'firm', 'ripe', 'juicy', 'tannins', 'although', 'smooth', 'already', 'red']\n",
      "\n",
      "\n",
      "Text:\n",
      "\ttart and snappy, the flavors of lime flesh and rind dominate. some green pineapple pokes through, with crisp acidity underscoring the flavors. the wine was all stainless-steel fermented.\n",
      "Lemmatized Words:\n",
      "\t['poke', 'flavor', 'ferment', 'flesh', 'lime', 'pineapple', 'underscore', 'acidity', 'tart', 'green', 'crisp', 'snappy', 'rind', 'dominate']\n",
      "\n",
      "\n",
      "Text:\n",
      "\tpineapple rind, lemon pith and orange blossom start off the aromas. the palate is a bit more opulent, with notes of honey-drizzled guava and mango giving way to a slightly astringent, semidry finish.\n",
      "Lemmatized Words:\n",
      "\t['opulent', 'aromas', 'palate', 'mango', 'astringent', 'start', 'pineapple', 'pith', 'note', 'way', 'guava', 'give', 'lemon', 'bite', 'finish', 'rind', 'orange', 'blossom', 'semidry']\n",
      "\n",
      "\n",
      "Text:\n",
      "\tmuch like the regular bottling from 2012, this comes across as rather rough and tannic, with rustic, earthy, herbal characteristics. nonetheless, if you think of it as a pleasantly unfussy country wine, it's a good companion to a hearty winter stew.\n",
      "Lemmatized Words:\n",
      "\t['bottle', 'winter', 'stew', 'unfussy', 'rough', 'earthy', 'rustic', 'companion', 'hearty', 'regular', 'herbal', 'come', 'across', 'characteristics', 'nonetheless', 'good', 'tannic', 'rather', 'much', 'think', 'pleasantly', 'country']\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "cannonical = nltkl.transform(reviews_sdf).select('description', 'words')\n",
    "for row in cannonical.take(5):\n",
    "    description, words = row\n",
    "    print(\"Text:\\n\\t%s\\nLemmatized Words:\\n\\t%s\\n\\n\" % (description, words))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca90b9a7-943a-4449-b370-9155d10ba046",
   "metadata": {},
   "source": [
    "**So we can simply include an instance of our `NLTKLemmatizer` when we define a pipeline in our model definition.**\n",
    "\n",
    "---\n",
    "\n",
    "## Target Word Set\n",
    "\n",
    "This concerns stage 3 in our approach.\n",
    "Basically, we need to create a set of words to track.\n",
    "\n",
    "In what follows we explore different ways to do so.\n",
    "\n",
    "### Most Common Words\n",
    "\n",
    "In this case our target word set simply consists of the _x_-most commonly used words in the review texts.\n",
    "There is no ready made function in pyspark that would allow to compute such list, so we write one and wrap it into a custom [Estimator](https://spark.apache.org/docs/3.1.1/api/python/reference/api/pyspark.ml.Estimator.html) just like we did for the `MarginalMaximizer` in our [Baseline Model](reviewed_grapes.baseline.model_def.pyspark.v1.ipynb).\n",
    "\n",
    "Our custom `WordSetTracker` is defined [utils/Estimators.py](./utils/Estimators.py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ea673432-85dd-4111-9080-7bfd40002f58",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import the custom estimator\n",
    "from utils.Estimators import WordSetTracker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8b17beaa-d816-4b28-97c1-f138a31646ae",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# how long should the list of most common words be?\n",
    "nbrWords = 1000\n",
    "# initiate the estimator\n",
    "wst = WordSetTracker(inputCol='words', outputCol='features', limitTo=nbrWords)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b50cbac5-6e85-47ef-bb78-4deb48c62f7c",
   "metadata": {},
   "source": [
    "Let's process our dataset and see what we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8ecb73d4-6765-45ec-a551-dd16533514c6",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nltkl' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<timed exec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'nltkl' is not defined"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "preview_model = Pipeline(stages=[nltkl, wst]).fit(reviews_sdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "785819f1-6664-4d76-ac7d-b039772d1add",
   "metadata": {},
   "source": [
    "We can now access the attributes `wordSet` and `wordCount` from our custom estimator and do some exploration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "abdd791b-27ad-4b97-85fa-8a825fde752f",
   "metadata": {},
   "outputs": [],
   "source": [
    "wst_model = preview_model.stages[1]\n",
    "word_set = wst_model.getWordSet()\n",
    "word_count = wst_model.getWordCount()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c4b4df2c-00ef-4eb5-8341-6512f69d6c1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list for later use\n",
    "with open('data/targetWordSets/common_words.json', 'w') as fo:\n",
    "    json.dump(word_set, fo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e4bcf0ec-bb04-413c-880d-eef3c34c1ee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "#### 100 most used words and how often they occur in reviews"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2520x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# let's have a look at the top most common words\n",
    "word_set = word_set[:100]\n",
    "word_count = word_count[:100]\n",
    "display(Markdown(f'\\n#### {len(word_set)} most used words and how often they occur in reviews'))\n",
    "fig, ax = plt.subplots(figsize=(35, 10))\n",
    "ax.bar(word_set, word_count)\n",
    "plt.xticks(rotation=45, fontsize='x-large', ha='right', va='top', rotation_mode='anchor')\n",
    "ax.set_ylabel('# reviews', fontweight='bold', fontsize='x-large')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a98f19-867b-4723-9256-cf118fa216f5",
   "metadata": {},
   "source": [
    "So far so good!\n",
    "\n",
    "**With our custom estimator, `WordSetTracker`, we can compute the list of most common words.**\n",
    "\n",
    "So also this step can now simply be included in a Pipeline.\n",
    "\n",
    "---\n",
    "\n",
    "### Word2Vec Based\n",
    "\n",
    "Now to the fun part!\n",
    "\n",
    "**Here we implement a deep learning model**, a variation of an auto-encoder to be clear, that will allow us to embed all canonical words in the review texts, as well as, all the wine varieties into a vector space.\n",
    "\n",
    "Based on this vector space we then assess the similarity between words and wine varieties and compile target words set based on similarity considerations.\n",
    "\n",
    "---\n",
    "**Note:** Spark implements its own [Word2Vec](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.ml.feature.Word2Vec.html) estimator, which makes things rather easy and allows  a seamless pipeline-syntax.\n",
    "We use this estimator here in our feature creation.\n",
    "However, **an implementation in [keras](https://keras.io/) and one in [elephas](https://github.com/maxpumperla/elephas) (allowing to run keras on spark) are also implemented.**\n",
    "\n",
    "The keras + elephas implementation can be found in [reviewed_grapes.feature_eng_SI.pyspark_keras_elephas.v1.ipynb](reviewed_grapes.feature_eng_SI.pyspark_keras_elephas.v1.ipynb).\n",
    "___\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0c7d219-37cd-49d4-97fa-e188d1c4f1a7",
   "metadata": {},
   "source": [
    "\n",
    "To start, we first get the dataset ready.\n",
    "Here we will already run the `WordSetTracker` once with a high number of most common words, i.e. 5000.\n",
    "This is to limit the number of word-pairs we create for our word-2-vector encoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "762a058d-ce59-4108-9c8b-f49b26d5283d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package punkt to /home/jonas/nltk_data...\n",
      "[nltk_data]   Package punkt is already up-to-date!\n",
      "[nltk_data] Downloading package wordnet to /home/jonas/nltk_data...\n",
      "[nltk_data]   Package wordnet is already up-to-date!\n"
     ]
    }
   ],
   "source": [
    "from reviewed_grapes.transformers import NLTKLemmatizer\n",
    "from utils.Estimators import WordSetTracker\n",
    "# Index the labels:\n",
    "si = StringIndexer(inputCol='variety', outputCol='label', handleInvalid='keep')\n",
    "# Create canonical word list\n",
    "from nltk.corpus import stopwords\n",
    "# get common english stopwords:\n",
    "en_stopwords = set(stopwords.words('english'))\n",
    "blacklist = set(['wine', 'drink', 'variety', 'show', 'offer', 'make', 'give', 'well',\n",
    "                 'open', 'come', 'years', 'bottle', 'mouth', 'like', 'also', 'along',\n",
    "                 'alongside', 'vineyard', 'ready', 'great', 'one', 'slightly', 'deliver',\n",
    "                 'yet', 'add', 'need', 'big', 'bring', 'easy', 'oral', 'best', 'end', 'alcohol'])\n",
    "stop_words = list(en_stopwords.union(blacklist))\n",
    "nltkl = NLTKLemmatizer(inputCol='description', outputCol='words', stopWords=stop_words)\n",
    "# Set up a pipeline\n",
    "prep_ppl = Pipeline(stages=[si, nltkl])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "01cf0349-6af6-4300-8529-8499b61dd37e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 22.9 ms, sys: 0 ns, total: 22.9 ms\n",
      "Wall time: 1.88 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "prep_nltk_fitted = prep_ppl.fit(reviews_sdf)\n",
    "nltk_ready = prep_nltk_fitted.transform(reviews_sdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb67023-2f7b-4e22-ad9b-0cd663bf18c7",
   "metadata": {},
   "source": [
    "___\n",
    "---\n",
    "_This part, up to the next box with double lining, is unused in the final version of the analysis._\n",
    "\n",
    "\n",
    "**Considerations:**\n",
    "        \n",
    "\n",
    "Since our dataset is not balanced and we have many more reviews for certain wine varieties,\n",
    "we would also pick-up this bias towards certain wine varieties in our word-2-vector encoding.\n",
    "\n",
    "To avoid this we create a balanced dataset and use this dataset for the word encoding.\n",
    "Creating a balanced dataset can be achieved by stratified sampling, however, if we do so,\n",
    "we will ignore some samples for the more frequent wine varieties.\n",
    "To avoid this, we adapt another approach and 'upscale' our dataset.\n",
    "In particular we resample the entries for each wine variety until each wine variety has the same number of samples.\n",
    "Note that all wine varieties will simply keep all its samples and that, with the exception of the most common one, \n",
    "all varieties will have some of their samples duplicated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d2e30ad9-31b5-432e-8f86-a9dfe2d13518",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "target_count=12277\n"
     ]
    }
   ],
   "source": [
    "# StringIndexer is rather helpful as it associates the index 0.0 to the most common lable.\n",
    "# We can thus easily get to count of the most common label with: \n",
    "target_count = nltk_ready.filter(nltk_ready.label==0.0).count()\n",
    "print(f'{target_count=}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4746480d-9191-4ed0-b1ba-61f4150f1a7d",
   "metadata": {},
   "source": [
    "Now we will 'upscale' the number of samples for any other label, in order to get the same count for each label.\n",
    "We do this by sampling with replacement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "afb7fa98-3467-4727-a252-5e112e56a5ef",
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total_count=108234\n",
      "upsacling label=1.0\t duplicated 1410 entries\n",
      "upsacling label=2.0\t duplicated 3439 entries\n",
      "upsacling label=3.0\t duplicated 4036 entries\n",
      "upsacling label=4.0\t duplicated 5808 entries\n",
      "upsacling label=5.0\t duplicated 7504 entries\n",
      "upsacling label=6.0\t duplicated 7702 entries\n",
      "upsacling label=7.0\t duplicated 8451 entries\n",
      "upsacling label=8.0\t duplicated 9057 entries\n",
      "upsacling label=9.0\t duplicated 9381 entries\n",
      "upsacling label=10.0\t duplicated 9675 entries\n",
      "upsacling label=11.0\t duplicated 9747 entries\n",
      "upsacling label=12.0\t duplicated 9817 entries\n",
      "upsacling label=13.0\t duplicated 9831 entries\n",
      "upsacling label=14.0\t duplicated 9995 entries\n",
      "upsacling label=15.0\t duplicated 10098 entries\n",
      "upsacling label=16.0\t duplicated 10306 entries\n",
      "upsacling label=17.0\t duplicated 10606 entries\n",
      "upsacling label=18.0\t duplicated 10934 entries\n",
      "upsacling label=19.0\t duplicated 10953 entries\n",
      "upsacling label=20.0\t duplicated 10969 entries\n",
      "upsacling label=21.0\t duplicated 11034 entries\n",
      "upsacling label=22.0\t duplicated 11077 entries\n",
      "upsacling label=23.0\t duplicated 11220 entries\n",
      "upsacling label=24.0\t duplicated 11284 entries\n",
      "upsacling label=25.0\t duplicated 11297 entries\n",
      "upsacling label=26.0\t duplicated 11337 entries\n",
      "upsacling label=27.0\t duplicated 11351 entries\n",
      "upsacling label=28.0\t duplicated 11355 entries\n",
      "upsacling label=29.0\t duplicated 11487 entries\n",
      "upsacling label=30.0\t duplicated 11575 entries\n",
      "upsacling label=31.0\t duplicated 11581 entries\n",
      "upsacling label=32.0\t duplicated 11631 entries\n",
      "upsacling label=33.0\t duplicated 11633 entries\n",
      "upsacling label=34.0\t duplicated 11649 entries\n",
      "upsacling label=35.0\t duplicated 11670 entries\n",
      "upsacling label=36.0\t duplicated 11703 entries\n",
      "upsacling label=37.0\t duplicated 11724 entries\n",
      "upsacling label=38.0\t duplicated 11731 entries\n",
      "upsacling label=39.0\t duplicated 11744 entries\n",
      "upsacling label=40.0\t duplicated 11843 entries\n",
      "upsacling label=41.0\t duplicated 11882 entries\n",
      "upsacling label=42.0\t duplicated 11882 entries\n",
      "upsacling label=43.0\t duplicated 11938 entries\n",
      "upsacling label=44.0\t duplicated 11947 entries\n",
      "upsacling label=45.0\t duplicated 11953 entries\n",
      "upsacling label=46.0\t duplicated 11969 entries\n",
      "upsacling label=47.0\t duplicated 11995 entries\n",
      "upsacling label=48.0\t duplicated 12011 entries\n",
      "upsacling label=49.0\t duplicated 12021 entries\n",
      "upsacling label=50.0\t duplicated 12023 entries\n",
      "upsacling label=51.0\t duplicated 12030 entries\n",
      "upsacling label=52.0\t duplicated 12037 entries\n",
      "upsacling label=53.0\t duplicated 12043 entries\n",
      "upsacling label=54.0\t duplicated 12048 entries\n",
      "upsacling label=55.0\t duplicated 12064 entries\n",
      "upsacling label=56.0\t duplicated 12067 entries\n",
      "CPU times: user 2.66 s, sys: 154 ms, total: 2.82 s\n",
      "Wall time: 4min 34s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# get all different labels present (i.e. all wine varieties)\n",
    "all_labels = sorted(np.array(nltk_ready.select('label').distinct().collect()).reshape(-1))\n",
    "# number of different labels (i.e. varieties)\n",
    "nbr_labels = len(all_labels)\n",
    "total_count = nltk_ready.count()\n",
    "print(f'{total_count=}')\n",
    "# we construct a new dataset that will hold the balanced review data\n",
    "nltk_upscaled = nltk_ready.alias('nltk_upscaled')\n",
    "# now we process each label\n",
    "# (with the exception of the first as there is nothing to do)\n",
    "for label in all_labels[1:]:\n",
    "    label_entries = nltk_ready.filter(nltk_ready.label==label)\n",
    "    nbr_entries = label_entries.count()\n",
    "    needed = target_count - nbr_entries\n",
    "    upscale_factor = needed / nbr_entries\n",
    "    # now we sample\n",
    "    new_entries = nltk_ready.sample(True, upscale_factor).take(needed)\n",
    "    nltk_upscaled = nltk_upscaled.union(sc.parallelize(new_entries).toDF())\n",
    "    added = len(new_entries)\n",
    "    print(f'upsacling {label=}\\t duplicated {added} entries')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1428ad4-db9a-4db8-8599-095a66f79596",
   "metadata": {},
   "source": [
    "\n",
    "---\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7267ef7-1cf4-4a79-9f21-8a4c995efcec",
   "metadata": {},
   "source": [
    "Now we can get the word count. Either from the balanced dataset or the original one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0134298d-227b-4dee-b802-9baf96c38357",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set the parameter for our word sets\n",
    "nbrWords = 4000  # used in word2vector embedding\n",
    "balance = False # whether or not to balance the dataset\n",
    "\n",
    "if balance:\n",
    "    words_ds = nltk_upscaled\n",
    "else:\n",
    "    words_ds = nltk_ready"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ff22f1fd-287f-47d9-bce3-c1b1489311f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute list of most common words\n",
    "# (we use indexWords=False to create a list of words instead of features)\n",
    "wst = WordSetTracker(inputCol='words', outputCol='word_list',\n",
    "                     limitTo=nbrWords, indexWords=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0db0797a-7924-4f03-9e08-d1c57f4a0013",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 40.9 ms, sys: 11.7 ms, total: 52.5 ms\n",
      "Wall time: 1min 31s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# nltk_upscaled = nltk_upscaled.union(sc.parallelize(new_entries).toDF())\n",
    "wst_fitted = wst.fit(words_ds)\n",
    "w2v_ready = wst_fitted.transform(words_ds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9e735e4-3351-40af-a75c-65ad3d58dc9f",
   "metadata": {},
   "source": [
    "Now with `w2v_upscaled` we have created a balanced dataset in that each wine variety has the exact same number of reviews.\n",
    "\n",
    "Based on this dataset we now construct word pairs that we can use to train our word2vec encoding with.\n",
    "\n",
    "We would do this yet again in another custom Transformer method.\n",
    "However, since we do this step only once in your feature creation and it won't be a part in our model definition later on (only the resulting target words sets will be) we implement this transformation here, directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b131416b-7628-4ce6-b8c9-7e1646a586f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a user defined function to zip the variety into the list of canonical words\n",
    "@udf(returnType=ArrayType(StringType()))\n",
    "def w2v_sentence(words_list, variety):\n",
    "    _sep = '  '  # we use 2 spaces here as some varieties also contain ' '\n",
    "    return f'{_sep}{variety}{_sep}'.join(words_list).split(_sep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b1b4d08c-9675-45f9-a7a1-58555e7c99ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
      "|w2v_sentence                                                                                                                                                                                                                                                                                                                                                                                                                                              |\n",
      "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
      "|[fruit, white blend, aromas, white blend, palate, white blend, acidity, white blend, dry, white blend, offer, white blend, apple, white blend, citrus, white blend, herb, white blend, tropical, white blend, brisk, white blend, sage, white blend, include, white blend, expressive, white blend, overly, white blend, broom, white blend, brimstone]                                                                                                   |\n",
      "|[fruit, portuguese red, acidity, portuguese red, tannins, portuguese red, ripe, portuguese red, red, portuguese red, berry, portuguese red, structure, portuguese red, juicy, portuguese red, fruity, portuguese red, firm, portuguese red, smooth, portuguese red, still, portuguese red, although, portuguese red, already, portuguese red, better, portuguese red, fill, portuguese red, certainly, portuguese red, drinkable, portuguese red, freshen]|\n",
      "|[flavor, pinot gris, acidity, pinot gris, crisp, pinot gris, green, pinot gris, tart, pinot gris, lime, pinot gris, pineapple, pinot gris, dominate, pinot gris, ferment, pinot gris, rind, pinot gris, flesh, pinot gris, snappy, pinot gris, underscore, pinot gris, poke]                                                                                                                                                                              |\n",
      "|[finish, riesling, aromas, riesling, palate, riesling, note, riesling, lemon, riesling, bite, riesling, give, riesling, orange, riesling, pineapple, riesling, way, riesling, start, riesling, blossom, riesling, astringent, riesling, opulent, riesling, mango, riesling, rind, riesling, pith, riesling, guava, riesling, semidry]                                                                                                                     |\n",
      "+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+\n",
      "only showing top 4 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Cerate the new column\n",
    "w2v_ready = w2v_ready.withColumn('w2v_sentence',\n",
    "                                 w2v_sentence(w2v_ready['word_list'],\n",
    "                                              w2v_ready['variety']))\n",
    "w2v_ready.select('w2v_sentence').show(4, truncate=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "837266ec-9df6-4218-a556-7d0b6a2f664c",
   "metadata": {},
   "source": [
    "So the column `'w2v_sentence'` consists of a list where every other word belongs to the review text with always the wine variety in-between.\n",
    "\n",
    "If we pass this column to pyspark's [Word2Vec](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.ml.feature.Word2Vec.html) with a `windowSize` of 1 then we train the model exclusively with word-variety pairs, which is exactly what we want:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "12ab91d0-ccc7-4a98-bda4-f2e5ab1139e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import the Word2Vec model\n",
    "from pyspark.ml.feature import Word2Vec\n",
    "# Initiate it with windowSize=1\n",
    "w2v = Word2Vec(inputCol='w2v_sentence', outputCol='result',\n",
    "               windowSize=1, vectorSize=50, minCount=10,\n",
    "               maxIter=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e2b124b6-4017-443d-88e3-05ae548cc5fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 30.6 ms, sys: 15.2 ms, total: 45.8 ms\n",
      "Wall time: 7min 39s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# Now we train the model\n",
    "w2v_model_fitted = w2v.fit(w2v_ready)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1fb51659-41b8-4110-9213-af46481c218c",
   "metadata": {},
   "outputs": [],
   "source": [
    "w2v_model_fitted.write().overwrite().save(f'data/interim/w2v_fitted_model_{nbrWords}words_{\"balanced\" if balance else \"\"}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1833cf42-8456-4aa3-a16a-762a8dbcd0f6",
   "metadata": {},
   "source": [
    "**We can now use the fitted model `w2v_model_fitted` to generate different target words sets.**\n",
    "\n",
    "We could extract the vector representation of each word and variety, however, what we really care about it the similarity between them.\n",
    "Luckily, spark's Word2Vec allows to directly assess the  [cosin simiarlity](https://en.wikipedia.org/wiki/Cosine_similarity), which is a common way to measure similarities between vectors and is basically the cosine of the angle between two vectors (so independent on their length).\n",
    "\n",
    "Spark's Word2Vec model uses the cosine similarity in its [findSynonyms](https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.ml.feature.Word2VecModel.html#pyspark.ml.feature.Word2VecModel.findSynonyms), so we directly work with this method.\n",
    "\n",
    "Since we will loop repeatedly over all varieties and all distinct canonical words, we create sets for them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0937ee78-61ac-4fb8-9d89-2de7ef1fb485",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we loop over the original ds since upscaling does not add any new words/varieties\n",
    "varieties = list(np.array(\n",
    "    nltk_ready.select('variety').distinct().collect()\n",
    ").reshape(-1))\n",
    "words = [np.array(wds).reshape(-1)\n",
    "         for wds in nltk_ready.select('words').distinct().collect()]\n",
    "word_set = set()\n",
    "for wds in words:\n",
    "    word_set = word_set.union(wds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06818bff-d8a2-4010-bbc5-a1e2db69c0ff",
   "metadata": {},
   "source": [
    "---\n",
    "#### Similar Words\n",
    "\n",
    "For each of the varieties we want to get the most similar words and use them as our target words set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c0085821-b0d8-4658-bfd2-ab310591a06e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4.31 s, sys: 152 ms, total: 4.46 s\n",
      "Wall time: 16.3 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# how many sinonyms should be fetched\n",
    "fetch = int(0.9 * nbrWords)\n",
    "variety_syno = {}\n",
    "for variety in varieties:\n",
    "    synonyms = w2v_model_fitted.findSynonyms(variety, fetch)\n",
    "    # we want to exclude other varieties:\n",
    "    # we take both the word and the similarity to avoid resorting\n",
    "    variety_syno[variety] = list(np.array(synonyms.filter(\n",
    "        ~col('word').isin(varieties)\n",
    "    ).select('word', 'similarity').collect()).reshape(-1))\n",
    "# Now we drop the similarity values and invert the list\n",
    "variety_syno = {var: sins[-2::-2] for var, sins in variety_syno.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a84d04f-1780-42b0-a538-56bfcdd74e30",
   "metadata": {},
   "source": [
    "**We're ready to create our target list of most _similar_ words!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "6aa752f5-e28f-477f-9915-c09f4d8046e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will hold the most similar words, alwasy 1 per variety\n",
    "similar_words = list()\n",
    "# loop over the varieties as long as \n",
    "# we have words to add (IndexError if a synonym list is empyt)\n",
    "while any(len(valsims) for valsims in variety_syno.values()):\n",
    "    for variety in varieties:\n",
    "        variety_sims = variety_syno[variety]\n",
    "        if variety_sims:\n",
    "            word = variety_sims.pop()\n",
    "            while word in similar_words and variety_sims:\n",
    "                word = variety_sims.pop()\n",
    "    if word not in similar_words:\n",
    "        similar_words.append(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3ea56650-6709-4cb9-bdb5-6825f854e345",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "In the end we get a list of **3544 most similar words**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(Markdown(f'In the end we get a list of **{len(similar_words)} most similar words**.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "04e840d6-83b3-45e5-84fb-73f09225d85e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list for later use\n",
    "with open(f'data/targetWordSets/similar_words_{nbrWords}based_{\"balanced\" if balance else \"\"}.json', 'w') as fo:\n",
    "    json.dump(similar_words, fo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4edcde80-3196-46e8-a1a0-828ceb2e20a3",
   "metadata": {},
   "source": [
    "---\n",
    "#### Dissimilar Words\n",
    "\n",
    "For this case we are interested in word(-vectors) as dissimilar as possible to our wine variety(-vectors).\n",
    "In terms of vectors this translates to: \n",
    "We are looking for vectors that point into a direction opposite to the one of the variety(-vectors). So, we are looking for word(-vectors) with a high similarity to the inverse of variety(-vectors).\n",
    "\n",
    "Basically simply invert each variety(-vector) and find the most similar word(-vectors) for the inverted vector:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d8ec2ee2-4d61-48ad-a0f4-e6a57fadf86d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2.35 s, sys: 418 ms, total: 2.77 s\n",
      "Wall time: 11.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "# how many sinonyms should be fetched\n",
    "fetch = 1400\n",
    "variety_anto = {}\n",
    "for variety in varieties:\n",
    "    # get the vecotr representation of the variety\n",
    "    var_vector = np.array(\n",
    "        w2v_model_fitted.getVectors().filter(col('word')==variety).first()[1]\n",
    "    )\n",
    "    # invert it\n",
    "    inverted = (-1) * var_vector\n",
    "    # and now it's same same as for the similar words...\n",
    "    synonyms = w2v_model_fitted.findSynonyms(inverted, fetch)\n",
    "    # we want to exclude other varieties:\n",
    "    # we take both the word and the similarity to avoid resorting\n",
    "    variety_anto[variety] = list(np.array(synonyms.filter(\n",
    "        ~col('word').isin(varieties)\n",
    "    ).select('word', 'similarity').collect()).reshape(-1))\n",
    "# Now we drop the similarity values and invert the list\n",
    "variety_anto = {var: sins[-2::-2] for var, sins in variety_anto.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73430bd5-5130-4aeb-9481-fef4fd29f923",
   "metadata": {},
   "source": [
    "**We're ready to create our target list of most _dissimilar_ words!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cafe4c23-4115-484e-926b-cc486677f327",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this will hold the most similar words, alwasy 1 per variety\n",
    "dissimilar_words = list()\n",
    "# loop over the varieties as long as \n",
    "# we have words to add (IndexError if a synonym list is empyt)\n",
    "while any(len(vals) for vals in variety_anto.values()):\n",
    "    for variety in varieties:\n",
    "        var_vals = variety_anto[variety]\n",
    "        if var_vals:\n",
    "            word = var_vals.pop()\n",
    "            while word in dissimilar_words and var_vals:\n",
    "                word = var_vals.pop()\n",
    "    if word not in dissimilar_words:\n",
    "        dissimilar_words.append(word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cc9ff0ed-4ae7-4035-bd3e-a5b8067a229e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "In the end we get a list of **1400 most dissimilar words**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(Markdown(f'In the end we get a list of **{len(dissimilar_words)} most dissimilar words**.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cd2727eb-f47b-48a4-84f6-6247eb32c634",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list for later use\n",
    "with open(f'data/targetWordSets/dissimilar_words_{nbrWords}based_{\"balanced\" if balance else \"\"}.json', 'w') as fo:\n",
    "    json.dump(dissimilar_words, fo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f661ce4-3727-4b6d-abdf-1a4cbdbf4f62",
   "metadata": {},
   "source": [
    "---\n",
    "#### Extremes Word Set\n",
    "\n",
    "This is simply a combination of the list of most similar and most dissimilar words.\n",
    "We combine the two lists like a zipper so that every other word is a similar and in-between are dissimilar words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "20737e7a-daa3-4fdd-acf3-81e2d6f09b48",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "extreme_words = list(chain.from_iterable(zip(similar_words, dissimilar_words)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a1313770-0bda-44c6-af5d-9534e0f904f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fortify', 'velvet', 'tawny', 'lurton', 'brandy', 'muscadelle', 'touriga', 'heavily', 'tinta', 'aragonez'] \n",
      " ['affordable', 'kiwis', 'plums', 'gala', 'basic', 'brighten', 'leave', 'central', 'soil', 'tongue'] \n",
      " ['fortify', 'affordable', 'velvet', 'kiwis', 'tawny', 'plums', 'lurton', 'gala', 'brandy', 'basic']\n"
     ]
    }
   ],
   "source": [
    "# just to check that we got it right:\n",
    "print(similar_words[:10], '\\n', dissimilar_words[:10], '\\n', extreme_words[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "4e1ba8f7-68f9-418b-99c8-e84dace42500",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list for later use\n",
    "with open(f'data/targetWordSets/extreme_words_{nbrWords}based_{\"balanced\" if balance else \"\"}.json', 'w') as fo:\n",
    "    json.dump(extreme_words, fo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4202810-edc1-4ec3-bc63-a28eaf7dc2e3",
   "metadata": {},
   "source": [
    "---\n",
    "#### Low Entropy Word Set\n",
    "\n",
    "Our last target words set is slightly more sophisticated as it is based on a measure for how (un-)even a quantity (the similarity in this case) is distributed.\n",
    "\n",
    "The idea is that a word from the review text will have approximately the same similarity to all wine variety(-vectors) if it occurs in all reviews, no matter the variety.\n",
    "\n",
    "Here we should also recall that we trained our word2vec on an unbiased dataset, `w2v_upscaled`, and thus, if a word is used in every review no matter the wine variety, this word will have the same amount of word-variety pairs for all varieties.\n",
    "Hence we expect it to be equally close to all wine varieties.\n",
    "Said differently, such a word will have a rather uniform distribution of similarity over the variety(-vectors).\n",
    "Also, such a word is not a good candidate for our target words set, as it does not convey any particular information on the wine variety at hand.\n",
    "\n",
    "So ideally we find a ways to measure for each word how (non-)uniform the distribution of similarity with the variety(-vectors) is.\n",
    "\n",
    "The [information entropy](https://en.wikipedia.org/wiki/Entropy_(information_theory)) measures basically this.\n",
    "If a word is equally similar (in terms of cosine similarity) to all wine varieties, its similarity distribution will have a maximal entropy.\n",
    "Consequentially, we identify the words with the lowest entropy in their similarity distribution and use these words in our target word set.\n",
    "\n",
    "We use the [scipy](https://www.scipy.org/) package for an implementation of the information entropy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e0fd199d-b89f-4726-aa6f-d44b18bc93cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import entropy as sci_entropy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "721e12ab-e2a2-4439-aed3-cef7868395ae",
   "metadata": {},
   "source": [
    "Let's get for each word the similarity distribution for variety vectors:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "812f96b4-8b49-4d90-b78a-07d09d36b97e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4031 more to go\n",
      "3931 more to go\n",
      "3831 more to go\n",
      "3731 more to go\n",
      "3631 more to go\n",
      "3531 more to go\n",
      "3431 more to go\n",
      "3331 more to go\n",
      "3231 more to go\n",
      "3131 more to go\n",
      "3031 more to go\n",
      "2931 more to go\n",
      "2831 more to go\n",
      "2731 more to go\n",
      "2631 more to go\n",
      "2531 more to go\n",
      "2431 more to go\n",
      "2331 more to go\n",
      "2231 more to go\n",
      "2131 more to go\n",
      "2031 more to go\n",
      "1931 more to go\n",
      "1831 more to go\n",
      "1731 more to go\n",
      "1631 more to go\n",
      "1531 more to go\n",
      "1431 more to go\n",
      "1331 more to go\n",
      "1231 more to go\n",
      "1131 more to go\n",
      "1031 more to go\n",
      "931 more to go\n",
      "831 more to go\n",
      "731 more to go\n",
      "631 more to go\n",
      "531 more to go\n",
      "431 more to go\n",
      "331 more to go\n",
      "231 more to go\n",
      "131 more to go\n",
      "31 more to go\n",
      "CPU times: user 35min 25s, sys: 14min 15s, total: 49min 40s\n",
      "Wall time: 1h 4min 44s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pot_words = []\n",
    "entropies = []\n",
    "encoded_words = list(np.array(\n",
    "    w2v_model_fitted.getVectors().select('word').collect()\n",
    ").reshape(-1))\n",
    "nbr_words = len(encoded_words)\n",
    "for i, word in enumerate(encoded_words):\n",
    "    if not i % 100:\n",
    "        print(f'{nbr_words - i} more to go')\n",
    "    vals = []\n",
    "    if word not in varieties:\n",
    "        synonyms = w2v_model_fitted.findSynonymsArray(word, 10000)\n",
    "        vals = [sim for w, sim in synonyms if w in varieties]\n",
    "        # cosine similarity is [-1,1] so we shift it to [0,2]\n",
    "        # we use `nbr_labels` as log basis to get avalue in [0,1]\n",
    "        entropy = sci_entropy(list(map(lambda x: (x+1), vals)), base=nbr_labels)\n",
    "        pot_words.append(word)\n",
    "        entropies.append(entropy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d6ca0b3-20f8-4f54-891e-d2cf6d3b0430",
   "metadata": {},
   "source": [
    "Now we have all we need to compile a ranking of relevant words.\n",
    "\n",
    "Our most relevant words are the ones with the lowest entropy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b9c95b9b-4933-49d1-9d66-113c261d26a9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "lowentropy_words, relevant_entropies = zip(*sorted(zip(pot_words, entropies),\n",
    "                                                 key=lambda x: x[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "09dbd4d7-c966-4f8c-ab59-8fb195a98c07",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "In the end we get a list of **3974 low entropy words**."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(Markdown(f'In the end we get a list of **{len(lowentropy_words)} low entropy words**.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a999cf76-fe2e-4d18-8395-97f711c8543b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the list for later use\n",
    "with open(f'data/targetWordSets/lowentropy_words_{nbrWords}based_{\"balanced\" if balance else \"\"}.json', 'w') as fo:\n",
    "    json.dump(lowentropy_words, fo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38971526-6bb3-4322-ac51-69cfa987f546",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}