assignments/a1/exploring_word_vectors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3HqK14JLSStR"
   },
   "source": [
    "# CS224N Assignment 1: Exploring Word Vectors (25 Points)\n",
    "### <font color='blue'> Due 4:30pm, Tue April 9th 2024</font>\n",
    "\n",
    "Welcome to CS224N! \n",
    "\n",
    "Before you start, make sure you **read the README.md** in the same directory as this notebook for important setup information. You need to install some Python libraries before you can successfully do this assignment. A lot of code is provided in this notebook, and we highly encourage you to read and understand it as part of the learning :)\n",
    "\n",
    "If you aren't super familiar with Python, Numpy, or Matplotlib, we recommend you check out the review session on Friday. The session will be recorded and the material will be made available on our [website](http://web.stanford.edu/class/cs224n/index.html#schedule). The CS231N Python/Numpy [tutorial](https://cs231n.github.io/python-numpy-tutorial/) is also a great resource.\n",
    "\n",
    "\n",
    "**Assignment Notes:** Please make sure to save the notebook as you go along. Submission Instructions are located at the bottom of the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-27T08:04:19.343709Z",
     "start_time": "2024-03-27T08:04:15.222676Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "8AGQxROrSStf",
    "outputId": "45390a52-8c82-466d-dcf3-d5b355f14aa4"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/abaowei/miniforge3/envs/fun/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "# All Import Statements Defined Here\n",
    "# Note: Do not add to this list.\n",
    "# ----------------\n",
    "\n",
    "import sys\n",
    "# Check if python version is at least 3.8\n",
    "assert sys.version_info[0] == 3\n",
    "assert sys.version_info[1] >= 8\n",
    "\n",
    "from platform import python_version\n",
    "assert int(python_version().split(\".\")[1]) >= 5, \"Please upgrade your Python version following the instructions in \\\n",
    "    the README.md file found in the same directory as this notebook. Your Python version is \" + python_version()\n",
    "\n",
    "from gensim.models import KeyedVectors\n",
    "from gensim.test.utils import datapath\n",
    "import pprint\n",
    "import matplotlib.pyplot as plt\n",
    "plt.rcParams['figure.figsize'] = [10, 5]\n",
    "\n",
    "from datasets import load_dataset\n",
    "imdb_dataset = load_dataset(\"stanfordnlp/imdb\")\n",
    "\n",
    "import re\n",
    "import numpy as np\n",
    "import random\n",
    "import scipy as sp\n",
    "from sklearn.decomposition import TruncatedSVD\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "START_TOKEN = '<START>'\n",
    "END_TOKEN = '<END>'\n",
    "NUM_SAMPLES = 150\n",
    "\n",
    "np.random.seed(0)\n",
    "random.seed(0)\n",
    "# ----------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SICd5IedSSto"
   },
   "source": [
    "## Word Vectors\n",
    "\n",
    "Word Vectors are often used as a fundamental component for downstream NLP tasks, e.g. question answering, text generation, translation, etc., so it is important to build some intuitions as to their strengths and weaknesses. Here, you will explore two types of word vectors: those derived from *co-occurrence matrices*, and those derived via *GloVe*. \n",
    "\n",
    "**Note on Terminology:** The terms \"word vectors\" and \"word embeddings\" are often used interchangeably. The term \"embedding\" refers to the fact that we are encoding aspects of a word's meaning in a lower dimensional space. As [Wikipedia](https://en.wikipedia.org/wiki/Word_embedding) states, \"*conceptually it involves a mathematical embedding from a space with one dimension per word to a continuous vector space with a much lower dimension*\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6Eug6AVrSStr"
   },
   "source": [
    "## Part 1: Count-Based Word Vectors (10 points)\n",
    "\n",
    "Most word vector models start from the following idea:\n",
    "\n",
    "*You shall know a word by the company it keeps ([Firth, J. R. 1957:11](https://en.wikipedia.org/wiki/John_Rupert_Firth))*\n",
    "\n",
    "Many word vector implementations are driven by the idea that similar words, i.e., (near) synonyms, will be used in similar contexts. As a result, similar words will often be spoken or written along with a shared subset of words, i.e., contexts. By examining these contexts, we can try to develop embeddings for our words. With this intuition in mind, many \"old school\" approaches to constructing word vectors relied on word counts. Here we elaborate upon one of those strategies, *co-occurrence matrices* (for more information, see [here](https://web.stanford.edu/~jurafsky/slp3/6.pdf) or [here](https://web.archive.org/web/20190530091127/https://medium.com/data-science-group-iitr/word-embedding-2d05d270b285))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "L6uQ9-DVSSts"
   },
   "source": [
    "### Co-Occurrence\n",
    "\n",
    "A co-occurrence matrix counts how often things co-occur in some environment. Given some word $w_i$ occurring in the document, we consider the *context window* surrounding $w_i$. Supposing our fixed window size is $n$, then this is the $n$ preceding and $n$ subsequent words in that document, i.e. words $w_{i-n} \\dots w_{i-1}$ and $w_{i+1} \\dots w_{i+n}$. We build a *co-occurrence matrix* $M$, which is a symmetric word-by-word matrix in which $M_{ij}$ is the number of times $w_j$ appears inside $w_i$'s window among all documents.\n",
    "\n",
    "**Example: Co-Occurrence with Fixed Window of n=1**:\n",
    "\n",
    "Document 1: \"all that glitters is not gold\"\n",
    "\n",
    "Document 2: \"all is well that ends well\"\n",
    "\n",
    "\n",
    "|     *    | `<START>` | all | that | glitters | is   | not  | gold  | well | ends | `<END>` |\n",
    "|----------|-------|-----|------|----------|------|------|-------|------|------|-----|\n",
    "| `<START>`    | 0     | 2   | 0    | 0        | 0    | 0    | 0     | 0    | 0    | 0   |\n",
    "| all      | 2     | 0   | 1    | 0        | 1    | 0    | 0     | 0    | 0    | 0   |\n",
    "| that     | 0     | 1   | 0    | 1        | 0    | 0    | 0     | 1    | 1    | 0   |\n",
    "| glitters | 0     | 0   | 1    | 0        | 1    | 0    | 0     | 0    | 0    | 0   |\n",
    "| is       | 0     | 1   | 0    | 1        | 0    | 1    | 0     | 1    | 0    | 0   |\n",
    "| not      | 0     | 0   | 0    | 0        | 1    | 0    | 1     | 0    | 0    | 0   |\n",
    "| gold     | 0     | 0   | 0    | 0        | 0    | 1    | 0     | 0    | 0    | 1   |\n",
    "| well     | 0     | 0   | 1    | 0        | 1    | 0    | 0     | 0    | 1    | 1   |\n",
    "| ends     | 0     | 0   | 1    | 0        | 0    | 0    | 0     | 1    | 0    | 0   |\n",
    "| `<END>`      | 0     | 0   | 0    | 0        | 0    | 0    | 1     | 1    | 0    | 0   |\n",
    "\n",
    "In NLP, we commonly use `<START>` and `<END>` tokens to mark the beginning and end of sentences, paragraphs, or documents. These tokens are included in co-occurrence counts, encapsulating each document, for example: \"`<START>` All that glitters is not gold `<END>`\".\n",
    "\n",
    "The matrix rows (or columns) provide word vectors based on word-word co-occurrence, but they can be large. To reduce dimensionality, we employ Singular Value Decomposition (SVD), akin to PCA, selecting the top $k$ principal components. The SVD process decomposes the co-occurrence matrix $A$ into singular values in the diagonal $S$ matrix and new, shorter word vectors in $U_k$.\n",
    "\n",
    "This dimensionality reduction maintains semantic relationships; for instance, *doctor* and *hospital* will be closer than *doctor* and *dog*.\n",
    "\n",
    "For those unfamiliar with eigenvalues and SVD, a beginner-friendly introduction to SVD is available [here](https://davetang.org/file/Singular_Value_Decomposition_Tutorial.pdf). Additional resources for in-depth understanding include lectures [7](https://web.stanford.edu/class/cs168/l/l7.pdf), [8](http://theory.stanford.edu/~tim/s15/l/l8.pdf), and [9](https://web.stanford.edu/class/cs168/l/l9.pdf) of CS168, providing high-level treatment of these algorithms. For practical implementation, utilizing pre-programmed functions from Python packages like numpy, scipy, or sklearn is recommended. While applying full SVD to large corpora can be memory-intensive, scalable techniques such as Truncated SVD exist for extracting the top $k$ vector components efficiently."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7IKeK4xtSStv"
   },
   "source": [
    "### Plotting Co-Occurrence Word Embeddings\n",
    "\n",
    "Here, we will be using the Large Movie Review Dataset. This is a dataset for binary sentiment classification containing substantially more data than previous benchmark datasets. We provide a set of 25,000 highly polar movie reviews for training, and 25,000 for testing. There is additional unlabeled data for use as well. We provide a `read_corpus` function below that pulls out the text of a movie review from the dataset. The function also adds `<START>` and `<END>` tokens to each of the documents, and lowercases words. You do **not** have to perform any other kind of pre-processing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-27T08:06:28.097673Z",
     "start_time": "2024-03-27T08:06:28.094138Z"
    },
    "id": "xwD2htUoSStw"
   },
   "outputs": [],
   "source": [
    "def read_corpus():\n",
    "    \"\"\" Read files from the Large Movie Review Dataset.\n",
    "        Params:\n",
    "            category (string): category name\n",
    "        Return:\n",
    "            list of lists, with words from each of the processed files\n",
    "    \"\"\"\n",
    "    files = imdb_dataset[\"train\"][\"text\"][:NUM_SAMPLES]\n",
    "    return [[START_TOKEN] + [re.sub(r'[^\\w]', '', w.lower()) for w in f.split(\" \")] + [END_TOKEN] for f in files]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hVLquFhjSStx"
   },
   "source": [
    "Let's have a look what these documents are like…."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-03-27T08:06:29.881790Z",
     "start_time": "2024-03-27T08:06:29.404708Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mC7B9Cb-SSty",
    "outputId": "a1861c4f-723a-4d99-98d9-5f5db3a92e7a"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['<START>', 'i', 'rented', 'i', 'am', 'curiousyellow', 'from', 'my', 'video', 'store', 'because',\n",
      "  'of', 'all', 'the', 'controversy', 'that', 'surrounded', 'it', 'when', 'it', 'was', 'first',\n",
      "  'released', 'in', '1967', 'i', 'also', 'heard', 'that', 'at', 'first', 'it', 'was', 'seized',\n",
      "  'by', 'us', 'customs', 'if', 'it', 'ever', 'tried', 'to', 'enter', 'this', 'country', 'therefore',\n",
      "  'being', 'a', 'fan', 'of', 'films', 'considered', 'controversial', 'i', 'really', 'had', 'to',\n",
      "  'see', 'this', 'for', 'myselfbr', 'br', 'the', 'plot', 'is', 'centered', 'around', 'a', 'young',\n",
      "  'swedish', 'drama', 'student', 'named', 'lena', 'who', 'wants', 'to', 'learn', 'everything',\n",
      "  'she', 'can', 'about', 'life', 'in', 'particular', 'she', 'wants', 'to', 'focus', 'her',\n",
      "  'attentions', 'to', 'making', 'some', 'sort', 'of', 'documentary', 'on', 'what', 'the', 'average',\n",
      "  'swede', 'thought', 'about', 'certain', 'political', 'issues', 'such', 'as', 'the', 'vietnam',\n",
      "  'war', 'and', 'race', 'issues', 'in', 'the', 'united', 'states', 'in', 'between', 'asking',\n",
      "  'politicians', 'and', 'ordinary', 'denizens', 'of', 'stockholm', 'about', 'their', 'opinions',\n",
      "  'on', 'politics', 'she', 'has', 'sex', 'with', 'her', 'drama', 'teacher', 'classmates', 'and',\n",
      "  'married', 'menbr', 'br', 'what', 'kills', 'me', 'about', 'i', 'am', 'curiousyellow', 'is',\n",
      "  'that', '40', 'years', 'ago', 'this', 'was', 'considered', 'pornographic', 'really', 'the', 'sex',\n",
      "  'and', 'nudity', 'scenes', 'are', 'few', 'and', 'far', 'between', 'even', 'then', 'its', 'not',\n",
      "  'shot', 'like', 'some', 'cheaply', 'made', 'porno', 'while', 'my', 'countrymen', 'mind', 'find',\n",
      "  'it', 'shocking', 'in', 'reality', 'sex', 'and', 'nudity', 'are', 'a', 'major', 'staple', 'in',\n",
      "  'swedish', 'cinema', 'even', 'ingmar', 'bergman', 'arguably', 'their', 'answer', 'to', 'good',\n",
      "  'old', 'boy', 'john', 'ford', 'had', 'sex', 'scenes', 'in', 'his', 'filmsbr', 'br', 'i', 'do',\n",
      "  'commend', 'the', 'filmmakers', 'for', 'the', 'fact', 'that', 'any', 'sex', 'shown', 'in', 'the',\n",
      "  'film', 'is', 'shown', 'for', 'artistic', 'purposes', 'rather', 'than', 'just', 'to', 'shock',\n",
      "  'people', 'and', 'make', 'money', 'to', 'be', 'shown', 'in', 'pornographic', 'theaters', 'in',\n",
      "  'america', 'i', 'am', 'curiousyellow', 'is', 'a', 'good', 'film', 'for', 'anyone', 'wanting',\n",
      "  'to', 'study', 'the', 'meat', 'and', 'potatoes', 'no', 'pun', 'intended', 'of', 'swedish',\n",
      "  'cinema', 'but', 'really', 'this', 'film', 'doesnt', 'have', 'much', 'of', 'a', 'plot', '<END>'],\n",
      " ['<START>', 'i', 'am', 'curious', 'yellow', 'is', 'a', 'risible', 'and', 'pretentious', 'steaming',\n",
      "  'pile', 'it', 'doesnt', 'matter', 'what', 'ones', 'political', 'views', 'are', 'because', 'this',\n",
      "  'film', 'can', 'hardly', 'be', 'taken', 'seriously', 'on', 'any', 'level', 'as', 'for', 'the',\n",
      "  'claim', 'that', 'frontal', 'male', 'nudity', 'is', 'an', 'automatic', 'nc17', 'that', 'isnt',\n",
      "  'true', 'ive', 'seen', 'rrated', 'films', 'with', 'male', 'nudity', 'granted', 'they', 'only',\n",
      "  'offer', 'some', 'fleeting', 'views', 'but', 'where', 'are', 'the', 'rrated', 'films', 'with',\n",
      "  'gaping', 'vulvas', 'and', 'flapping', 'labia', 'nowhere', 'because', 'they', 'dont', 'exist',\n",
      "  'the', 'same', 'goes', 'for', 'those', 'crappy', 'cable', 'shows', 'schlongs', 'swinging', 'in',\n",
      "  'the', 'breeze', 'but', 'not', 'a', 'clitoris', 'in', 'sight', 'and', 'those', 'pretentious',\n",
      "  'indie', 'movies', 'like', 'the', 'brown', 'bunny', 'in', 'which', 'were', 'treated', 'to', 'the',\n",
      "  'site', 'of', 'vincent', 'gallos', 'throbbing', 'johnson', 'but', 'not', 'a', 'trace', 'of',\n",
      "  'pink', 'visible', 'on', 'chloe', 'sevigny', 'before', 'crying', 'or', 'implying',\n",
      "  'doublestandard', 'in', 'matters', 'of', 'nudity', 'the', 'mentally', 'obtuse', 'should', 'take',\n",
      "  'into', 'account', 'one', 'unavoidably', 'obvious', 'anatomical', 'difference', 'between', 'men',\n",
      "  'and', 'women', 'there', 'are', 'no', 'genitals', 'on', 'display', 'when', 'actresses', 'appears',\n",
      "  'nude', 'and', 'the', 'same', 'cannot', 'be', 'said', 'for', 'a', 'man', 'in', 'fact', 'you',\n",
      "  'generally', 'wont', 'see', 'female', 'genitals', 'in', 'an', 'american', 'film', 'in',\n",
      "  'anything', 'short', 'of', 'porn', 'or', 'explicit', 'erotica', 'this', 'alleged',\n",
      "  'doublestandard', 'is', 'less', 'a', 'double', 'standard', 'than', 'an', 'admittedly',\n",
      "  'depressing', 'ability', 'to', 'come', 'to', 'terms', 'culturally', 'with', 'the', 'insides',\n",
      "  'of', 'womens', 'bodies', '<END>'],\n",
      " ['<START>', 'if', 'only', 'to', 'avoid', 'making', 'this', 'type', 'of', 'film', 'in', 'the',\n",
      "  'future', 'this', 'film', 'is', 'interesting', 'as', 'an', 'experiment', 'but', 'tells', 'no',\n",
      "  'cogent', 'storybr', 'br', 'one', 'might', 'feel', 'virtuous', 'for', 'sitting', 'thru', 'it',\n",
      "  'because', 'it', 'touches', 'on', 'so', 'many', 'important', 'issues', 'but', 'it', 'does', 'so',\n",
      "  'without', 'any', 'discernable', 'motive', 'the', 'viewer', 'comes', 'away', 'with', 'no', 'new',\n",
      "  'perspectives', 'unless', 'one', 'comes', 'up', 'with', 'one', 'while', 'ones', 'mind', 'wanders',\n",
      "  'as', 'it', 'will', 'invariably', 'do', 'during', 'this', 'pointless', 'filmbr', 'br', 'one',\n",
      "  'might', 'better', 'spend', 'ones', 'time', 'staring', 'out', 'a', 'window', 'at', 'a', 'tree',\n",
      "  'growingbr', 'br', '', '<END>']]\n",
      "corpus size:  290\n"
     ]
    }
   ],
   "source": [
    "imdb_corpus = read_corpus()\n",
    "pprint.pprint(imdb_corpus[:3], compact=True, width=100)\n",
    "print(\"corpus size: \", len(imdb_corpus[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tfa216H1SSt0"
   },
   "source": [
    "### Question 1.1: Implement `distinct_words` [code] (2 points)\n",
    "\n",
    "Write a method to work out the distinct words (word types) that occur in the corpus.\n",
    "\n",
    "You can use `for` loops to process the input `corpus` (a list of list of strings), but try using Python list comprehensions (which are generally faster). In particular, [this](https://coderwall.com/p/rcmaea/flatten-a-list-of-lists-in-one-line-in-python) may be useful to flatten a list of lists. If you're not familiar with Python list comprehensions in general, here's [more information](https://python-3-patterns-idioms-test.readthedocs.io/en/latest/Comprehensions.html).\n",
    "\n",
    "Your returned `corpus_words` should be sorted. You can use python's `sorted` function for this.\n",
    "\n",
    "You may find it useful to use [Python sets](https://www.w3schools.com/python/python_sets.asp) to remove duplicate words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "id": "NjJABbVFSSt1"
   },
   "outputs": [],
   "source": [
    "def distinct_words(corpus):\n",
    "    \"\"\" Determine a list of distinct words for the corpus.\n",
    "        Params:\n",
    "            corpus (list of list of strings): corpus of documents\n",
    "        Return:\n",
    "            corpus_words (list of strings): sorted list of distinct words across the corpus\n",
    "            n_corpus_words (integer): number of distinct words across the corpus\n",
    "    \"\"\"\n",
    "    corpus_words = []\n",
    "    n_corpus_words = -1\n",
    "    \n",
    "    # ------------------\n",
    "    # Write your implementation here.\n",
    "    # Flatten the corpus\n",
    "    flat_corpus = [w for doc in corpus for w in doc]\n",
    "\n",
    "    # Deduplicate and sort words\n",
    "    corpus_words = sorted(set(flat_corpus))\n",
    "    assert isinstance(corpus_words, list), \"corpus_words should be of type list.\"\n",
    "\n",
    "    # Derive the number of distinct words\n",
    "    n_corpus_words = len(corpus_words)\n",
    "    # ------------------\n",
    "\n",
    "    return corpus_words, n_corpus_words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iKfXBXySSSt3",
    "outputId": "8b49421a-1cff-4f10-fe4a-927f30570b59"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Passed All Tests!\n",
      "--------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# ---------------------\n",
    "# Run this sanity check\n",
    "# Note that this not an exhaustive check for correctness.\n",
    "# ---------------------\n",
    "\n",
    "# Define toy corpus\n",
    "test_corpus = [\"{} All that glitters isn't gold {}\".format(START_TOKEN, END_TOKEN).split(\" \"), \"{} All's well that ends well {}\".format(START_TOKEN, END_TOKEN).split(\" \")]\n",
    "test_corpus_words, num_corpus_words = distinct_words(test_corpus)\n",
    "\n",
    "# Correct answers\n",
    "ans_test_corpus_words = sorted([START_TOKEN, \"All\", \"ends\", \"that\", \"gold\", \"All's\", \"glitters\", \"isn't\", \"well\", END_TOKEN])\n",
    "ans_num_corpus_words = len(ans_test_corpus_words)\n",
    "\n",
    "# Test correct number of words\n",
    "assert(num_corpus_words == ans_num_corpus_words), \"Incorrect number of distinct words. Correct: {}. Yours: {}\".format(ans_num_corpus_words, num_corpus_words)\n",
    "\n",
    "# Test correct words\n",
    "assert (test_corpus_words == ans_test_corpus_words), \"Incorrect corpus_words.\\nCorrect: {}\\nYours:   {}\".format(str(ans_test_corpus_words), str(test_corpus_words))\n",
    "\n",
    "# Print Success\n",
    "print (\"-\" * 80)\n",
    "print(\"Passed All Tests!\")\n",
    "print (\"-\" * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ymDFJn_lSSt5"
   },
   "source": [
    "### Question 1.2: Implement `compute_co_occurrence_matrix` [code] (3 points)\n",
    "\n",
    "Write a method that constructs a co-occurrence matrix for a certain window-size $n$ (with a default of 4), considering words $n$ before and $n$ after the word in the center of the window. Here, we start to use `numpy (np)` to represent vectors, matrices, and tensors. If you're not familiar with NumPy, there's a NumPy tutorial in the second half of this cs231n [Python NumPy tutorial](http://cs231n.github.io/python-numpy-tutorial/).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "v8MIy3KDSSt6"
   },
   "outputs": [],
   "source": [
    "def compute_co_occurrence_matrix(corpus, window_size=4):\n",
    "    \"\"\" Compute co-occurrence matrix for the given corpus and window_size (default of 4).\n",
    "    \n",
    "        Note: Each word in a document should be at the center of a window. Words near edges will have a smaller\n",
    "              number of co-occurring words.\n",
    "              \n",
    "              For example, if we take the document \"<START> All that glitters is not gold <END>\" with window size of 4,\n",
    "              \"All\" will co-occur with \"<START>\", \"that\", \"glitters\", \"is\", and \"not\".\n",
    "    \n",
    "        Params:\n",
    "            corpus (list of list of strings): corpus of documents\n",
    "            window_size (int): size of context window\n",
    "        Return:\n",
    "            M (a symmetric numpy matrix of shape (number of unique words in the corpus , number of unique words in the corpus)): \n",
    "                Co-occurence matrix of word counts. \n",
    "                The ordering of the words in the rows/columns should be the same as the ordering of the words given by the distinct_words function.\n",
    "            word2ind (dict): dictionary that maps word to index (i.e. row/column number) for matrix M.\n",
    "    \"\"\"\n",
    "    words, n_words = distinct_words(corpus)\n",
    "    M = None\n",
    "    word2ind = {}\n",
    "    \n",
    "    # ------------------\n",
    "    # Write your implementation here.\n",
    "    # Map unique words to corresponding indices\n",
    "    word2ind = {word: ind for ind, word in enumerate(words)}\n",
    "\n",
    "    # Construct the co-occurrence matrix\n",
    "    M = np.zeros((n_words, n_words), dtype=np.int32)\n",
    "    for doc in corpus:\n",
    "        for t_c, w_c in enumerate(doc):\n",
    "            # Set context boundaries\n",
    "            # lo, hi = max(t_c - window_size, 0), min(t_c + window_size + 1, len(doc))\n",
    "            lo, hi = t_c + 1, min(t_c + window_size + 1, len(doc))\n",
    "            \n",
    "            for t_o in range(lo, hi):\n",
    "                if t_c == t_o:\n",
    "                    # Skip the center word\n",
    "                    continue\n",
    "\n",
    "                # Increase occurrence of the (center word, context word) pair\n",
    "                i, j = word2ind[w_c], word2ind[doc[t_o]]\n",
    "                M[i][j] += 1\n",
    "\n",
    "    M += M.T\n",
    "    # ------------------\n",
    "    \n",
    "    return M, word2ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u-6ID1qhSSt7",
    "outputId": "f4f1bccb-06a8-4bb6-ec80-f2b6201b2645"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Passed All Tests!\n",
      "--------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# ---------------------\n",
    "# Run this sanity check\n",
    "# Note that this is not an exhaustive check for correctness.\n",
    "# ---------------------\n",
    "\n",
    "# Define toy corpus and get student's co-occurrence matrix\n",
    "test_corpus = [\"{} All that glitters isn't gold {}\".format(START_TOKEN, END_TOKEN).split(\" \"), \"{} All's well that ends well {}\".format(START_TOKEN, END_TOKEN).split(\" \")]\n",
    "M_test, word2ind_test = compute_co_occurrence_matrix(test_corpus, window_size=1)\n",
    "\n",
    "# Correct M and word2ind\n",
    "M_test_ans = np.array( \n",
    "    [[0., 0., 0., 0., 0., 0., 1., 0., 0., 1.,],\n",
    "     [0., 0., 1., 1., 0., 0., 0., 0., 0., 0.,],\n",
    "     [0., 1., 0., 0., 0., 0., 0., 0., 1., 0.,],\n",
    "     [0., 1., 0., 0., 0., 0., 0., 0., 0., 1.,],\n",
    "     [0., 0., 0., 0., 0., 0., 0., 0., 1., 1.,],\n",
    "     [0., 0., 0., 0., 0., 0., 0., 1., 1., 0.,],\n",
    "     [1., 0., 0., 0., 0., 0., 0., 1., 0., 0.,],\n",
    "     [0., 0., 0., 0., 0., 1., 1., 0., 0., 0.,],\n",
    "     [0., 0., 1., 0., 1., 1., 0., 0., 0., 1.,],\n",
    "     [1., 0., 0., 1., 1., 0., 0., 0., 1., 0.,]]\n",
    ")\n",
    "ans_test_corpus_words = sorted([START_TOKEN, \"All\", \"ends\", \"that\", \"gold\", \"All's\", \"glitters\", \"isn't\", \"well\", END_TOKEN])\n",
    "word2ind_ans = dict(zip(ans_test_corpus_words, range(len(ans_test_corpus_words))))\n",
    "\n",
    "# Test correct word2ind\n",
    "assert (word2ind_ans == word2ind_test), \"Your word2ind is incorrect:\\nCorrect: {}\\nYours: {}\".format(word2ind_ans, word2ind_test)\n",
    "\n",
    "# Test correct M shape\n",
    "assert (M_test.shape == M_test_ans.shape), \"M matrix has incorrect shape.\\nCorrect: {}\\nYours: {}\".format(M_test.shape, M_test_ans.shape)\n",
    "\n",
    "# Test correct M values\n",
    "for w1 in word2ind_ans.keys():\n",
    "    idx1 = word2ind_ans[w1]\n",
    "    for w2 in word2ind_ans.keys():\n",
    "        idx2 = word2ind_ans[w2]\n",
    "        student = M_test[idx1, idx2]\n",
    "        correct = M_test_ans[idx1, idx2]\n",
    "        if student != correct:\n",
    "            print(\"Correct M:\")\n",
    "            print(M_test_ans)\n",
    "            print(\"Your M: \")\n",
    "            print(M_test)\n",
    "            raise AssertionError(\"Incorrect count at index ({}, {})=({}, {}) in matrix M. Yours has {} but should have {}.\".format(idx1, idx2, w1, w2, student, correct))\n",
    "\n",
    "# Print Success\n",
    "print (\"-\" * 80)\n",
    "print(\"Passed All Tests!\")\n",
    "print (\"-\" * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K-nyJnAASSt9"
   },
   "source": [
    "### Question 1.3: Implement `reduce_to_k_dim` [code] (1 point)\n",
    "\n",
    "Construct a method that performs dimensionality reduction on the matrix to produce k-dimensional embeddings. Use SVD to take the top k components and produce a new matrix of k-dimensional embeddings. \n",
    "\n",
    "**Note:** All of numpy, scipy, and scikit-learn (`sklearn`) provide *some* implementation of SVD, but only scipy and sklearn provide an implementation of Truncated SVD, and only sklearn provides an efficient randomized algorithm for calculating large-scale Truncated SVD. So please use [sklearn.decomposition.TruncatedSVD](https://scikit-learn.org/stable/modules/generated/sklearn.decomposition.TruncatedSVD.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "truGMjifSSt9"
   },
   "outputs": [],
   "source": [
    "def reduce_to_k_dim(M, k=2):\n",
    "    \"\"\" Reduce a co-occurence count matrix of dimensionality (num_corpus_words, num_corpus_words)\n",
    "        to a matrix of dimensionality (num_corpus_words, k) using the following SVD function from Scikit-Learn:\n",
    "            - http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.TruncatedSVD.html\n",
    "    \n",
    "        Params:\n",
    "            M (numpy matrix of shape (number of unique words in the corpus , number of unique words in the corpus)): co-occurence matrix of word counts\n",
    "            k (int): embedding size of each word after dimension reduction\n",
    "        Return:\n",
    "            M_reduced (numpy matrix of shape (number of corpus words, k)): matrix of k-dimensioal word embeddings.\n",
    "                    In terms of the SVD from math class, this actually returns U * S\n",
    "    \"\"\"    \n",
    "    n_iters = 10    # Use this parameter in your call to `TruncatedSVD`\n",
    "    M_reduced = None\n",
    "    print(\"Running Truncated SVD over %i words...\" % (M.shape[0]))\n",
    "    \n",
    "    # ------------------\n",
    "    # Write your implementation here.\n",
    "    svd = TruncatedSVD(n_components=k, n_iter=n_iters, random_state=42)\n",
    "    M_reduced = svd.fit_transform(M)\n",
    "    # ------------------\n",
    "\n",
    "    print(\"Done.\")\n",
    "    return M_reduced"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "7pqKuqvhSSt-",
    "outputId": "7d147bd2-9916-4226-d936-43ce795006cb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Truncated SVD over 10 words...\n",
      "Done.\n",
      "--------------------------------------------------------------------------------\n",
      "Passed All Tests!\n",
      "--------------------------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "# ---------------------\n",
    "# Run this sanity check\n",
    "# Note that this is not an exhaustive check for correctness \n",
    "# In fact we only check that your M_reduced has the right dimensions.\n",
    "# ---------------------\n",
    "\n",
    "# Define toy corpus and run student code\n",
    "test_corpus = [\"{} All that glitters isn't gold {}\".format(START_TOKEN, END_TOKEN).split(\" \"), \"{} All's well that ends well {}\".format(START_TOKEN, END_TOKEN).split(\" \")]\n",
    "M_test, word2ind_test = compute_co_occurrence_matrix(test_corpus, window_size=1)\n",
    "M_test_reduced = reduce_to_k_dim(M_test, k=2)\n",
    "\n",
    "# Test proper dimensions\n",
    "assert (M_test_reduced.shape[0] == 10), \"M_reduced has {} rows; should have {}\".format(M_test_reduced.shape[0], 10)\n",
    "assert (M_test_reduced.shape[1] == 2), \"M_reduced has {} columns; should have {}\".format(M_test_reduced.shape[1], 2)\n",
    "\n",
    "# Print Success\n",
    "print (\"-\" * 80)\n",
    "print(\"Passed All Tests!\")\n",
    "print (\"-\" * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "apZknsLoSSt_"
   },
   "source": [
    "### Question 1.4: Implement `plot_embeddings` [code] (1 point)\n",
    "\n",
    "Here you will write a function to plot a set of 2D vectors in 2D space. For graphs, we will use Matplotlib (`plt`).\n",
    "\n",
    "For this example, you may find it useful to adapt [this code](http://web.archive.org/web/20190924160434/https://www.pythonmembers.club/2018/05/08/matplotlib-scatter-plot-annotate-set-text-at-label-each-point/). In the future, a good way to make a plot is to look at [the Matplotlib gallery](https://matplotlib.org/gallery/index.html), find a plot that looks somewhat like what you want, and adapt the code they give."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "dDcCZE5lSSuA"
   },
   "outputs": [],
   "source": [
    "def plot_embeddings(M_reduced, word2ind, words):\n",
    "    \"\"\" Plot in a scatterplot the embeddings of the words specified in the list \"words\".\n",
    "        NOTE: do not plot all the words listed in M_reduced / word2ind.\n",
    "        Include a label next to each point.\n",
    "        \n",
    "        Params:\n",
    "            M_reduced (numpy matrix of shape (number of unique words in the corpus , 2)): matrix of 2-dimensioal word embeddings\n",
    "            word2ind (dict): dictionary that maps word to indices for matrix M\n",
    "            words (list of strings): words whose embeddings we want to visualize\n",
    "    \"\"\"\n",
    "\n",
    "    # ------------------\n",
    "    # Write your implementation here.\n",
    "    # Retrieve word embeddings to visualize\n",
    "    wi = [word2ind[w] for w in words]\n",
    "    M_vis = M_reduced[wi]\n",
    "    e0, e1 = M_vis[:, 0], M_vis[:, 1]\n",
    "\n",
    "    # Plot SVD components\n",
    "    fig, ax = plt.subplots(figsize=(12, 4))\n",
    "    ax.scatter(e0, e1, c=\"r\", marker=\"x\")\n",
    "    ax.set_title(\"SVD Components of Word Embeddings\")\n",
    "    ax.set_xlabel(\"Component 0\")\n",
    "    ax.set_ylabel(\"Component 1\")\n",
    "    for x, y, w in zip(e0, e1, words):\n",
    "        ax.text(x, y, w)\n",
    "    plt.tight_layout()\n",
    "    # ------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 372
    },
    "id": "gHxOMWPxSSuB",
    "outputId": "565711fc-02ea-43cb-daa5-8b8bb310cdda"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------------------------------------\n",
      "Outputted Plot:\n",
      "--------------------------------------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ---------------------\n",
    "# Run this sanity check\n",
    "# Note that this is not an exhaustive check for correctness.\n",
    "# The plot produced should look like the included file question_1.4_test.png \n",
    "# ---------------------\n",
    "\n",
    "print (\"-\" * 80)\n",
    "print (\"Outputted Plot:\")\n",
    "\n",
    "M_reduced_plot_test = np.array([[1, 1], [-1, -1], [1, -1], [-1, 1], [0, 0]])\n",
    "word2ind_plot_test = {'test1': 0, 'test2': 1, 'test3': 2, 'test4': 3, 'test5': 4}\n",
    "words = ['test1', 'test2', 'test3', 'test4', 'test5']\n",
    "plot_embeddings(M_reduced_plot_test, word2ind_plot_test, words)\n",
    "\n",
    "print (\"-\" * 80)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YpBzYs2hSSuC"
   },
   "source": [
    "### Question 1.5: Co-Occurrence Plot Analysis [written] (3 points)\n",
    "\n",
    "Now we will put together all the parts you have written! We will compute the co-occurrence matrix with fixed window of 4 (the default window size), over the Large Movie Review corpus. Then we will use TruncatedSVD to compute 2-dimensional embeddings of each word. TruncatedSVD returns U\\*S, so we need to normalize the returned vectors, so that all the vectors will appear around the unit circle (therefore closeness is directional closeness). **Note**: The line of code below that does the normalizing uses the NumPy concept of *broadcasting*. If you don't know about broadcasting, check out\n",
    "[Computation on Arrays: Broadcasting by Jake VanderPlas](https://jakevdp.github.io/PythonDataScienceHandbook/02.05-computation-on-arrays-broadcasting.html).\n",
    "\n",
    "Run the below cell to produce the plot. It can take up to a few minutes to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 355
    },
    "id": "7L1Uk50mSSuD",
    "outputId": "35ae3e41-07c8-421b-e75c-dcbeaa4fb015"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running Truncated SVD over 5880 words...\n",
      "Done.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAGGCAYAAACqvTJ0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB7mklEQVR4nO3de3zO9f/H8ee1zQ5su+a0E2M2jDmfYzKHFZHoIGrNyKFfobRUVA4pkSRyKspIxDekvqU5LBOjaJqU83mOI2wzGbbP7499d+WyYWMH43G/3T6326735/35fF6fax+6PHu/35fJMAxDAAAAAAAAQCGyKeoCAAAAAAAAcO8hlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAKMbOnz+vvn37ytPTUyaTSYMHDy7qkvKsdevWat26dVGXYTFnzhyZTCb99ttvBX6tXr16ydfX96b9Dh48KJPJpDlz5ljaRo0aJZPJVHDFAQBQwAilAAC4Tdu2bdMTTzyhypUry9HRURUqVNADDzygKVOmSJK2bNkik8mkt95667rn2LNnj0wmkyIiIiT9+4/NrK1kyZKqVKmSOnfurMjISKWlpeWpxn379um5556Tn5+fHB0d5erqqqCgIE2ePFn//PPPrd88JEkLFizQpEmTiuTa7733nubMmaPnn39e8+bNU1hYWI79AgMDVa9evWzt33zzjUwmk4KDg7Ptmz17tkwmk1auXJnvdd8KX19fqz8XV28dOnQo6vIAAEAe2RV1AQAAFGcbNmxQmzZtVKlSJfXr10+enp5KSEjQL7/8osmTJ2vQoEFq2LChatSooa+++krvvvtujudZsGCBJOmZZ56xap8xY4acnZ2Vlpamo0ePasWKFXr22Wc1adIkff/99/Lx8blpjT/88IO6desmBwcH9ezZU7Vr19alS5e0fv16vfrqq/rrr780c+bM238z7mELFizQn3/+WSSjlH766Sfdd999Gjly5A37tWzZUp9//rmSkpJkNpst7bGxsbKzs9PmzZt1+fJllShRwmqfra2tmjdvXmD151X9+vX1yiuvZGv39vYugmqK1ltvvaWhQ4cWdRkAANwyQikAAG7DmDFjZDabtXnzZrm5uVntS0xMtPwcGhqq4cOH65dfftF9992X7TxfffWVatSooYYNG1q1P/HEEypXrpzl9YgRIzR//nz17NlT3bp10y+//HLD+g4cOKAePXqocuXK+umnn+Tl5WXZN2DAAO3du1c//PBDXm4Zd5jExEQFBgbetF/Lli01a9YsbdiwQQ899JClPTY2Vk8++aQWLFiguLg4q+dz/fr1qlu3rlxcXG6rxtTUVJUqVeq2zpGlQoUK2cLbe5WdnZ3s7Pg4DwAovpi+BwDAbdi3b59q1aqVLZCSJHd3d8vPoaGhkv4dEXW1uLg47dq1y9LnZkJDQ9W3b1/9+uuvWrVq1Q37jh8/XufPn9fnn39uFUhlqVq1ql566SXL6ytXruidd96Rv7+/HBwc5OvrqzfeeCPbdEFfX189/PDDiomJUePGjeXk5KQ6deooJiZGkrR06VLVqVNHjo6OatSokX7//Xer43v16iVnZ2ft379f7du3V6lSpeTt7a3Ro0fLMAyrvqmpqXrllVfk4+MjBwcHBQQEaMKECdn6mUwmDRw4UMuWLVPt2rXl4OCgWrVqKSoqKtt9Hz16VM8++6w8PDws/WbPnm3VJyYmRiaTSf/5z380ZswYVaxYUY6OjmrXrp327t1r6de6dWv98MMPOnTokGUq2dVrBE2ZMkW1atVSyZIlVbp0aTVu3DjH5+BaiYmJ6tOnjzw8POTo6Kh69epp7ty52eo7cOCAfvjhB8u1Dx48mOP5WrZsKSkzhMpy8eJFbdmyRY899pj8/Pys9p06dUq7d++2HCdJv//+ux566CG5urrK2dlZ7dq1yxaMZq3HtHbtWr3wwgtyd3dXxYoVLftnzpwpf39/OTk5qWnTplq3bt1N34u8ynq+Dh8+rIcffljOzs6qUKGCpk2bJilzym3btm1VqlQpVa5c+bq/jwsXLui5555T2bJl5erqqp49e+rs2bPZ+v3444+6//77VapUKbm4uKhTp07666+/svXLejYdHR1Vu3ZtffPNNzle99y5c+rVq5fMZrPc3NwUHh6uc+fOZeuX05pSeflzkPXn19HRUf7+/vr0009zPOeqVavUsmVLubm5ydnZWQEBAXrjjTdyrB0AgDwxAADALXvwwQcNFxcXY9u2bTft26JFC8PDw8O4cuWKVXtERIQhydi3b5+lbeTIkYYk49SpUzmea926dYYkY8iQITe8ZoUKFQw/P79c3Emm8PBwQ5LxxBNPGNOmTTN69uxpSDK6du1q1a9y5cpGQECA4eXlZYwaNcr46KOPjAoVKhjOzs7Gl19+aVSqVMkYN26cMW7cOMNsNhtVq1Y10tPTra7j6OhoVKtWzQgLCzOmTp1qPPzww4YkY/jw4ZZ+GRkZRtu2bQ2TyWT07dvXmDp1qtG5c2dDkjF48GCrmiQZ9erVM7y8vIx33nnHmDRpkuHn52eULFnSOH36tKXfiRMnjIoVKxo+Pj7G6NGjjRkzZhiPPPKIIcn46KOPLP3WrFljSDIaNGhgNGrUyPjoo4+MUaNGGSVLljSaNm1q6bdy5Uqjfv36Rrly5Yx58+YZ8+bNM7755hvDMAxj5syZlvfz008/NSZPnmz06dPHePHFF2/4e7hw4YJRs2ZNo0SJEsbLL79sfPzxx8b9999vSDImTZpkuY958+YZ5cqVM+rXr2+59vnz5697Xm9vbyM4ONjy+ueffzYkGceOHTOeeeYZ49FHH7XsW7ZsmSHJWLRokWEYhvHnn38apUqVsry/48aNM6pUqWI4ODgYv/zyi+W4yMhIQ5IRGBhoBAcHG1OmTDHGjRtnGIZhfPbZZ4Yko0WLFsbHH39sDB482HBzczP8/Pys6rqeypUrGw8++KBx6tSpbNuFCxcs/bKer8DAQOP//u//jGnTphktWrQwJBmRkZGGt7e38eqrrxpTpkwxatWqZdja2hr79+/Pdg916tQx7r//fuPjjz82BgwYYNjY2BitWrUyMjIyLH2/+OILw2QyGR06dDCmTJlivP/++4avr6/h5uZmHDhwwNJvxYoVho2NjVG7dm1j4sSJxptvvmmYzWajVq1aRuXKlS39MjIyjFatWhk2NjbGCy+8YEyZMsVo27atUbduXUv9WbL+nrhabv8cbNmyxXBwcDB8fX2NcePGGWPGjDG8vb2NevXqWZ3zzz//NOzt7Y3GjRsbkydPNj755BNjyJAhRqtWrW76+wIA4GYIpQAAuA0rV640bG1tDVtbW6N58+bGa6+9ZqxYscK4dOlStr7Tpk0zJBkrVqywtKWnpxsVKlQwmjdvbtX3ZqHU2bNnDUlWIcK1kpKSDElGly5dcnUv8fHxhiSjb9++Vu1DhgwxJBk//fSTpa1y5cqGJGPDhg2WthUrVhiSDCcnJ+PQoUOW9k8//dSQZKxZs8bSlhV+DRo0yNKWkZFhdOrUybC3t7fcd1Yw8u6771rV9MQTTxgmk8nYu3evpU2SYW9vb9W2detWQ5IxZcoUS1ufPn0MLy8vq3+gG4Zh9OjRwzCbzZZwIyuUqlmzppGWlmbpN3nyZEOSVRDZqVMnq2AhS5cuXYxatWpla7+ZSZMmGZKML7/80tJ26dIlo3nz5oazs7ORnJxsaa9cubLRqVOnXJ23W7duhpOTk+X5HDt2rFGlShXDMAxj+vTphru7u6Vv1u/96NGjhmEYRteuXQ17e3ur8PTYsWOGi4uLVUCRFei0bNnSKoC9dOmS4e7ubtSvX9/q/cwK7nIbSknKcRs7dqylX9bz9d5771nazp49azg5ORkmk8lYuHChpX3nzp2GJGPkyJHZ7qFRo0ZWf5bHjx9vSDK+/fZbwzAMIyUlxXBzczP69etnVeeJEycMs9ls1V6/fn3Dy8vLOHfunKVt5cqVhiSrZyfrmR8/fryl7cqVK5ZQMjehVG7+HHTu3NkoWbKk5fdrGIaxZ88ew87OzuqcH3300Q3/LgIA4HYwfQ8AgNvwwAMPaOPGjXrkkUe0detWjR8/Xu3bt1eFChX03XffWfXt3r27SpQoYTVVaO3atTp69Giup+5lcXZ2liSlpKRct09ycrIk5Xo9oOXLl0uS5RsAs2QtKn3t2lOBgYFWC2A3a9ZMktS2bVtVqlQpW/v+/fuzXXPgwIGWn7OmHV26dEmrV6+21GRra6sXX3wxW02GYejHH3+0ag8JCZG/v7/ldd26deXq6mq5tmEYWrJkiTp37izDMHT69GnL1r59eyUlJWnLli1W5+zdu7fs7e0tr++///7r3s+13NzcdOTIEW3evPmmfa+2fPlyeXp66qmnnrK0lShRQi+++KLOnz+vtWvX5ul8WVq2bKl//vlHcXFxkjKn8rVo0UKSFBQUpMTERO3Zs8eyr0qVKvL29lZ6erpWrlyprl27ys/Pz3I+Ly8vPf3001q/fr3lecvSr18/2draWl7/9ttvSkxM1P/93/9ZvZ9Z09Ryq1mzZlq1alW27er3Kkvfvn0tP7u5uSkgIEClSpXSk08+aWkPCAiQm5tbjr/P/v37Wy38/vzzz8vOzs7yZ2XVqlU6d+6cnnrqKatnydbWVs2aNdOaNWskScePH1d8fLzCw8Ot7vWBBx7Ith7Y8uXLZWdnp+eff97SZmtrq0GDBuX6PbrZn4P09HStXr1aXbt2tVogvmrVqlbrjWW9b5L07bffKiMjI9c1AACQG4RSAADcpiZNmmjp0qU6e/asNm3apGHDhiklJUVPPPGEtm/fbulXtmxZtW/fXt98840uXrwoKXONKTs7O6t/JOfG+fPnJd04cHJ1dZV04+DqaocOHZKNjY2qVq1q1e7p6Sk3NzcdOnTIqv3q4EmS5R/b134jYFb7tWvx2NjYWAUcklS9enVJsqyLdOjQIXl7e2e7z5o1a1r236gmSSpdurTl2qdOndK5c+c0c+ZMlS9f3mrr3bu3JOsF6nM6Z+nSpXO8n5y8/vrrcnZ2VtOmTVWtWjUNGDDAat2m6zl06JCqVasmGxvrj2rXu+/cunpdKcMwtGHDBgUFBUmSateuLVdXV8XGxurixYuKi4uz9D916pQuXLiggICAbOesWbOmMjIylJCQYNVepUqVbPckSdWqVbNqL1GiRLbn4EbKlSunkJCQbFvlypWt+jk6Oqp8+fJWbWazWRUrVsy2ZpLZbM7x93ltrc7OzvLy8rI8n1kBXtu2bbM9TytXrrQ8S9e7d0nZ3tNDhw7Jy8vLEjxfr9+N3OzPQWJiov75559sf9YlZWvr3r27goKC1LdvX3l4eKhHjx76z3/+Q0AFAMgXfF0HAAD5xN7eXk2aNFGTJk1UvXp19e7dW19//bVGjhxp6fPMM8/o+++/1/fff69HHnlES5Ys0YMPPpjtH8838+eff0rK/g/Iq7m6usrb29vSN7eu/Qf79Vw9CiY37cY1C5MXhJtdO+sf0s8884zCw8Nz7Fu3bt08nfNGatasqV27dun7779XVFSUlixZounTp2vEiBF6++23b3p8fqtXr55cXFy0fv16dezYUWfOnLGMlLKxsVGzZs20fv16+fv769KlS1aLnOeVk5NTfpV9Swrj+cx6nubNmydPT89s+4vqm/Hy8x6dnJz0888/a82aNfrhhx8UFRWlRYsWqW3btlq5cuV1rwUAQG4wUgoAgALQuHFjSZnTdq72yCOPyMXFRQsWLNCPP/6os2fP5nnqnpT5j2BJat++/Q37Pfzww9q3b582btx403NWrlxZGRkZltEfWU6ePKlz585lG4lyuzIyMrJNmdq9e7ckWb69rnLlyjp27Fi20V47d+607M+L8uXLy8XFRenp6TmOtgkJCbH61sTculGQV6pUKXXv3l2RkZE6fPiwOnXqpDFjxlhGy+WkcuXK2rNnT7bRKLd631lsbW113333KTY2VuvXr5erq6vq1Klj2d+iRQvFxsZaRnNlhVLly5dXyZIltWvXrmzn3Llzp2xsbLKNkMvpniRle74uX76sAwcO3NL9FLRraz1//ryOHz9ueT6zpsi5u7vn+Cy1bt1a0vXvXVK297Ry5co6fvy4ZTTk9frdDnd3dzk6Olp9i2SWnNpsbGzUrl07TZw4Udu3b9eYMWP0008/WaYnAgBwqwilAAC4DWvWrMlx9EHWmjPXTrlxcnLSo48+quXLl2vGjBkqVaqUunTpkqdrLliwQJ999pmaN2+udu3a3bDva6+9plKlSqlv3746efJktv379u3T5MmTJUkdO3aUJE2aNMmqz8SJEyVJnTp1ylOduTF16lTLz4ZhaOrUqSpRooTlvjp27Kj09HSrfpL00UcfyWQyZVv/5mZsbW31+OOPa8mSJTmOIDt16tQt3EVm8JSUlJSt/e+//7Z6bW9vr8DAQBmGocuXL1/3fB07dtSJEye0aNEiS9uVK1c0ZcoUOTs7Kzg4+JbqlDKDplOnTikyMlLNmjWzmiLYokUL7dq1S99++63Kli1rmS5oa2urBx98UN9++61l6pqUGVguWLBALVu2tEwXvZ7GjRurfPny+uSTT3Tp0iVL+5w5c3Tu3Llbvp+CNHPmTKvf04wZM3TlyhXLc9e+fXu5urrqvffey/H3mfU8eXl5qX79+po7d67Vc7Jq1SqrKb5S5u/+ypUrmjFjhqUtPT1dU6ZMybf7srW1VUhIiJYtW6Zjx45Z2vfu3ZttnbYzZ85kO75+/fqSpLS0tHyrCQBwb2L6HgAAt2HQoEG6cOGCHn30UdWoUUOXLl3Shg0btGjRIvn6+lrWKbraM888oy+++EIrVqxQaGioSpUqdd3zL168WM7Ozrp06ZKOHj2qFStWKDY2VvXq1dPXX3990/r8/f21YMECde/eXTVr1lTPnj1Vu3ZtS51ff/21evXqJSlzald4eLhmzpypc+fOKTg4WJs2bdLcuXPVtWtXtWnT5pbfp5w4OjoqKipK4eHhatasmX788Uf98MMPeuONNyzTGTt37qw2bdrozTff1MGDB1WvXj2tXLlS3377rQYPHmy1mHNujRs3TmvWrFGzZs3Ur18/BQYG6syZM9qyZYtWr16d4z/Cb6ZRo0ZatGiRIiIi1KRJEzk7O6tz58568MEH5enpqaCgIHl4eGjHjh2aOnWqOnXqdMP1wPr3769PP/1UvXr1UlxcnHx9fbV48WLFxsZq0qRJuV68PidZo582btyoUaNGWe277777ZDKZ9Msvv6hz585WI8DeffddrVq1Si1bttQLL7wgOzs7ffrpp0pLS9P48eNvet0SJUro3Xff1XPPPae2bduqe/fuOnDggCIjI/O0ptTRo0f15ZdfZmt3dnZW165dc32e3Lh06ZLatWunJ598Urt27dL06dPVsmVLPfLII5Iyp8jOmDFDYWFhatiwoXr06KHy5cvr8OHD+uGHHxQUFGQJVMeOHatOnTqpZcuWevbZZ3XmzBlNmTJFtWrVshoV1blzZwUFBWno0KE6ePCgAgMDtXTp0hxDz9sxatQorVy5UkFBQXr++ect4W/t2rUVHx9v6Td69Gj9/PPP6tSpkypXrqzExERNnz5dFStWvK3pnQAASLrmO2QBAECe/Pjjj8azzz5r1KhRw3B2djbs7e2NqlWrGoMGDTJOnjyZ4zFXrlwxvLy8DEnG8uXLc+yT9VXvWZujo6NRsWJF4+GHHzZmz55tXLx4MU917t692+jXr5/h6+tr2NvbGy4uLkZQUJAxZcoUq3NdvnzZePvtt40qVaoYJUqUMHx8fIxhw4Zlu17lypWNTp06ZbuOJGPAgAFWbQcOHDAkGR988IGlLTw83ChVqpSxb98+48EHHzRKlixpeHh4GCNHjjTS09Otjk9JSTFefvllw9vb2yhRooRRrVo144MPPjAyMjJueu2sWsPDw63aTp48aQwYMMDw8fExSpQoYXh6ehrt2rUzZs6caemzZs0aQ5Lx9ddf53g/kZGRlrbz588bTz/9tOHm5mZIMipXrmwYhmF8+umnRqtWrYyyZcsaDg4Ohr+/v/Hqq68aSUlJ2eq81smTJ43evXsb5cqVM+zt7Y06depYXfPq+8vpd3E9qamphp2dnSHJWLlyZbb9devWNSQZ77//frZ9W7ZsMdq3b284OzsbJUuWNNq0aWNs2LDBqk9kZKQhydi8eXOO158+fbpRpUoVw8HBwWjcuLHx888/G8HBwUZwcPBNa69cubLVn4urt6z33DD+fb6uFRwcbNSqVSvH8179Hmbdw9q1a43+/fsbpUuXNpydnY3Q0FDj77//znb8mjVrjPbt2xtms9lwdHQ0/P39jV69ehm//fabVb8lS5YYNWvWNBwcHIzAwEBj6dKlRnh4uFXthmEYf//9txEWFma4uroaZrPZCAsLM37//fdsz13W3xNXy8ufg+joaKNBgwaGvb294e/vb3z22WfGK6+8Yjg6Olr16dKli+Ht7W3Y29sb3t7exlNPPWXs3r072zUAAMgrk2EUwqqjAAAAV+nVq5cWL16cbd0cAEWra9eu+uuvv3Jc/woAgPzGmlIAAADAPeiff/6xer1nzx4tX77cskA7AAAFjTWlAAAAgHuQn5+fevXqJT8/Px06dEgzZsyQvb29XnvttaIuDQBwjyCUAgAAAO5BHTp00FdffaUTJ07IwcFBzZs313vvvadq1aoVdWkAgHsEa0oBAAAAAACg0LGmFAAAAAAAAAodoRQAAAAAAAAKHWtK3URGRoaOHTsmFxcXmUymoi4HAAAAAADgjmYYhlJSUuTt7S0bm+uPhyKUuoljx47Jx8enqMsAAAAAAAAoVhISElSxYsXr7ieUugkXFxdJmW+kq6trEVcDAAAAAABwZ0tOTpaPj48lU7keQqmbyJqy5+rqSigFAAAAAACQSzdbBomFzlFk5syZIzc3t6IuAwAAAAAAFAFCKRSZ7t27a/fu3UVdBgAAAAAAKAJM30ORcXJykpOTU1GXAQAAAAAAigAjpe4xrVu31qBBgzR48GCVLl1aHh4emjVrllJTU9W7d2+5uLioatWq+vHHHyVJ6enp6tOnj6pUqSInJycFBARo8uTJVueMiYlR06ZNVapUKbm5uSkoKEiHDh2SJG3dulVt2rSRi4uLXF1d1ahRI/3222+SrKfv7d69WyaTSTt37rQ690cffSR/f3/L6z///FMPPfSQnJ2d5eHhobCwMJ0+fbqg3i4AAAAAAFBACKXuQXPnzlW5cuW0adMmDRo0SM8//7y6deumFi1aaMuWLXrwwQcVFhamCxcuKCMjQxUrVtTXX3+t7du3a8SIEXrjjTf0n//8R5J05coVde3aVcHBwfrjjz+0ceNG9e/f37KYWWhoqCpWrKjNmzcrLi5OQ4cOVYkSJbLVVL16dTVu3Fjz58+3ap8/f76efvppSdK5c+fUtm1bNWjQQL/99puioqJ08uRJPfnkkwX8jgEAAAAAgPxmMgzDKOoi7mTJyckym81KSkq6K759r3Xr1kpPT9e6deskZY6EMpvNeuyxx/TFF19Ikk6cOCEvLy9t3LhR9913X7ZzDBw4UCdOnNDixYt15swZlS1bVjExMQoODs7W19XVVVOmTFF4eHi2fXPmzNHgwYN17tw5SdKkSZM0depU7d27V1Lm6KmAgADt2LFDNWrU0Lvvvqt169ZpxYoVlnMcOXJEPj4+2rVrl6pXr37b7w8AAAAAALg9uc1SGCl1N0tKko4cydZct27dzPakJNna2qps2bKqU6eOZb+Hh4ckKTExUZI0bdo0NWrUSOXLl5ezs7Nmzpypw4cPS5LKlCmjXr16qX379urcubMmT56s48ePW84VERGhvn37KiQkROPGjdO+ffuuW26PHj108OBB/fLLL5IyR0k1bNhQNWrUkJQ5FXDNmjVydna2bFn7bnReAAAAAABw5yGUulslJUkdOkjBwVJCgtWuEhcvZrZ36CAlJclkMllNqcuaepeRkaGFCxdqyJAh6tOnj1auXKn4+Hj17t1bly5dsvSPjIzUxo0b1aJFCy1atEjVq1e3BEujRo3SX3/9pU6dOumnn35SYGCgvvnmmxxL9vT0VNu2bbVgwQJJ0oIFCxQaGmrZf/78eXXu3Fnx8fFW2549e9SqVav8ed8AAAAAAECh4Nv37lYpKVJiorR/v9S6tRQTI/n4SGlp0uLFUnLyv/1uIDY2Vi1atNALL7xgactpVFKDBg3UoEEDDRs2TM2bN9eCBQssU/+qV6+u6tWr6+WXX9ZTTz2lyMhIPfroozleLzQ0VK+99pqeeuop7d+/Xz169LDsa9iwoZYsWSJfX1/Z2fHoAgAAAABQnDFS6m5VsWJmEOXn928wtWGDFB+fGUj5+WXur1jxhqepVq2afvvtN61YsUK7d+/W8OHDtXnzZsv+AwcOaNiwYdq4caMOHTqklStXas+ePapZs6b++ecfDRw4UDExMTp06JBiY2O1efNm1axZ87rXe+yxx5SSkqLnn39ebdq0kbe3t2XfgAEDdObMGT311FPavHmz9u3bpxUrVqh3795KT0+/vfcLAAAAAAAUKkKpu5mPj3UwFRQkXbwoubr+O3LqJp577jk99thj6t69u5o1a6a///7batRUyZIltXPnTj3++OOqXr26+vfvrwEDBui5556Tra2t/v77b/Xs2VPVq1fXk08+qYceekhvv/32da/n4uKizp07a+vWrVZT9yTJ29tbsbGxSk9P14MPPqg6depo8ODBcnNzk40NjzIAAAAAAMUJ3753E3fFt+9t2JAZSGWJjZVatCi6egAAAAAAwF2Lb99DpoQEKSzMui0sLNvi5wAAAAAAAIWJUOpulpCQuZbU/v2ZU/hiY63XmCKYAgAAAAAARYRQ6m515Ih1IBUTkzll79rFz48cKdo6AQAAAADAPcmuqAtAAXFxkdzdM3++elHzrMXPW7fO3O/iUkQFAgAAAACAexmh1N3KbJaioqSUFKliRet9Pj7S2rWZgZTZXDT1AQAAAACAe1qxm743bdo0+fr6ytHRUc2aNdOmTZuu23fOnDkymUxWm6OjYyFWW8TM5uyBVJaKFQmkAAAAAABAkSlWodSiRYsUERGhkSNHasuWLapXr57at2+vxMTE6x7j6uqq48ePW7ZDhw4VYsUAAAAAAADISbEKpSZOnKh+/fqpd+/eCgwM1CeffKKSJUtq9uzZ1z3GZDLJ09PTsnl4eBRixQAAAAAAAMhJsQmlLl26pLi4OIWEhFjabGxsFBISoo0bN173uPPnz6ty5cry8fFRly5d9NdffxVGuQAAAAAAALiBYhNKnT59Wunp6dlGOnl4eOjEiRM5HhMQEKDZs2fr22+/1ZdffqmMjAy1aNFCR44cue510tLSlJycbLUBAAAAAAAgfxWbUOpWNG/eXD179lT9+vUVHByspUuXqnz58vr000+ve8zYsWNlNpstm4+PTyFWDAAAAAAAcG8oNqFUuXLlZGtrq5MnT1q1nzx5Up6enrk6R4kSJdSgQQPt3bv3un2GDRumpKQky5aQkHBbdQMAAAAAACC7YhNK2dvbq1GjRoqOjra0ZWRkKDo6Ws2bN8/VOdLT07Vt2zZ5eXldt4+Dg4NcXV2tNgAAAAAAAOQvu6IuIC8iIiIUHh6uxo0bq2nTppo0aZJSU1PVu3dvSVLPnj1VoUIFjR07VpI0evRo3XfffapatarOnTunDz74QIcOHVLfvn2L8jYAAAAAAADuecUqlOrevbtOnTqlESNG6MSJE6pfv76ioqIsi58fPnxYNjb/Dv46e/as+vXrpxMnTqh06dJq1KiRNmzYoMDAwKK6BQAAAAAAAEgyGYZhFHURd7Lk5GSZzWYlJSUxlQ8AAAAAAOAmcpulFJs1pQAAAAAAAHD3IJQCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChK3ah1LRp0+Tr6ytHR0c1a9ZMmzZtytVxCxculMlkUteuXQu2QAAAAAAAANxUsQqlFi1apIiICI0cOVJbtmxRvXr11L59eyUmJt7wuIMHD2rIkCG6//77C6lSAAAAAAAA3EixCqUmTpyofv36qXfv3goMDNQnn3yikiVLavbs2dc9Jj09XaGhoXr77bfl5+dXiNUCAAAAAADgeopNKHXp0iXFxcUpJCTE0mZjY6OQkBBt3LjxuseNHj1a7u7u6tOnT66uk5aWpuTkZKsNAAAAAAAA+avYhFKnT59Wenq6PDw8rNo9PDx04sSJHI9Zv369Pv/8c82aNSvX1xk7dqzMZrNl8/Hxua26AQAAAAAAkF2xCaXyKiUlRWFhYZo1a5bKlSuX6+OGDRumpKQky5aQkFCAVQIAAAAAANyb7Iq6gNwqV66cbG1tdfLkSav2kydPytPTM1v/ffv26eDBg+rcubOlLSMjQ5JkZ2enXbt2yd/fP9txDg4OcnBwyOfqAQAAAAAAcLViM1LK3t5ejRo1UnR0tKUtIyND0dHRat68ebb+NWrU0LZt2xQfH2/ZHnnkEbVp00bx8fFMywMAAAAAAChCxWaklCRFREQoPDxcjRs3VtOmTTVp0iSlpqaqd+/ekqSePXuqQoUKGjt2rBwdHVW7dm2r493c3CQpWzsAAACKp9atW6t+/fqaNGlSUZcCAADyqFiFUt27d9epU6c0YsQInThxQvXr11dUVJRl8fPDhw/LxqbYDP4CAAAAAAC4Z5kMwzCKuog7WXJyssxms5KSkuTq6lrU5QAAAOAqtzNSyjAMpaeny86uWP1/WgAA7ni5zVIYVgQAAIC7wrx589S4cWO5uLjI09NTTz/9tBITEy37Y2JiZDKZ9OOPP6pRo0ZycHDQ+vXrlZKSotDQUJUqVUpeXl766KOP1Lp1aw0ePNhybFpamoYMGaIKFSqoVKlSatasmWJiYgr/JgEAuIsQSgEAAOCucPnyZb3zzjvaunWrli1bpoMHD6pXr17Z+g0dOlTjxo3Tjh07VLduXUVERCg2NlbfffedVq1apXXr1mnLli1WxwwcOFAbN27UwoUL9ccff6hbt27q0KGD9uzZU0h3BwDA3YexygAAALgrPPvss5af/fz89PHHH6tJkyY6f/68nJ2dLftGjx6tBx54QJKUkpKiuXPnasGCBWrXrp0kKTIyUt7e3pb+hw8fVmRkpA4fPmxpHzJkiKKiohQZGan33nuvMG4PAIC7DqEUAAAAioekJCklRapYMfu+I0cUt2+fRk2YoK1bt+rs2bPKyMiQlBkqBQYGWro2btzY8vP+/ft1+fJlNW3a1NJmNpsVEBBgeb1t2zalp6erevXqVpdMS0tT2bJl8+vuAAC45xBKAQAA4M6XlCR16CAlJkoxMZKPz7/7UlKUev/9an/kiNo/+qjmz5+v8uXL6/Dhw2rfvr0uXbpkdapSpUrl6dLnz5+Xra2t4uLiZGtra7Xv6hFYAAAgbwilAAAAcOdLSckMpPbvl1q3/jeYSkuTFi/WzuRk/S1p3JAh8vnfqKfffvvtpqf18/NTiRIltHnzZlWqVEmSlJSUpN27d6tVq1aSpAYNGig9PV2JiYm6//77C+gGAQC497DQOQAAAO58FStmBlF+fv8GUxs2SPHxUnKyKlWuLHt7e01ZvFj79+/Xd999p3feeeemp3VxcVF4eLheffVVrVmzRn/99Zf69OkjGxsbmUwmSVL16tUVGhqqnj17aunSpTpw4IA2bdqksWPH6ocffijQ2wYA4G5GKAUAAIDiwcfHOpgKCpIuXpRcXVV+3TrNmTNHX3/9tQIDAzVu3DhNmDAhV6edOHGimjdvrocfflghISEKCgpSzZo15ejoaOkTGRmpnj176pVXXlFAQIC6du1qNboKAADknckwDKOoi7iTJScny2w2KykpSa6urkVdDgAAADZsyAykssTGSi1a5NvpU1NTVaFCBX344Yfq06dPvp0XAIB7RW6zFEZKAQAAoPhISJDCwqzbwsIy22/R77//rq+++kr79u3Tli1bFBoaKknq0qXL7VQKAABuglAKAAAAxUNCQuZaUvv3Z07hi421XmPqNoKpCRMmqF69egoJCVFqaqrWrVuncuXK5VvpAAAgO6bv3QTT9wAAAO4AR45IwcH/BlJZ3753bVC1dm3mougAAKDI5DZLsSvEmgAAAIBb4+Iiubtn/pwVSEn/Ln7eunXmfheXIioQAADkFaEUAAAA7nxmsxQVJaWkZB8J5eOTOULKxSWzHwAAKBYIpQAAAFA8mM3XD52YsgcAQLHDQucAAAAAAAAodIRSAAAAAAAAKHSEUgAAAAAAACh0hFIAAAAA7nq9evVS165di7oMAMBVCKUAAAAAIJcuXbpU1CUAwF2DUAoAAADAXWPx4sWqU6eOnJycVLZsWYWEhOjVV1/V3Llz9e2338pkMslkMikmJkaStG3bNrVt29bSv3///jp//rzlfFkjrMaMGSNvb28FBARo9OjRql27drZr169fX8OHDy+sWwWAYs+uqAsAAAAAgPxw/PhxPfXUUxo/frweffRRpaSkaN26derZs6cOHz6s5ORkRUZGSpLKlCmj1NRUtW/fXs2bN9fmzZuVmJiovn37auDAgZozZ47lvNHR0XJ1ddWqVaskSWazWW+//bY2b96sJk2aSJJ+//13/fHHH1q6dGmh3zcAFFeEUgAAAADuCsePH9eVK1f02GOPqXLlypKkOnXqSJKcnJyUlpYmT09PS/+5c+fq4sWL+uKLL1SqVClJ0tSpU9W5c2e9//778vDwkCSVKlVKn332mezt7S3Htm/fXpGRkZZQKjIyUsHBwfLz8yuUewWAuwHT9wAAAAAUP0lJ0pEjVk316tVTu3btVKd2bXXr2lWzZs3S2bNnr3uKHTt2qF69epZASpKCgoKUkZGhXbt2Wdrq1KljFUhJUr9+/fTVV1/p4sWLunTpkhYsWKBnn302n24OAO4NxS6UmjZtmnx9feXo6KhmzZpp06ZN1+27dOlSNW7cWG5ubipVqpTq16+vefPmFWK1AAAAAPJdUpLUoYMUHCwlJFiabW1ttWr2bP3o6qrA337TlEmTFBAQoAMHDtzW5a4OrbJ07txZDg4O+uabb/Tf//5Xly9f1hNPPHFb1wGAe02xCqUWLVqkiIgIjRw5Ulu2bFG9evXUvn17JSYm5ti/TJkyevPNN7Vx40b98ccf6t27t3r37q0VK1YUcuUAAAAA8k1KipSYKO3fL7Vu/W8wlZAgU5s2Cjp2TG87OOj35ctlb2+vb775Rvb29kpPT7c6Tc2aNbV161alpqZa2mJjY2VjY6OAgIAblmBnZ6fw8HBFRkYqMjJSPXr0kJOTU37fKQDc1YpVKDVx4kT169dPvXv3VmBgoD755BOVLFlSs2fPzrF/69at9eijj6pmzZry9/fXSy+9pLp162r9+vWFXDkAAACAfFOxohQTI/n5/RtMbdigX++7T+/t36/fKlTQ4fnztXTTJp06dUo1a9aUr6+v/vjjD+3atUunT5/W5cuXFRoaKkdHR4WHh+vPP//UmjVrNGjQIIWFhVnWk7qRvn376qefflJUVBRT9wDgFhSbUOrSpUuKi4tTSEiIpc3GxkYhISHauHHjTY83DEPR0dHatWuXWrVqdd1+aWlpSk5OttoAAAAA3GF8fKyDqaAguR47pp+dnNTx4kVVb91ab731lj788EM99NBD6tevnwICAtS4cWOVL19esbGxKlmypFasWKEzZ86oSZMmeuKJJ9SuXTtNnTo1VyVUq1ZNLVq0UI0aNdSsWbOCvV8AuAsVm2/fO336tNLT07P9HwsPDw/t3LnzusclJSWpQoUKSktLk62traZPn64HHnjguv3Hjh2rt99+O9/qBgAAAFBAfHykefOkoCBJUk1JUatXSy1aZOtavnx5rVy5Mlt7nTp19NNPP133EnPmzLnuPsMwdOzYMb3wwgt5Lh0AUIxGSt0qFxcXxcfHa/PmzRozZowiIiIUExNz3f7Dhg1TUlKSZUu4auFEAAAAAHeQhAQpLMy6LSzMavHzgnLq1ClNnTpVJ06cUO/evQv8egBwNyo2oVS5cuVka2urkydPWrWfPHlSnp6e1z3OxsZGVatWVf369fXKK6/oiSee0NixY6/b38HBQa6urlYbAAAAgDtMQkLmWlL792dO4YuNtV5jqoCDKXd3d40ePVozZ85U6dKlC/Ra+aF169YaPHhwgV7D19dXkyZNKtBrALi7FJtQyt7eXo0aNVJ0dLSlLSMjQ9HR0WrevHmuz5ORkaG0tLSCKBEAAABAYThyxDqQionJnLJ37eLnR44UWAmGYejUqVN6+umnC+waAHC3KzZrSklSRESEwsPD1bhxYzVt2lSTJk1SamqqZbhsz549VaFCBctIqLFjx6px48by9/dXWlqali9frnnz5mnGjBlFeRsAAAAAboeLi+TunvlzTEzm2lLSv4uft26dud/FpYgKxO0YNWqUli1bpvj4+KIuBUABKzYjpSSpe/fumjBhgkaMGKH69esrPj5eUVFRlsXPDx8+rOPHj1v6p6am6oUXXlCtWrUUFBSkJUuW6Msvv1Tfvn2L6hYAAAAA3C6zWYqKktau/TeQyuLjk9keFZXZDxZXrlzRwIEDZTabVa5cOQ0fPlyGYUiSzp49q549e6p06dIqWbKkHnroIe3Zs8fq+CVLlqhWrVpycHCQr6+vPvzwwxte77PPPpObm5vVbJfcGDJkSJ6PAVA8mYysv4WQo+TkZJnNZiUlJbG+FAAAAIBiqXXr1oqLi1OfPn30/PPP67ffflP//v01adIk9evXT126dNGePXv06aefytXVVa+//rr27dun7du3q0SJEoqLi1PTpk01atQode/eXRs2bNALL7yg6dOnq1evXpIy15QaPHiwBg8erPHjx2v8+PFavny5mjZtWrQ3D6DQ5TZLKVYjpQAAAAAAt8bHx0cfffSRAgICFBoaqkGDBumjjz7Snj179N133+mzzz7T/fffr3r16mn+/Pk6evSo6tevr0GDBik0NFQ2NjaaOnWq1q5dq27dusnf3199+vRR1apV9eOPP1qu8/TTT+utt95SUlKSunTpoqFDh+rKlSuSpJkzZ8rb21sZGRlWtXXp0kXPPvuspMzpe/Xr17fa/9lnn6lmzZpydHRUjRo1NH369IJ9swAUCkIpAAAAALibJCXluMj7fffdJ9PRo5n7JTVv3lx79uzR9u3bZWdnp2bNmln6li1bVgEBAUpNTdXcuXOVnJys559/XoMGDdLzzz+vbt26qVWrVrK1tVVISIjCwsJkGIbGjx+vr776Sk8++aS2bdumGTNm6PPPP9e7774rSerWrZv+/vtvrVmzxnKtM2fOKCoqSqGhoTnezvz58zVixAiNGTNGO3bs0Hvvvafhw4dr7ty5+fmuASgChFIAAAAAcLdISpI6dJCCg6WEBOt9qamZ7R06WIKp3KhXr548PT1VtmxZDRs2TI6OjipXrpwefPBBSdLw4cP1999/69KlSypdurRsbGxUq1Yt1ahRQ127dtXbb7+tDz/8UBkZGSpdurQeeughLViwwHL+xYsXq1y5cmrTpk2O1x85cqQ+/PBDPfbYY6pSpYoee+wxvfzyy/r000/z/v4AuKMQSgEAAADA3SIlRUpMlPbvz/wWwqxgKi1Nv37zTWZ7YqKUkqJffvlF1apVU2BgoK5cuaJfo6MtI6z+/vtv7dq1S6VKlVLdunVVs3Jlxa5dK1tbW5UtW1Z16tRRbGysqlevLm9vb0lSRkaGbG1t1aFDB40dO1YTJkyQJAUFBen8+fM68r9zh4aGasmSJUpLS5OUORKqR48esrHJ/s/T1NRU7du3T3369JGzs7Nle/fdd7Vv374CfjMBFDS7oi4AAAAAAJBPKlaUYmIyA6msYGrePCk+XocvX1aE2aznPv9cW9at05QpU/Thhx+qWrVq6tKxo/p17apPS5eWy+zZGjppkipUqKCyZcuqxMWLemXzZjU5elTvvPmmrly5ot9//13Lli3T9OnTZTKZJMnyTX7u7u5avny5HnroIdnZ2WUbAdW5c2cZhqEffvhBTZo00bp16/TRRx/leDvnz5+XJM2aNctqeqEk2dra5utbB6Dw5dtIqYSEBMvCdAAAAACAIuLjkxlM+fllBlNBQdLFi+rp6qp/OndW0y5dNGDAAL300kvq37+/JCny/ffVyNZWDx87puYPPSTjn3+0fPly2Vy+LC1erIZHj+o/7u5auHixjh07pqioKI0ePdryzXtZPDw8tHHjRgUFBemHH37QW2+9pTFjxsjFxUUVK1aUJDk6Ouqxxx7T/Pnz9dVXXykgIEANGzbM8VY8PDzk7e2t/fv3q2rVqlZblSpVCvJdBFAI8m2k1JkzZzR37lzNnj07v04JAAAAALgVPj6ZI6SCgiRJMZL0449SixaakUP30rVr64vt2/8dYZWQIJ06JcXHSxcvSn5+ejwmRo/7+MjX11eDBw/W4MGDrc4xc+ZMNWnSRNWrV9egQYM0cOBAzZ8/X3379lVERITV9LzQ0FA9/PDD+uuvv/TMM8/c8FbefvttvfjiizKbzerQoYPS0tL022+/6ezZs4qIiLiNNwlAUct1KPXdd9/dcP/+/ftvuxgAAAAAQD5ISJDCwqzbwsIyR1D5+OR8TNYIq6xg6n+Bllxdb3zcVSpUqKDly5fr1VdfVb169VSmTBn16dNHb731llW/tm3bqkyZMtq1a5eefvrpG56zb9++KlmypD744AO9+uqrKlWqlOrUqZMtFANQ/JiMrIm/N2FjYyOTyaQbdTeZTEpPT8+34u4EycnJMpvNSkpKkqura1GXAwAAAAA3lpDwb7Dk55c5Yios7N/XNwuYNmz4N5CSpNhYqUWLgq4awF0kt1lKrteU8vLy0tKlS5WRkZHjtmXLlnwpHAAAAABwi44csQ6kYmIyA6Wr15hq3dryLXvZXG+EVda3+AFAPsp1KNWoUSPFxcVdd//NRlEBAAAAAAqYi4vk7p59RNTVi5+7u2f2u9a1I6xiY62DLIIpAPks12tKvfrqq0pNTb3u/qpVq2rNmjX5UhQAAAAA4BaYzVJUlJSSIv3v2+4sfHyktWszAymz2XpfTiOsrl1jqnXrzOOvPS8A3KJcryl1r2JNKQAAAAB3vaQkqUMHKTEx+5pTWSOo3N0zA69rAy0AuEZus5Rcj5QCAAAAANylbnWEFQDcBkIpAAAAAEBm4HS90IkpewAKQK4XOgcAAAAAAADyC6EUAAAAAAAACl2eQ6mff/5ZV65cydZ+5coV/fzzz/lSFAAAAAAAAO5ueQ6l2rRpozNnzmRrT0pKUps2bfKlKAAAAAAAANzd8hxKGYYhk8mUrf3vv/9WqVKl8qUoAAAAAAAA3N1y/e17jz32mCTJZDKpV69ecnBwsOxLT0/XH3/8oRYtWuR/hQAAAAAAALjr5DqUMv/vq0ENw5CLi4ucnJws++zt7XXfffepX79++V8hAAAAAAAA7jq5DqUiIyMlSb6+vhoyZAhT9QAAAAAAAHDLTIZhGEVdxJ0sOTlZZrNZSUlJcnV1LepyAAAAAAAA7mi5zVLyvND5yZMnFRYWJm9vb9nZ2cnW1tZqK2jTpk2Tr6+vHB0d1axZM23atOm6fWfNmqX7779fpUuXVunSpRUSEnLD/gAAAAAAACgcuZ6+l6VXr146fPiwhg8fLi8vrxy/ia+gLFq0SBEREfrkk0/UrFkzTZo0Se3bt9euXbvk7u6erX9MTIyeeuoptWjRQo6Ojnr//ff14IMP6q+//lKFChUKrW4AAAAAAABYy/P0PRcXF61bt07169cvoJKur1mzZmrSpImmTp0qScrIyJCPj48GDRqkoUOH3vT49PR0lS5dWlOnTlXPnj1zdU2m7wEAAAAAAORegU3f8/HxUVEsQ3Xp0iXFxcUpJCTE0mZjY6OQkBBt3LgxV+e4cOGCLl++rDJlyhRUmQAAAAAAFCuGYah///4qU6aMTCaT4uPjC+xac+bMkZubW4Gd/2q9evVS165dC+VauDV5DqUmTZqkoUOH6uDBgwVQzvWdPn1a6enp8vDwsGr38PDQiRMncnWO119/Xd7e3lbB1rXS0tKUnJxstQEAAAAAcLeKiorSnDlz9P333+v48eOqXbt2gV2re/fu2r17d76e8+DBgzmGaZMnT9acOXPy9VrIX3leU6p79+66cOGC/P39VbJkSZUoUcJq/5kzZ/KtuPw0btw4LVy4UDExMXJ0dLxuv7Fjx+rtt98uxMoAAAAAACg6+/btk5eXl1q0aFHg13JycpKTk1Ou+/v6+mrw4MEaPHhwnq9lNpvzfAwK1y2NlJo5c6Zmz56tqVOn6qOPPrLaCkq5cuVka2urkydPWrWfPHlSnp6eNzx2woQJGjdunFauXKm6devesO+wYcOUlJRk2RISEm67dgAAAAAA7kS9evXSoEGDdPjwYZlMJvn6+ioqKkotW7aUm5ubypYtq4cfflj79u2zHHPp0iUNHDhQXl5ecnR0VOXKlTV27FjL/nPnzum5556Th4eHHB0dVbt2bX3//feSsk/fGzVqlOrXr6958+bJ19dXZrNZPXr0UEpKiqXPjh07blhPlSpVJEkNGjSQyWRS69atLfd29fS91q1b68UXX9Rrr72mMmXKyNPTU6NGjbJ6P3bu3KmWLVvK0dFRgYGBWr16tUwmk5YtW3ab7zRykueRUuHh4QVRx03Z29urUaNGio6OtjxUGRkZio6O1sCBA6973Pjx4zVmzBitWLFCjRs3vul1HBwc5ODgkF9lAwAAAABwx5o8ebL8/f01c+ZMbd68Wba2tvr5558VERGhunXr6vz58xoxYoQeffRRxcfHy8bGRh9//LG+++47/ec//1GlSpWUkJBgGdCRkZGhhx56SCkpKfryyy/l7++v7du3y9bW9ro17Nu3T8uWLdP333+vs2fP6sknn9S4ceM0ZswYSZkh2I3q2bRpk5o2barVq1erVq1asre3v+615s6dq4iICP3666/auHGjevXqpaCgID3wwANKT09X165dValSJf36669KSUnRK6+8kr9vOKzkOZSSMh+YyMhI7du3T5MnT5a7u7t+/PFHVapUSbVq1crvGi0iIiIUHh6uxo0bq2nTppo0aZJSU1PVu3dvSVLPnj1VoUIFS0L7/vvva8SIEVqwYIF8fX0ta085OzvL2dm5wOoEAAAAAKA4MJvNcnFxka2trWUW0uOPP27VZ/bs2Spfvrw6d+6smJgYSZK3t7eGDx+u+vXra9KkSTp79qx69uypb775RufPn9f9998vX19f+fn5yc/PT5K0ZMkSvfnmm0pKSpKvr68GDRokKTPImjNnjv755x8NGzZMp0+f1ocffqjAwEBJUr169fTYY49lq2f79u2qXbu2ypcvL0kqW7bsTWdS1a1bVyNHjpQkVatWTVOnTlV0dLQeeOABrVq1Svv27VNMTIzlPGPGjNEDDzxwO28xbiDP0/fWrl2rOnXq6Ndff9XSpUt1/vx5SdLWrVstv9iC0r17d02YMEEjRoxQ/fr1FR8fr6ioKMvi54cPH9bx48ct/WfMmKFLly7piSeekJeXl2WbMGFCgdYJAAAAAMAdKSlJOnIk531HjkhJSdqzZ4+eeuop+fn5ydXVVb6+vpKk3377Td99950iIyN16NAhrVu3TjExMVq5cqV69eql3377Tc8884w8PT1VsmRJdezYUZcvX5YkxcXF6cknn1SzZs3k7OysUaNGafjw4YqPj5evr69cXFzUq1cvJSQk6IUXXlDZsmU1ffp0JSYm6tSpUznWc/jw4Tzf/rVL+nh5eSkxMVGStGvXLvn4+FgFW02bNs3zNZB7eR4pNXToUL377ruKiIiQi4uLpb1t27aaOnVqvhaXk4EDB153ul5WYpulsL8hEAAAAACAO1ZSktShg5SYKMXESD4+/+5LT5eCgyV3d3X++29VrlJFs2bNkre3t1JSUtSsWTOFh4erXbt2kqTmzZurWrVqunLlih5//HGdP39esbGxiouL0/LlyzV//nz5+Pho2bJl6tatmyZOnKh27drpkUce0U8//aRevXpp+/btmjNnjry9vbV79279+OOP2rRpk2JjY1WiRAl9/vnnqlmzpmbNmqUGDRpY6snIyFDt2rV16dKlPL8F135Zm8lkUkZGxu28q7gNeR4ptW3bNj366KPZ2t3d3XX69Ol8KQoAAAAAAOSzlJTMQGr/fql1aynri73OnpVOnJD279ffx49r1549eqt/f7Vr1041a9bU9u3bJWVOd8saTeXj46PAwECFhIRY1l2qVq2a6tatqyNHjujvv/9WQECAduzYISlzsfKgoCCrcoKCgvT333/LMAzt2LFDdnZ2atSokWV/jRo1ZDabderUKb311luWes6ePWt1nqw1pNLT02/r7QkICFBCQoLVF6xt3rz5ts6JG8vzSCk3NzcdP37csrp9lt9//10VKlTIt8IAAAAAAEA+qlgxc4RU69b/BlPz5knTpklXrkh+fiq9bJnKNmyomb16ycvdXYcvX/53CZwzZ6TgYE1MT5fX8OG6ePGizp49q7/++ktSZl4QHBysVq1a6fHHH9c///yjs2fP6scff1RycvItlWwymVSyZEnNnDlTXl5eOnz4sIYOHWrVx93dXU5OToqKilLFihXl6Ogos9mc52s98MAD8vf3V3h4uMaPH6+UlBS99dZbljqQ//I8UqpHjx56/fXXdeLECcswt9jYWA0ZMkQ9e/YsiBoBAAAAAEB+8PHJDKb8/DKDqaAg6e+/JTs7KSZGNqVLa2G5coo7f161g4P18sCB+uCDDyRJe8eOlfbvl0tqqsZOmKAdO3Zo4cKFSk1NlfTvqKIlS5aoTp062rdvn6ZNm6bXXntNFStWVGxsrFUpsbGxKlu2rEwmk2rUqKErV64oLi7Osn/Xrl06d+6cwsPDFRcXp9q1a+vll1+21JPFzs5OH3/8sT799FN5e3urS5cut/TW2NraatmyZTp//ryaNGmivn376s0335QkOTo63tI5cWMmwzCMvBxw6dIlDRgwQHPmzFF6errs7OyUnp6up59+WnPmzLnh1zwWR8nJyTKbzUpKSpKrq2tRlwMAAAAAwO3bsCEzkMoSGyu1aJH5c0LCv6Op/PykefPUr0MHRaek6HMvL7l/8YVGfvKJVq5cqT59+uijjz5S165dtWfPHn366adycXHR0KFDtXfvXm3fvl0lSpTQli1b1KRJE40aNUrdu3fXxo0b9fzzz2v69Onq1auXJOmhhx7SyZMnNWPGDNnZ2Wnw4MGKi4vTe++9p8GDBxf2O/S/tyVWLVu21N69e+Xv718kNRRHuc1S8jxSyt7eXrNmzdK+ffv0/fff68svv9TOnTs1b968uy6QAgAAAADgrpOQIIWFWbeFhf27xlQOo6kmpqSoubOzHj53TiFhYQoKClLNmjUtI4giIyPVqFEjPfzww2revLkMw9Dy5cstC4s3bNhQ//nPf7Rw4ULVrl1bI0aM0OjRoy2BVNY5vL29FRwcrMcee0z9+/eXu7t7Ibwh//rmm2+0atUqHTx4UKtXr1b//v0VFBREIFVA8jxS6l7DSCkAAAAAwF0jh1FQCgv79/XV38p3g9FUqampqlChgj788EP16dOn0G+joHzxxRd69913dfjwYZUrV04hISH68MMPVbZs2aIurVjJbZaS51AqPT1dc+bMUXR0tBITE7N9deJPP/10axXfoQilAAAAAAB3hSNHpODg7AHUtUHV2rWSYfzbJul3STvd3dV08WIllSql0aNHKyYmRnv37lW5cuWK8KZwJ8ptlpLnb9976aWXNGfOHHXq1Em1a9dmBXoAAAAAAIoDFxcpazrc1SOisqbrtW6duT8pSXrkEevRVE8+qQlHj2pXcLDsXV3VqEkTrVu3jkAKtyXPI6XKlSunL774Qh07diyomu4ojJQCAAAAANw1kpKklBSpYsXs+44ckZKTpc6dczeaKqdzFIHWrVurfv36mjRpUlGXki9GjRqlZcuWKT4+vqhLuWUFutB51apVb6s4AAAAAABQBMzm64dJFStKFSpkjpa6dn2pqxc/d3fPHHV1h1i6dKneeeedXPU9ePCgTCbTHRP4mEwmLVu2zKptyJAhio6OLpqCClmeQ6lXXnlFkydPFuujAwAAAABwlzGbpaiozJFQWYFUFh+fzPaoqMx+d4gyZcrIpQhCssuXLxfIeZ2dne+ZhdXzHEqtX79e8+fPl7+/vzp37qzHHnvMagMAAAAAAMXYzUZT3UGBlJQ5fW/w4MGSJF9fX7333nt69tln5eLiokqVKmnmzJmWvlWqVJEkNWjQQCaTSa1bt7bs++yzz1SzZk05OjqqRo0amj59umVf1girRYsWKTg4WI6Ojpo/f/5Nj7t06ZIGDhwoLy8vOTo6qnLlyho7dqylVkl69NFHZTKZLK9HjRql+vXrW87Rq1cvde3aVRMmTJCXl5fKli2rAQMGWIVix48fV6dOneTk5KQqVapowYIF8vX1veOnNOZ5oXM3Nzc9+uijBVELAAAAAADAbfnwww/1zjvv6I033tDixYv1/PPPKzg4WAEBAdq0aZOaNm2q1atXq1atWrK3t5ckzZ8/XyNGjNDUqVPVoEED/f777+rXr59KlSql8PBwy7mHDh2qDz/8UA0aNLAEUzc67uOPP9Z3332n//znP6pUqZISEhKUkJAgSdq8ebPc3d0VGRmpDh06yNbW9rr3tGbNGnl5eWnNmjXau3evunfvrvr166tfv36SpJ49e+r06dOKiYlRiRIlFBERocTExAJ8l/NHnkOpyMjIgqgDAAAAAADgtnXs2FEvvPCCJOn111/XRx99pDVr1iggIEDly5eXJJUtW1aenp6WY0aOHKkPP/zQMgOsSpUq2r59uz799FOrUGrw4MFWs8Rudtzhw4dVrVo1tWzZUiaTSZUrV7Ycm1WLm5ubVS05KV26tKZOnSpbW1vVqFFDnTp1UnR0tPr166edO3dq9erV2rx5sxo3biwpc/RWtWrVbvk9LCx5DqWynDp1Srt27ZIkq18sAAAAAABAgbjZtwdmZKhu3bqWJpPJJE9PzxuOGkpNTdW+ffvUp08fy8gjSbpy5YrM10xVzAp9cntcr1699MADDyggIEAdOnTQww8/rAcffDDPt12rVi2rkVReXl7atm2bJGnXrl2ys7NTw4YNLfurVq2q0qVL5/k6hS3PoVRqaqoGDRqkL774QhkZGZIkW1tb9ezZU1OmTFHJkiXzvUgAAAAAAHCPS0qSOnSQEhOtvxlQygyqgoOlkydV4soVq8NMJpMlv8jJ+fPnJUmzZs1Ss2bNrPZdO6WuVKlSeTquYcOGOnDggH788UetXr1aTz75pEJCQrR48eLc3fP/lChRIk/3VFzkeaHziIgIrV27Vv/973917tw5nTt3Tt9++63Wrl2rV155pSBqBAAAAAAA97qUlMxAav9+qXVr6X9rMyktTVq8OLM9IyPz9XVkrSGVnp5uafPw8JC3t7f279+vqlWrWm1ZC6PnJLfHubq6qnv37po1a5YWLVqkJUuW6MyZM5Iyw6ara7kVAQEBunLlin7//XdL2969e3X27NnbOm9hyPNIqSVLlmjx4sVWK9R37NhRTk5OevLJJzVjxoz8rA8AAAAAACBzyl5MTGYglRVMzZsnxcdLFy9Kfn7SpUuSm9t1T+Hu7i4nJydFRUWpYsWKcnR0lNls1ttvv60XX3xRZrNZHTp0UFpamn777TedPXtWERER1z3fzY6bOHGivLy81KBBA9nY2Ojrr7+Wp6en3P5Xo6+vr6KjoxUUFCQHB4dbmnJXo0YNhYSEqH///poxY4ZKlCihV155RU5OTjKZTHk+X2HK80ipCxcuyMPDI1u7u7u7Lly4kC9FAQAAAAAAZOPjkxlM+fllBlNBQZmBlKtrZvsNvsFOkuzs7PTxxx/r008/lbe3t7p06SJJ6tu3rz777DNFRkaqTp06Cg4O1pw5c244Uio3x7m4uGj8+PFq3LixmjRpooMHD2r58uWyscmMYz788EOtWrVKPj4+atCgwS2/LV988YU8PDzUqlUrPfroo+rXr59cXFzk6Oh4y+csDCbDMIy8HNCuXTuVLVtWX3zxheXm/vnnH4WHh+vMmTNavXp1gRRaVJKTk2U2m5WUlCRXV9eiLgcAAAAAAGzYkBlIZYmNlVq0KLp67jBHjhyRj4+PVq9erXbt2hX69XObpeR5+t7kyZPVvn17VaxYUfXq1ZMkbd26VY6OjlqxYsWtVwwAAAAAAHAzCQlSWJh1W1hY9sXP7yE//fSTzp8/rzp16uj48eN67bXX5Ovrq1atWhV1aTeU51Cqdu3a2rNnj+bPn6+dO3dKkp566imFhobKyckp3wsEAAAAAACQlBlIZa0p5eeXuaZUWNi/a0zdo8HU5cuX9cYbb2j//v1ycXFRixYtNH/+/Gzf2nenyfP0vXsN0/cAAAAAALgDHDkiBQf/G0hlBVDXBlVr12Yuio4iU2DT9yRp165dmjJlinbs2CFJqlmzpgYOHKgaNWrcWrUAAAAAAAA34uIiubtn/nz1iKisxc9bt87c7+JSRAUir/L87XtLlixR7dq1FRcXp3r16qlevXrasmWL6tSpoyVLlhREjQAAAAAA4F5nNktRUZkjoa6doufjk9keFZXZD8VCnkOp1157TcOGDdPGjRs1ceJETZw4URs2bNAbb7yh1157rSBqtDJt2jT5+vrK0dFRzZo106ZNm67b96+//tLjjz8uX19fmUwmTZo0qcDrAwAAAAAABcRsvv7UvIoVCaSKmTyHUsePH1fPnj2ztT/zzDM6fvx4vhR1PYsWLVJERIRGjhypLVu2qF69emrfvr0SExNz7H/hwgX5+flp3Lhx8vT0LNDaAAAAAAAAkHt5DqVat26tdevWZWtfv3697r///nwp6nomTpyofv36qXfv3goMDNQnn3yikiVLavbs2Tn2b9KkiT744AP16NFDDg4OBVobAAAAAAAAci/PC50/8sgjev311xUXF6f77rtPkvTLL7/o66+/1ttvv63vvvvOqm9+uXTpkuLi4jRs2DBLm42NjUJCQrRx48Z8u05aWprS0tIsr5OTk/Pt3AAAAAAAAMiU51DqhRdekCRNnz5d06dPz3GfJJlMJqWnp99mef86ffq00tPT5eHhYdXu4eGhnTt35tt1xo4dq7fffjvfzgcAAAAAAIDs8jx9LyMjI1dbfgZShWnYsGFKSkqybAkJCUVdEgAAAAAAwF0nzyOlikq5cuVka2urkydPWrWfPHkyXxcxd3BwYP0pAAAAAACAAnZLodTmzZu1Zs0aJSYmKiMjw2rfxIkT86Wwa9nb26tRo0aKjo5W165dJWWO2oqOjtbAgQML5JoAAAAAAAAoGHkOpd577z299dZbCggIkIeHh0wmk2Xf1T8XhIiICIWHh6tx48Zq2rSpJk2apNTUVPXu3VuS1LNnT1WoUEFjx46VlLk4+vbt2y0/Hz16VPHx8XJ2dlbVqlULtFYAAAAAAABcX55DqcmTJ2v27Nnq1atXAZRzY927d9epU6c0YsQInThxQvXr11dUVJRl8fPDhw/LxubfZbKOHTumBg0aWF5PmDBBEyZMUHBwsGJiYgq7fAAAAAAAAPyPyTAMIy8HeHl56eeff1a1atUKqqY7SnJyssxms5KSkuTq6lrU5QAAAAAAANzRcpul5Pnb915++WVNmzbttooDAAAAAADAvS3P0/eGDBmiTp06yd/fX4GBgSpRooTV/qVLl+ZbcQAAAAAAALg75TmUevHFF7VmzRq1adNGZcuWLfDFzQEAAAAAAHD3yXMoNXfuXC1ZskSdOnUqiHoAAAAAAABwD8jzmlJlypSRv79/QdQCAAAAAACAe0SeQ6lRo0Zp5MiRunDhQkHUAwAAAAAAgHtAnqfvffzxx9q3b588PDzk6+ubbaHzLVu25FtxAAAAAAAAuDvlOZTq2rVrAZQBAAAAAACAe4nJMAyjqIu4kyUnJ8tsNispKUmurq5FXQ4AAAAAAMAdLbdZSp5HSmWJi4vTjh07JEm1atVSgwYNbvVUAAAAAAAAuMfkOZRKTExUjx49FBMTIzc3N0nSuXPn1KZNGy1cuFDly5fP7xoBAAAAAABwl8nzt+8NGjRIKSkp+uuvv3TmzBmdOXNGf/75p5KTk/Xiiy8WRI0AAAAAAAC4y+R5TSmz2azVq1erSZMmVu2bNm3Sgw8+qHPnzuVnfUWONaUAAAAAAAByL7dZSp5HSmVkZKhEiRLZ2kuUKKGMjIy8ng4AAAAAAAD3oDyHUm3bttVLL72kY8eOWdqOHj2ql19+We3atcvX4gAAAAAAAHB3ynMoNXXqVCUnJ8vX11f+/v7y9/dXlSpVlJycrClTphREjQAAAAAAALjL5Pnb93x8fLRlyxatXr1aO3fulCTVrFlTISEh+V4cAAAAAAAA7k55Xuj8XsNC5wAAAAAAALmX7wud//TTTwoMDFRycnK2fUlJSapVq5bWrVt3a9UCAAAAAADgnpLrUGrSpEnq169fjgmX2WzWc889p4kTJ+ZrcQAAAAAAALg75TqU2rp1qzp06HDd/Q8++KDi4uLypSgAAAAAAADc3XIdSp08eVIlSpS47n47OzudOnUqX4oCAAAAAADA3S3XoVSFChX0559/Xnf/H3/8IS8vr3wpCgAAAAAAAHe3XIdSHTt21PDhw3Xx4sVs+/755x+NHDlSDz/8cL4WBwAAAAAAgLtTrkOpt956S2fOnFH16tU1fvx4ffvtt/r222/1/vvvKyAgQGfOnNGbb75ZkLVKkqZNmyZfX185OjqqWbNm2rRp0w37f/3116pRo4YcHR1Vp04dLV++vMBrBAAAAAAAwI3lOpTy8PDQhg0bVLt2bQ0bNkyPPvqoHn30Ub3xxhuqXbu21q9fLw8Pj4KsVYsWLVJERIRGjhypLVu2qF69emrfvr0SExNz7L9hwwY99dRT6tOnj37//Xd17dpVXbt2veE0RAAAAAAAABQ8k2EYRl4POnv2rPbu3SvDMFStWjWVLl26IGrLplmzZmrSpImmTp0qScrIyJCPj48GDRqkoUOHZuvfvXt3paam6vvvv7e03Xfffapfv74++eSTXF0zOTlZZrNZSUlJcnV1zZ8bAQAAAAAAuEvlNkvJ9Uipq5UuXVpNmjRR06ZNCy2QunTpkuLi4hQSEmJps7GxUUhIiDZu3JjjMRs3brTqL0nt27e/bn8AAAAAAICi1rp1aw0ePLioyyhwdkVdQG6dPn1a6enp2aYIenh4aOfOnTkec+LEiRz7nzhx4rrXSUtLU1pamuV1cnLybVQNAAAAAACAnNzSSKm72dixY2U2my2bj49PUZcEAAAAAABw1yk2oVS5cuVka2urkydPWrWfPHlSnp6eOR7j6emZp/6SNGzYMCUlJVm2hISE2y8eAAAAAAAgDzIyMvTaa6+pTJky8vT01KhRoyRJBw8elMlkUnx8vKXvuXPnZDKZFBMTY2n77rvvVK1aNTk6OqpNmzaaO3euTCaTzp07Z+mzfv163X///XJycpKPj49efPFFpaamFs4NqhiFUvb29mrUqJGio6MtbRkZGYqOjlbz5s1zPKZ58+ZW/SVp1apV1+0vSQ4ODnJ1dbXaAAAAAAAACtPcuXNVqlQp/frrrxo/frxGjx6tVatW5erYAwcO6IknnlDXrl21detWPffcc3rzzTet+uzbt08dOnTQ448/rj/++EOLFi3S+vXrNXDgwIK4nRwVmzWlJCkiIkLh4eFq3LixmjZtqkmTJik1NVW9e/eWJPXs2VMVKlTQ2LFjJUkvvfSSgoOD9eGHH6pTp05auHChfvvtN82cObMobwMAAAAAAOCG6tatq5EjR0qSqlWrpqlTpyo6OlrVqlW76bGffvqpAgIC9MEHH0iSAgIC9Oeff2rMmDGWPmPHjlVoaKhlQfVq1arp448/VnBwsGbMmCFHR8f8v6lrFKtQqnv37jp16pRGjBihEydOqH79+oqKirIsZn748GHZ2Pw7+KtFixZasGCB3nrrLb3xxhuqVq2ali1bptq1axfVLQAAAAAAAPwrKUlKSZEqVrRqrlu3rnTkiOTiIpnN8vLyUmJiYq5OuWvXLjVp0sSqrWnTplavt27dqj/++EPz58+3tBmGoYyMDB04cEA1a9a8xRvKvWIVSknSwIEDrzuU7Oq5k1m6deumbt26FXBVAAAAAAAAeZSUJHXoICUmSjEx0lVftlbi4kUpOFhyd5eiomQymZSRkWEZjGMYhqXv5cuX83zp8+fP67nnntOLL76YbV+lSpXyfi+3oNiFUgAAAAAAAHeFlJTMQGr/fql163+DqbQ0afFiKTn5337/U758eUnS8ePH1aBBA0myWvRcypyut3z5cqu2zZs3W71u2LChtm/frqpVq+brLeVFsVnoHAAAAAAA4K5SsWJmEOXn928wtWGDFB+fGUj5+WXuv2pqn5OTk+677z6NGzdOO3bs0Nq1a/XWW29Znfa5557Tzp079frrr2v37t36z3/+ozlz5kiSTCaTJOn111/Xhg0bNHDgQMXHx2vPnj369ttvC3Whc0IpAAAAAACAouLjYx1MBQVJFy9Krq7ZpvRlmT17tq5cuaJGjRpp8ODBevfdd632V6lSRYsXL9bSpUtVt25dzZgxw/Ltew4ODpIy16xau3atdu/erfvvv18NGjTQiBEj5O3tXdB3bGEyrp6EiGySk5NlNpuVlJQkV1fXoi4HAAAAAADcjTZsyAykssTGSi1a5Nvpx4wZo08++UQJCQn5ds7ryW2WwkgpAAAAAACAopSQIIWFWbeFhWW236Lp06dr8+bN2r9/v+bNm6cPPvhA4eHht1lo/iKUAgAAAAAAKCoJCZlrSe3fnzmFLzbWeo2pWwym9uzZoy5duigwMFDvvPOOXnnlFY0aNSo/K79tTN+7CabvAQAAAACAAnHkiBQc/G8glbWG1LVB1dq1Voud3+lym6XYFWJNAAAAAAAAyOLiIrm7Z/589aLmWYuft26dud/FpYgKLFiEUgAAAAAAAEXBbJaioqSUlOwjoXx8MkdIubhk9rsLEUoBAAAAAAAUFbP5+qFTMZqydytY6BwAAAAAAACFjlAKAAAAAAAAhY5QCgAAAAAAAIWOUAoAAAAAAACFjlAKAAAAAAAAhY5QCgAAAAAAAIWOUAoAAAAAAACFjlAKAAAAAAAAhY5QCgAAAAAAAIWOUAoAAAAAAACFjlAKAAAAAAAAhY5QCgAAAAAAAIWOUAoAAAAAAACFjlAKAAAAAAAAhY5QCgAAAAAAAIWu2IRSZ86cUWhoqFxdXeXm5qY+ffro/PnzNzxm5syZat26tVxdXWUymXTu3LnCKRYAAAAAAAA3VGxCqdDQUP31119atWqVvv/+e/3888/q37//DY+5cOGCOnTooDfeeKOQqgQAAAAAAEBumAzDMIq6iJvZsWOHAgMDtXnzZjVu3FiSFBUVpY4dO+rIkSPy9va+4fExMTFq06aNzp49Kzc3tzxdOzk5WWazWUlJSXJ1db3VWwAAAAAAALgn5DZLKRYjpTZu3Cg3NzdLICVJISEhsrGx0a+//pqv10pLS1NycrLVBgAAAAAAgPxVLEKpEydOyN3d3arNzs5OZcqU0YkTJ/L1WmPHjpXZbLZsPj4++Xp+AAAAAAAAFHEoNXToUJlMphtuO3fuLNSahg0bpqSkJMuWkJBQqNcHAAAAAAC4F9gV5cVfeeUV9erV64Z9/Pz85OnpqcTERKv2K1eu6MyZM/L09MzXmhwcHOTg4JCv5wQAAAAAAIC1Ig2lypcvr/Lly9+0X/PmzXXu3DnFxcWpUaNGkqSffvpJGRkZatasWUGXCQAAAAAAgHxWLNaUqlmzpjp06KB+/fpp06ZNio2N1cCBA9WjRw/LN+8dPXpUNWrU0KZNmyzHnThxQvHx8dq7d68kadu2bYqPj9eZM2eK5D4AAAAAAACQqViEUpI0f/581ahRQ+3atVPHjh3VsmVLzZw507L/8uXL2rVrly5cuGBp++STT9SgQQP169dPktSqVSs1aNBA3333XaHXDwAAAAAAgH+ZDMMwirqIO1lycrLMZrOSkpLk6upa1OUAAAAAAADc0XKbpRSbkVIAAAAAAAC4exBKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQEUoBAAAAAACg0BFKAQAAAAAAoNARSgEAAAAAAKDQFZtQ6syZMwoNDZWrq6vc3NzUp08fnT9//ob9Bw0apICAADk5OalSpUp68cUXlZSUVIhVAwAAAAAAICfFJpQKDQ3VX3/9pVWrVun777/Xzz//rP79+1+3/7Fjx3Ts2DFNmDBBf/75p+bMmaOoqCj16dOnEKsGAAAAAABATkyGYRhFXcTN7NixQ4GBgdq8ebMaN24sSYqKilLHjh115MgReXt75+o8X3/9tZ555hmlpqbKzs4uV8ckJyfLbDYrKSlJrq6ut3wPAAAAAAAA94LcZinFYqTUxo0b5ebmZgmkJCkkJEQ2Njb69ddfc32erDcjt4EUAAAAAAAACkaxSGdOnDghd3d3qzY7OzuVKVNGJ06cyNU5Tp8+rXfeeeeGU/4kKS0tTWlpaZbXycnJeS8YAAAAAAAAN1SkI6WGDh0qk8l0w23nzp23fZ3k5GR16tRJgYGBGjVq1A37jh07Vmaz2bL5+Pjc9vUBAAAAAABgrUhHSr3yyivq1avXDfv4+fnJ09NTiYmJVu1XrlzRmTNn5OnpecPjU1JS1KFDB7m4uOibb75RiRIlbth/2LBhioiIsLxOTk4mmAIAAAAAAMhnRRpKlS9fXuXLl79pv+bNm+vcuXOKi4tTo0aNJEk//fSTMjIy1KxZs+sel5ycrPbt28vBwUHfffedHB0db3otBwcHOTg45P4mAAAAAAAAkGfFYqHzmjVrqkOHDurXr582bdqk2NhYDRw4UD169LB8897Ro0dVo0YNbdq0SVJmIPXggw8qNTVVn3/+uZKTk3XixAmdOHFC6enpRXk7AAAAAAAA97xisdC5JM2fP18DBw5Uu3btZGNjo8cff1wff/yxZf/ly5e1a9cuXbhwQZK0ZcsWyzfzVa1a1epcBw4ckK+vb6HVDgAAAAAAAGsmwzCMoi7iTpacnCyz2aykpCS5uroWdTkAAAAAAAB3tNxmKcVi+h4AAAAAAADuLoRSAAAAAIB72sGDB2UymRQfH1/UpQD3FEIpAAAAAECx4+vrq0mTJuXLuXx8fHT8+HHVrl07X84HIHeKzULnAAAAAADkt0uXLsne3l6enp5FXQpwz2GkFAAAAADgtrVu3VqDBg3S4MGDVbp0aXl4eGjWrFlKTU1V79695eLioqpVq+rHH3+UYRiqWrWqJkyYYHWO+Ph4mUwm7d27V4ZhaNSoUapUqZIcHBzk7e2tF1980XKtQ4cO6eWXX5bJZJLJZLKcY/369br//vvl5OQkHx8fvfjii0pNTbXs9/X11TvvvKOePXvK1dVV/fv3z3H63tq1a9W0aVM5ODjIy8tLQ4cO1ZUrV6zOc+1Irfr162vUqFGSdMP6AWQilAIAAAAA5Iu5c+eqXLly2rRpkwYNGqTnn39e3bp1U4sWLbRlyxY9+OCDCgsL0z///KNnn31WkZGRVsdHRkaqVatWqlq1qpYsWaKPPvpIn376qfbs2aNly5apTp06kqSlS5eqYsWKGj16tI4fP67jx49Lkvbt26cOHTro8ccf1x9//KFFixZp/fr1GjhwoNV1JkyYoHr16un333/X8OHDs93H0aNH1bFjRzVp0kRbt27VjBkz9Pnnn+vdd9/N9Xtxo/oBZGL6HgAAAAAgX9SrV09vvfWWJGnYsGEaN26cypUrp379+kmSRowYoRkzZuiPP/5Qr169NGLECG3atElNmzbV5cuXtWDBAsvoqcOHD8vT01MhISEqUaKEKlWqpKZNm0qSypQpI1tbW7m4uFhNuxs7dqxCQ0M1ePBgSVK1atX08ccfKzg4WDNmzJCjo6MkqW3btnrllVcsxx08eNDqPqZPny4fHx9NnTpVJpNJNWrU0LFjx/T6669rxIgRsrG5+fiOG9UPIBMjpQAAAAAAeZOUJB05kq25bt26me1JSbK1tVXZsmWtRgd5eHhIkhITE+Xt7a1OnTpp9uzZkqT//ve/SktLU7du3SRJ3bp10z///CM/Pz/169dP33zzjdX0uZxs3bpVc+bMkbOzs2Vr3769MjIydODAAUu/xo0b3/A8O3bsUPPmza2mBQYFBen8+fM6ksN95+RW6gfuNYRSAAAAAIDcS0qSOnSQgoOlhASrXSUuXsxs79BBSkqSyWRSiRIlLPuzQp6MjAxJUt++fbVw4UL9888/ioyMVPfu3VWyZElJmd+It2vXLk2fPl1OTk564YUX1KpVK12+fPm6pZ0/f17PPfec4uPjLdvWrVu1Z88e+fv7W/qVKlXqtt8GGxsbGYZh1XZ1bbdSP3CvYfoeAAAAACD3UlKkxERp/36pdWspJkby8ZHS0qTFi6Xk5H/73UTHjh1VqlQpzZgxQ1FRUfr555+t9js5Oalz587q3LmzBgwYoBo1amjbtm1q2LCh7O3tlZ6ebtW/YcOG2r59u6pWrXpbt1izZk0tWbJEhmFYgrTY2Fi5uLioYsWKkqTy5ctb1rKSpOTkZKvRWDerHwAjpQAAAAAAeVGxYmYQ5ef3bzC1YYMUH58ZSPn5Ze7/X3hzI7a2turVq5eGDRumatWqqXnz5pZ9c+bM0eeff64///xT+/fv15dffiknJydVrlxZUua33/388886evSoTp8+LUl6/fXXtWHDBg0cOFDx8fHas2ePvv3222wLnd/MCy+8oISEBA0aNEg7d+7Ut99+q5EjRyoiIsKynlTbtm01b948rVu3Ttu2bVN4eLhsbW1zXT8AQikAAAAAQF75+FgHU0FB0sWLkqvrvyOncqlPnz66dOmSevfubdXu5uamWbNmKSgoSHXr1tXq1av13//+V2XLlpUkjR49WgcPHpS/v7/Kly8vKXNNq7Vr12r37t26//771aBBA40YMULe3t55ur0KFSpo+fLl2rRpk+rVq6f/+7//U58+fSyLuEuZC7kHBwfr4YcfVqdOndS1a1erKYI3qx+AZDKunQQLK8nJyTKbzUpKSpKrq2tRlwMAAAAAd44NGzIDqSyxsVKLFnk6xbp169SuXTslJCRYFkIHULzlNkthpBQAAAAAIO8SEqSwMOu2sLBsi59fT1pamo4cOaJRo0apW7duBFLAPYhQCgAAAACQNwkJmWtJ7d+fOYUvNtZ6jalcBFNfffWVKleurHPnzmn8+PEFXjKAOw/T926C6XsAAAAAcJUjR6Tg4H8Dqaw1pK4NqtauzdVi5wDuPrnNUuwKsSYAAAAAQHHn4iK5u2f+fPWi5lmLn7dunbnfxaWICgRQXBBKAQAAAAByz2yWoqKklJTsI6F8fDJHSLm4ZPYDgBsglAIAAAAA5I3ZfP3QiSl7AHKJhc4BAAAAAABQ6AilAAAAAAAAUOgIpQAAAAAAAFDoCKUAAAAAAABQ6AilAAAAAAAAUOgIpQAAAAAAAFDo7Iq6gDudYRiSpOTk5CKuBAAAAAAA4M6XlaFkZSrXQyh1EykpKZIkHx+fIq4EAAAAAACg+EhJSZHZbL7ufpNxs9jqHpeRkaFjx47JxcVFJpOpqMtBIUpOTpaPj48SEhLk6upa1OXgDsAzgZzwXOBaPBO4Fs8ErsUzgWvxTOBaxf2ZMAxDKSkp8vb2lo3N9VeOYqTUTdjY2KhixYpFXQaKkKura7H8SwAFh2cCOeG5wLV4JnAtnglci2cC1+KZwLWK8zNxoxFSWVjoHAAAAAAAAIWOUAoAAAAAAACFjlAKuA4HBweNHDlSDg4ORV0K7hA8E8gJzwWuxTOBa/FM4Fo8E7gWzwSuda88Eyx0DgAAAAAAgELHSCkAAAAAAAAUOkIpAAAAAAAAFDpCKQAAAAAAABQ6QincU6ZNmyZfX185OjqqWbNm2rRp0w37T5o0SQEBAXJycpKPj49efvllXbx40arP0aNH9cwzz6hs2bJycnJSnTp19NtvvxXkbSAf5fczkZ6eruHDh6tKlSpycnKSv7+/3nnnHbF8X/GRl2fi8uXLGj16tPz9/eXo6Kh69eopKirqts6JO09+PxNjx45VkyZN5OLiInd3d3Xt2lW7du0q6NtAPiqIvyeyjBs3TiaTSYMHDy6AylFQCuKZ4DNm8ZbfzwSfMYu3n3/+WZ07d5a3t7dMJpOWLVt202NiYmLUsGFDOTg4qGrVqpozZ062PnfFZ0wDuEcsXLjQsLe3N2bPnm389ddfRr9+/Qw3Nzfj5MmTOfafP3++4eDgYMyfP984cOCAsWLFCsPLy8t4+eWXLX3OnDljVK5c2ejVq5fx66+/Gvv37zdWrFhh7N27t7BuC7ehIJ6JMWPGGGXLljW+//5748CBA8bXX39tODs7G5MnTy6s28JtyOsz8dprrxne3t7GDz/8YOzbt8+YPn264ejoaGzZsuWWz4k7S0E8E+3btzciIyONP//804iPjzc6duxoVKpUyTh//nxh3RZuQ0E8E1k2bdpk+Pr6GnXr1jVeeumlAr4T5JeCeCb4jFm8FcQzwWfM4m358uXGm2++aSxdutSQZHzzzTc37L9//36jZMmSRkREhLF9+3ZjypQphq2trREVFWXpc7d8xiSUwj2jadOmxoABAyyv09PTDW9vb2Ps2LE59h8wYIDRtm1bq7aIiAgjKCjI8vr11183WrZsWTAFo8AVxDPRqVMn49lnn7Xq89hjjxmhoaH5WDkKSl6fCS8vL2Pq1KlWbdf+vvN6TtxZCuKZuFZiYqIhyVi7dm3+FI0CVVDPREpKilGtWjVj1apVRnBwMKFUMVIQzwSfMYu3gngm+Ix598hNKPXaa68ZtWrVsmrr3r270b59e8vru+UzJtP3cE+4dOmS4uLiFBISYmmzsbFRSEiINm7cmOMxLVq0UFxcnGUI5P79+7V8+XJ17NjR0ue7775T48aN1a1bN7m7u6tBgwaaNWtWwd4M8kVBPRMtWrRQdHS0du/eLUnaunWr1q9fr4ceeqgA7wb54VaeibS0NDk6Olq1OTk5af369bd8Ttw5CuKZyElSUpIkqUyZMvlQNQpSQT4TAwYMUKdOnazOjTtfQT0TfMYsvgrqmeAz5r1l48aN2f570L59e8szdDd9xrQr6gKAwnD69Gmlp6fLw8PDqt3Dw0M7d+7M8Zinn35ap0+fVsuWLWUYhq5cuaL/+7//0xtvvGHps3//fs2YMUMRERF64403tHnzZr344ouyt7dXeHh4gd4Tbk9BPRNDhw5VcnKyatSoIVtbW6Wnp2vMmDEKDQ0t0PvB7buVZ6J9+/aaOHGiWrVqJX9/f0VHR2vp0qVKT0+/5XPizlEQz8S1MjIyNHjwYAUFBal27dr5fg/IXwX1TCxcuFBbtmzR5s2bC7R+5L+Ceib4jFl8FdQzwWfMe8uJEydyfIaSk5P1zz//6OzZs3fNZ0xGSgHXERMTo/fee0/Tp0/Xli1btHTpUv3www965513LH0yMjLUsGFDvffee2rQoIH69++vfv366ZNPPinCylFQcvNM/Oc//9H8+fO1YMECbdmyRXPnztWECRM0d+7cIqwcBWXy5MmqVq2aatSoIXt7ew0cOFC9e/eWjQ3/eb1X5fWZGDBggP78808tXLiwkCtFYbnZM5GQkKCXXnpJ8+fPzzZSAnen3Pw9wWfMe0tungk+Y+Juxadm3BPKlSsnW1tbnTx50qr95MmT8vT0zPGY4cOHKywsTH379lWdOnX06KOP6r333tPYsWOVkZEhSfLy8lJgYKDVcTVr1tThw4cL5kaQbwrqmXj11Vc1dOhQ9ejRQ3Xq1FFYWJhefvlljR07tsDvCbfnVp6J8uXLa9myZUpNTdWhQ4e0c+dOOTs7y8/P75bPiTtHQTwTVxs4cKC+//57rVmzRhUrViyQe0D+KohnIi4uTomJiWrYsKHs7OxkZ2entWvX6uOPP5adnd11R9nhzlBQf0/wGbP4Kqhngs+Y9xZPT88cnyFXV1c5OTndVZ8xCaVwT7C3t1ejRo0UHR1tacvIyFB0dLSaN2+e4zEXLlzI9n+2bW1tJcny1atBQUHZvsZ79+7dqly5cn6WjwJQUM/E9fpkhVa4c93KM5HF0dFRFSpU0JUrV7RkyRJ16dLlts+JolcQz4SU+ffFwIED9c033+inn35SlSpVCuwekL8K4plo166dtm3bpvj4eMvWuHFjhYaGKj4+3vLfGdyZCurvCT5jFl8F9UzwGfPe0rx5c6tnSJJWrVpleYbuqs+YRbrMOlCIFi5caDg4OBhz5swxtm/fbvTv399wc3MzTpw4YRiGYYSFhRlDhw619B85cqTh4uJifPXVV8b+/fuNlStXGv7+/saTTz5p6bNp0ybDzs7OGDNmjLFnzx5j/vz5RsmSJY0vv/yy0O8PeVcQz0R4eLhRoUIFy9f1Ll261ChXrpzx2muvFfr9Ie/y+kz88ssvxpIlS4x9+/YZP//8s9G2bVujSpUqxtmzZ3N9TtzZCuKZeP755w2z2WzExMQYx48ft2wXLlwo7NvDLSiIZ+JafPte8VIQzwSfMYu3gngm+IxZvKWkpBi///678fvvvxuSjIkTJxq///67cejQIcMwDGPo0KFGWFiYpf/+/fuNkiVLGq+++qqxY8cOY9q0aYatra0RFRVl6XO3fMYklMI9ZcqUKUalSpUMe3t7o2nTpsYvv/xi2RccHGyEh4dbXl++fNkYNWqU4e/vbzg6Oho+Pj7GCy+8kO1D5H//+1+jdu3ahoODg1GjRg1j5syZhXQ3yA/5/UwkJycbL730klGpUiXD0dHR8PPzM958800jLS2tEO8KtyMvz0RMTIxRs2ZNw8HBwShbtqwRFhZmHD16NE/nxJ0vv58JSTlukZGRhXRHuF0F8ffE1Qilip+CeCb4jFm85fczwWfM4m3NmjU5/rc/6zkIDw83goODsx1Tv359w97e3vDz88vxc8Ld8BnTZBj/m3MCAAAAAAAAFBLWlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAAAAAEChI5QCAAAAAABAoSOUAgAAAAAAQKEjlAIAAPifEydOaNCgQfLz85ODg4N8fHzUuXNnRUdHF3Vpd5RevXqpa9euueo7bdo0+fr6ytHRUc2aNdOmTZsKtjgAAFBsEEoBAABIOnjwoBo1aqSffvpJH3zwgbZt26aoqCi1adNGAwYMKOryiqVFixYpIiJCI0eO1JYtW1SvXj21b99eiYmJRV0aAAC4AxBKAQAASHrhhRdkMpm0adMmPf7446pevbpq1aqliIgI/fLLL5Z+hw8fVpcuXeTs7CxXV1c9+eSTOnnypGX/qFGjVL9+fc2ePVuVKlWSs7OzXnjhBaWnp2v8+PHy9PSUu7u7xowZY3V9k8mkGTNm6KGHHpKTk5P8/Py0ePFiqz7btm1T27Zt5eTkpLJly6p///46f/68ZX/WCKYJEybIy8tLZcuW1YABA3T58mVLn7S0NA0ZMkQVKlRQqVKl1KxZM8XExFj2z5kzR25ublqxYoVq1qwpZ2dndejQQcePH7fc39y5c/Xtt9/KZDLJZDJZHX+1iRMnql+/furdu7cCAwP1ySefqGTJkpo9e3aefz8AAODuQygFAADueWfOnFFUVJQGDBigUqVKZdvv5uYmScrIyFCXLl105swZrV27VqtWrdL+/fvVvXt3q/779u3Tjz/+qKioKH311Vf6/PPP1alTJx05ckRr167V+++/r7feeku//vqr1XHDhw/X448/rq1btyo0NFQ9evTQjh07JEmpqalq3769Spcurc2bN+vrr7/W6tWrNXDgQKtzrFmzRvv27dOaNWs0d+5czZkzR3PmzLHsHzhwoDZu3KiFCxfqjz/+ULdu3dShQwft2bPH0ufChQuaMGGC5s2bp59//lmHDx/WkCFDJElDhgzRk08+aQmqjh8/rhYtWmR7zy5duqS4uDiFhIRY2mxsbBQSEqKNGzfm4rcCAADudnZFXQAAAEBR27t3rwzDUI0aNW7YLzo6Wtu2bdOBAwfk4+MjSfriiy9Uq1Ytbd68WU2aNJGUGV7Nnj1bLi4uCgwMVJs2bbRr1y4tX75cNjY2CggI0Pvvv681a9aoWbNmlvN369ZNffv2lSS98847WrVqlaZMmaLp06drwYIFunjxor744gtLcDZ16lR17txZ77//vjw8PCRJpUuX1tSpU2Vra6saNWqoU6dOio6OVr9+/XT48GFFRkbq8OHD8vb2lpQZMkVFRSkyMlLvvfeeJOny5cv65JNP5O/vLykzyBo9erQkydnZWU5OTkpLS5Onp+d136vTp08rPT3dUlcWDw8P7dy5Mxe/FQAAcLcjlAIAAPc8wzBy1W/Hjh3y8fGxBFKSFBgYKDc3N+3YscMSSvn6+srFxcXSx8PDQ7a2trKxsbFqu3ZtpebNm2d7HR8fb7l2vXr1rEZyBQUFKSMjQ7t27bKEP7Vq1ZKtra2lj5eXl7Zt2yYpc/pfenq6qlevbnWdtLQ0lS1b1vK6ZMmSlkAq6xysAwUAAPIboRQAALjnVatWTSaTKd9G8JQoUcLqtclkyrEtIyMjX653s2tnXef8+fOytbVVXFycVXAlZY6AutE5chvcZSlXrpxsbW2t1tuSpJMnT95whBUAALh3sKYUAAC455UpU0bt27fXtGnTlJqamm3/uXPnJEk1a9ZUQkKCEhISLPu2b9+uc+fOKTAw8LbruHpB9azXNWvWtFx769atVvXFxsZapgPmRoMGDZSenq7ExERVrVrVastLUGRvb6/09PSb9mnUqJGio6MtbRkZGYqOjs42IgwAANybCKUAAAAkTZs2Tenp6WratKmWLFmiPXv2aMeOHfr4448tIUpISIjq1Kmj0NBQbdmyRZs2bVLPnj0VHBysxo0b33YNX3/9tWbPnq3du3dr5MiR2rRpk2Uh89DQUDk6Oio8PFx//vmn1qxZo0GDBiksLCzbuk3XU716dYWGhqpnz55aunSpDhw4oE2bNmns2LH64Ycfcl2nr6+v/vjjD+3atUunT5+2+na/q0VERGjWrFmaO3euduzYoeeff16pqanq3bt3rq8FAADuXoRSAAAAkvz8/LRlyxa1adNGr7zyimrXrq0HHnhA0dHRmjFjhqTMaWzffvutSpcurVatWikkJER+fn5atGhRvtTw9ttva+HChapbt66++OILffXVV5YRWCVLltSKFSt05swZNWnSRE888YTatWunqVOn5ukakZGR6tmzp1555RUFBASoa9eu2rx5sypVqpTrc/Tr108BAQFq3Lixypcvr9jY2Bz7de/eXRMmTNCIESNUv359xcfHKyoqKtchGgAAuLuZjLwuEAAAAIB8ZzKZ9M0336hr165FXQoAAEChYKQUAAAAAAAACh2hFAAAAAAAAAqdXVEXAAAAAIkVFQAAwL2GkVIAAAAAAAAodIRSAAAAAAAAKHSEUgAAAAAAACh0hFIAAAAAAAAodIRSAAAAAAAAKHSEUgAAAAAAACh0hFIAAAAAAAAodIRSAAAAAAAAKHSEUgAAAAAAACh0/w/ykaFruMnX3QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# -----------------------------\n",
    "# Run This Cell to Produce Your Plot\n",
    "# ------------------------------\n",
    "imdb_corpus = read_corpus()\n",
    "M_co_occurrence, word2ind_co_occurrence = compute_co_occurrence_matrix(imdb_corpus)\n",
    "M_reduced_co_occurrence = reduce_to_k_dim(M_co_occurrence, k=2)\n",
    "\n",
    "# Rescale (normalize) the rows to make them each of unit-length\n",
    "M_lengths = np.linalg.norm(M_reduced_co_occurrence, axis=1)\n",
    "M_normalized = M_reduced_co_occurrence / M_lengths[:, np.newaxis] # broadcasting\n",
    "\n",
    "words = ['movie', 'book', 'mysterious', 'story', 'fascinating', 'good', 'interesting', 'large', 'massive', 'huge']\n",
    "\n",
    "plot_embeddings(M_normalized, word2ind_co_occurrence, words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RtOd40JTSSuE"
   },
   "source": [
    "**Verify that your figure matches \"question_1.5.png\" in the assignment zip. If not, use the figure in \"question_1.5.png\" to answer the next two questions.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ciXWGMvRSSuE"
   },
   "source": [
    "a. Find at least two groups of words that cluster together in 2-dimensional embedding space. Give an explanation for each cluster you observe."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fLU7o3HESSuF"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <ol>\n",
    "        <li><code>[\"book\", \"movie\"]</code>: Both books and movies follow a structured narrative, including the beginning, middle, and end. Also, they (e.g., fiction) develop characters over time and involve dialogue to reveal characters' traits.</li>\n",
    "        <li><code>[\"fascinating\", \"good\", \"interesting\"]</code>: These three adjectives all describe positive reactions to something, offering affirmative evaluation.</li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3H-tyA9RSSuF"
   },
   "source": [
    "b. What doesn't cluster together that you might think should have? Describe at least two examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3NG2j9J4SSuG"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    <ol>\n",
    "        <li><code>[\"massive\", \"large\", \"huge\"]</code>: These three adjectives are all used to describe size or scale, but they're far from one another.</li>\n",
    "        <li><code>[\"book\", \"movie\", \"story\"]</code>: Both books and movies revolve around telling a story, but the word embedding of <code>\"story\"</code> seems a little bit distant from the others.</li>\n",
    "        <li><code>[\"mysterious\", \"interesting\"]</code>: Both terms are commonly used to describe things that trigger curiosity.</li>\n",
    "    </ol>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_h0OzAaRSSuI"
   },
   "source": [
    "## Part 2: Prediction-Based Word Vectors (15 points)\n",
    "\n",
    "As discussed in class, more recently prediction-based word vectors have demonstrated better performance, such as word2vec and GloVe (which also utilizes the benefit of counts). Here, we shall explore the embeddings produced by GloVe. Please revisit the class notes and lecture slides for more details on the word2vec and GloVe algorithms. If you're feeling adventurous, challenge yourself and try reading [GloVe's original paper](https://nlp.stanford.edu/pubs/glove.pdf).\n",
    "\n",
    "Then run the following cells to load the GloVe vectors into memory. **Note**: If this is your first time to run these cells, i.e. download the embedding model, it will take a couple minutes to run. If you've run these cells before, rerunning them will load the model without redownloading it, which will take about 1 to 2 minutes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "l3kwvdksSSuI",
    "outputId": "736a4672-4b59-4c2e-d6e6-b16e4548db30",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded vocab size 400000\n"
     ]
    }
   ],
   "source": [
    "def load_embedding_model():\n",
    "    \"\"\" Load GloVe Vectors\n",
    "        Return:\n",
    "            wv_from_bin: All 400000 embeddings, each length 200\n",
    "    \"\"\"\n",
    "    import gensim.downloader as api\n",
    "    wv_from_bin = api.load(\"glove-wiki-gigaword-200\")\n",
    "    print(\"Loaded vocab size %i\" % len(list(wv_from_bin.index_to_key)))\n",
    "    return wv_from_bin\n",
    "wv_from_bin = load_embedding_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "egIeG1RTSSuK"
   },
   "source": [
    "#### Note: If you are receiving a \"reset by peer\" error, rerun the cell to restart the download. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rH9gWJWpSSuL"
   },
   "source": [
    "### Reducing dimensionality of Word Embeddings\n",
    "Let's directly compare the GloVe embeddings to those of the co-occurrence matrix. In order to avoid running out of memory, we will work with a sample of 40000 GloVe vectors instead.\n",
    "Run the following cells to:\n",
    "\n",
    "1. Put 40000 Glove vectors into a matrix M\n",
    "2. Run `reduce_to_k_dim` (your Truncated SVD function) to reduce the vectors from 200-dimensional to 2-dimensional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "0PROUu_-SSuL"
   },
   "outputs": [],
   "source": [
    "def get_matrix_of_vectors(wv_from_bin, required_words):\n",
    "    \"\"\" Put the GloVe vectors into a matrix M.\n",
    "        Param:\n",
    "            wv_from_bin: KeyedVectors object; the 400000 GloVe vectors loaded from file\n",
    "        Return:\n",
    "            M: numpy matrix shape (num words, 200) containing the vectors\n",
    "            word2ind: dictionary mapping each word to its row number in M\n",
    "    \"\"\"\n",
    "    import random\n",
    "    words = list(wv_from_bin.index_to_key)\n",
    "    print(\"Shuffling words ...\")\n",
    "    random.seed(225)\n",
    "    random.shuffle(words)\n",
    "    print(\"Putting %i words into word2ind and matrix M...\" % len(words))\n",
    "    word2ind = {}\n",
    "    M = []\n",
    "    curInd = 0\n",
    "    for w in words:\n",
    "        try:\n",
    "            M.append(wv_from_bin.get_vector(w))\n",
    "            word2ind[w] = curInd\n",
    "            curInd += 1\n",
    "        except KeyError:\n",
    "            continue\n",
    "    for w in required_words:\n",
    "        if w in words:\n",
    "            continue\n",
    "        try:\n",
    "            M.append(wv_from_bin.get_vector(w))\n",
    "            word2ind[w] = curInd\n",
    "            curInd += 1\n",
    "        except KeyError:\n",
    "            continue\n",
    "    M = np.stack(M)\n",
    "    print(\"Done.\")\n",
    "    return M, word2ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cpgM0M-hSSuM",
    "outputId": "b0989be9-8e11-45d8-8ba9-47297a990760"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shuffling words ...\n",
      "Putting 400000 words into word2ind and matrix M...\n",
      "Done.\n",
      "Running Truncated SVD over 400000 words...\n",
      "Done.\n"
     ]
    }
   ],
   "source": [
    "# -----------------------------------------------------------------\n",
    "# Run Cell to Reduce 200-Dimensional Word Embeddings to k Dimensions\n",
    "# Note: This should be quick to run\n",
    "# -----------------------------------------------------------------\n",
    "M, word2ind = get_matrix_of_vectors(wv_from_bin, words)\n",
    "M_reduced = reduce_to_k_dim(M, k=2)\n",
    "\n",
    "# Rescale (normalize) the rows to make them each of unit-length\n",
    "M_lengths = np.linalg.norm(M_reduced, axis=1)\n",
    "M_reduced_normalized = M_reduced / M_lengths[:, np.newaxis] # broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8_46FYMJSSuN"
   },
   "source": [
    "**Note: If you are receiving out of memory issues on your local machine, try closing other applications to free more memory on your device. You may want to try restarting your machine so that you can free up extra memory. Then immediately run the jupyter notebook and see if you can load the word vectors properly. If you still have problems with loading the embeddings onto your local machine after this, please go to office hours or contact course staff.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zAFrU8ahSSuO"
   },
   "source": [
    "### Question 2.1: GloVe Plot Analysis [written] (3 points)\n",
    "\n",
    "Run the cell below to plot the 2D GloVe embeddings for `['movie', 'book', 'mysterious', 'story', 'fascinating', 'good', 'interesting', 'large', 'massive', 'huge']`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 321
    },
    "id": "9kHRkjz6SSuO",
    "outputId": "fbe0f8af-ea5e-456d-8d75-b9ad0caaa5fc",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "words = ['movie', 'book', 'mysterious', 'story', 'fascinating', 'good', 'interesting', 'large', 'massive', 'huge']\n",
    "\n",
    "plot_embeddings(M_reduced_normalized, word2ind, words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Verify that your figure matches \"question_2.1.png\" in the assignment zip. If not, use the figure in \"question_2.1.png\" (and the figure in \"question_1.5.png\", if applicable) to answer the next two questions.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eOnrMZkzSSuP"
   },
   "source": [
    "a. What is one way the plot is different from the one generated earlier from the co-occurrence matrix? What is one way it's similar?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5KC4PTQoSSuQ"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    Compared to word embeddings from the co-occurrence matrix, <code>[\"book\", \"story\", \"movie\"]</code> remain close to one another. Also, <code>[\"massive\", \"large\", \"huge\"]</code> are still separate but now appear closer.<br>\n",
    "    On the other hand, the most noticeable difference is that <code>[\"good\", \"interesting\", \"fascinating\"]</code> are now farther apart. Additionally, <code>[\"mysterious\", \"interesting\"]</code> are clustered together.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bNDY5puZSSuQ"
   },
   "source": [
    "b. Why might the GloVe plot (question_2.1.png) differ from the plot generated earlier from the co-occurrence matrix (question_1.5.png)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "o-cWAvi8SSuR"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    Word embeddings derived from the co-occurrence matrix are based purely on word co-occurrence counts, often leading to high-dimensional, sparse vectors that require additional dimensionality reduction techniques (e.g., SVD). In contrast, GloVe learns a low-dimensional embedding space based on <strong>co-occurrence ratios</strong>, which effectively captures both local and global semantic relationships between words, resulting in more compact and semantically rich vectors.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nA8oIbjjSSuS"
   },
   "source": [
    "### Cosine Similarity\n",
    "Now that we have word vectors, we need a way to quantify the similarity between individual words, according to these vectors. One such metric is cosine-similarity. We will be using this to find words that are \"close\" and \"far\" from one another.\n",
    "\n",
    "We can think of n-dimensional vectors as points in n-dimensional space. If we take this perspective [L1](http://mathworld.wolfram.com/L1-Norm.html) and [L2](http://mathworld.wolfram.com/L2-Norm.html) Distances help quantify the amount of space \"we must travel\" to get between these two points. Another approach is to examine the angle between two vectors. From trigonometry we know that:\n",
    "\n",
    "<img src=\"./imgs/inner_product.png\" width=20% style=\"float: center;\"></img>\n",
    "\n",
    "Instead of computing the actual angle, we can leave the similarity in terms of $similarity = cos(\\Theta)$. Formally the [Cosine Similarity](https://en.wikipedia.org/wiki/Cosine_similarity) $s$ between two vectors $p$ and $q$ is defined as:\n",
    "\n",
    "$$s = \\frac{p \\cdot q}{||p|| ||q||}, \\textrm{ where } s \\in [-1, 1] $$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sFfCOLUsSSuS"
   },
   "source": [
    "### Question 2.2: Words with Multiple Meanings (1.5 points) [code + written] \n",
    "Polysemes and homonyms are words that have more than one meaning (see this [wiki page](https://en.wikipedia.org/wiki/Polysemy) to learn more about the difference between polysemes and homonyms ). Find a word with *at least two different meanings* such that the top-10 most similar words (according to cosine similarity) contain related words from *both* meanings. For example, \"leaves\" has both \"go_away\" and \"a_structure_of_a_plant\" meaning in the top 10, and \"scoop\" has both \"handed_waffle_cone\" and \"lowdown\". You will probably need to try several polysemous or homonymic words before you find one. \n",
    "\n",
    "Please state the word you discover and the multiple meanings that occur in the top 10. Why do you think many of the polysemous or homonymic words you tried didn't work (i.e. the top-10 most similar words only contain **one** of the meanings of the words)?\n",
    "\n",
    "**Note**: You should use the `wv_from_bin.most_similar(word)` function to get the top 10 most similar words. This function ranks all other words in the vocabulary with respect to their cosine similarity to the given word. For further assistance, please check the __[GenSim documentation](https://radimrehurek.com/gensim/models/keyedvectors.html#gensim.models.keyedvectors.FastTextKeyedVectors.most_similar)__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ZAr09U-xSSuT",
    "outputId": "da8adff7-c61e-43a0-8f4b-66084b4a66b8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('mice', 0.6580958962440491),\n",
       " ('keyboard', 0.5548277497291565),\n",
       " ('rat', 0.5433949828147888),\n",
       " ('rabbit', 0.5192376971244812),\n",
       " ('cat', 0.5077415704727173),\n",
       " ('cursor', 0.5058691501617432),\n",
       " ('trackball', 0.5048902630805969),\n",
       " ('joystick', 0.49841052293777466),\n",
       " ('mickey', 0.47242844104766846),\n",
       " ('clicks', 0.4722806215286255)]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ------------------\n",
    "# Write your implementation here.\n",
    "wv_from_bin.most_similar(\"mouse\")\n",
    "# ------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Failed Example 1<<<\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('banks', 0.7625691294670105),\n",
       " ('banking', 0.6818838119506836),\n",
       " ('central', 0.6283639073371887),\n",
       " ('financial', 0.6166563034057617),\n",
       " ('credit', 0.6049751043319702),\n",
       " ('lending', 0.5980608463287354),\n",
       " ('monetary', 0.5963003039360046),\n",
       " ('bankers', 0.5913101434707642),\n",
       " ('loans', 0.5802940130233765),\n",
       " ('investment', 0.574020266532898)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      ">>> Failed Example 2 <<<\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('present', 0.6921151280403137),\n",
       " ('future', 0.6827352046966553),\n",
       " ('its', 0.6762338280677795),\n",
       " ('the', 0.6630324721336365),\n",
       " ('change', 0.6562344431877136),\n",
       " ('term', 0.654639720916748),\n",
       " ('same', 0.6516712307929993),\n",
       " ('this', 0.6397123336791992),\n",
       " ('of', 0.6339256763458252),\n",
       " ('year', 0.6308804750442505)]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\">>> Failed Example 1<<<\")\n",
    "display(wv_from_bin.most_similar(\"bank\"))\n",
    "\n",
    "print(\"\\n>>> Failed Example 2 <<<\")\n",
    "display(wv_from_bin.most_similar(\"current\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VdQ018tjSSuT",
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    When we discuss the topic like animals, \"mouse\" refers to a type of small rodent. On the other hand, it's also an useful device for controlling the cursor on the computer screen. Hence, we can observe similar words, such as \"keyboard\", \"cursor\", and \"clicks\".<br>\n",
    "    One reason many polysemous or homonymic words don't work well is that one meaning tends to be <strong>dominant</strong> in most contexts. For example, the top 10 most similar words for \"bank\" are all related to <strong>finance</strong>, with none referring to the land alongside a river. Similarly, the word \"current\" is mostly associated with the concept of <strong>time</strong>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VfeW-eK9SSuU"
   },
   "source": [
    "### Question 2.3: Synonyms & Antonyms (2 points) [code + written] \n",
    "\n",
    "When considering Cosine Similarity, it's often more convenient to think of Cosine Distance, which is simply 1 - Cosine Similarity.\n",
    "\n",
    "Find three words $(w_1,w_2,w_3)$ where $w_1$ and $w_2$ are synonyms and $w_1$ and $w_3$ are antonyms, but Cosine Distance $(w_1,w_3) <$ Cosine Distance $(w_1,w_2)$. \n",
    "\n",
    "As an example, $w_1$=\"happy\" is closer to $w_3$=\"sad\" than to $w_2$=\"cheerful\". Please find a different example that satisfies the above. Once you have found your example, please give a possible explanation for why this counter-intuitive result may have happened.\n",
    "\n",
    "You should use the the `wv_from_bin.distance(w1, w2)` function here in order to compute the cosine distance between two words. Please see the __[GenSim documentation](https://radimrehurek.com/gensim/models/keyedvectors.html#gensim.models.keyedvectors.FastTextKeyedVectors.distance)__ for further assistance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bwlpPjpHSSuV",
    "outputId": "8c983677-b3d1-4423-d31c-da566cb522a5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synonyms \"interesting\" and \"alluring\" have cosine distance 0.61.\n",
      "Antonyms \"interesting\" and \"boring\" have cosine distance 0.53.\n"
     ]
    }
   ],
   "source": [
    "# ------------------\n",
    "# Write your implementation here.\n",
    "w1, w2, w3 = \"interesting\", \"alluring\", \"boring\"\n",
    "dist1 = wv_from_bin.distance(w1, w2)\n",
    "dist2 = wv_from_bin.distance(w1, w3)\n",
    "print(f\"Synonyms \\\"{w1}\\\" and \\\"{w2}\\\" have cosine distance {dist1:.2f}.\")\n",
    "print(f\"Antonyms \\\"{w1}\\\" and \\\"{w3}\\\" have cosine distance {dist2:.2f}.\")\n",
    "# ------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PeIHjTFMSSuV"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    \"Interesting\" and \"alluring\" both carry positive connotations and are often used to describe things that capture attention. However, in terms of cosine similarity, \"interesting\" is closer to \"boring\". This may be because \"interesting\" and \"boring\" apply to a wider range of contexts, whereas \"alluring\" is more specifically associated with physical or aesthetic appeal. Additionally, \"interesting\" and \"boring\" are frequently used in contrast (e.g., \"the most interesting and boring movies you've seen\"). Conversely, it's rare to find \"interesting\" and \"alluring\" used together in the same context.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZxIDq26zSSuW"
   },
   "source": [
    "### Question 2.4: Analogies with Word Vectors [written] (1.5 points)\n",
    "Word vectors have been shown to *sometimes* exhibit the ability to solve analogies. \n",
    "\n",
    "As an example, for the analogy \"man : grandfather :: woman : x\" (read: man is to grandfather as woman is to x), what is x?\n",
    "\n",
    "In the cell below, we show you how to use word vectors to find x using the `most_similar` function from the __[GenSim documentation](https://radimrehurek.com/gensim/models/keyedvectors.html#gensim.models.keyedvectors.KeyedVectors.most_similar)__. The function finds words that are most similar to the words in the `positive` list and most dissimilar from the words in the `negative` list (while omitting the input words, which are often the most similar; see [this paper](https://www.aclweb.org/anthology/N18-2039.pdf)). The answer to the analogy will have the highest cosine similarity (largest returned numerical value)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "u0pC7H4VSSuY",
    "outputId": "a2e3a0c1-2621-4def-f00b-f3de583f86bf"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('grandmother', 0.7608445286750793),\n",
      " ('granddaughter', 0.7200808525085449),\n",
      " ('daughter', 0.7168302536010742),\n",
      " ('mother', 0.7151536345481873),\n",
      " ('niece', 0.7005682587623596),\n",
      " ('father', 0.6659887433052063),\n",
      " ('aunt', 0.6623408794403076),\n",
      " ('grandson', 0.6618767976760864),\n",
      " ('grandparents', 0.6446609497070312),\n",
      " ('wife', 0.644535481929779)]\n"
     ]
    }
   ],
   "source": [
    "# Run this cell to answer the analogy -- man : grandfather :: woman : x\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=['woman', 'grandfather'], negative=['man']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XVv8I9WwSSuZ"
   },
   "source": [
    "Let $m$, $g$, $w$, and $x$ denote the word vectors for `man`, `grandfather`, `woman`, and the answer, respectively. Using **only** vectors $m$, $g$, $w$, and the vector arithmetic operators $+$ and $-$ in your answer, what is the expression in which we are maximizing cosine similarity with $x$?\n",
    "\n",
    "Hint: Recall that word vectors are simply multi-dimensional vectors that represent a word. It might help to draw out a 2D example using arbitrary locations of each vector. Where would `man` and `woman` lie in the coordinate plane relative to `grandfather` and the answer?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "KlUKBqtHSSuZ"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "$x = w + (g - m)$\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    It's intuitive to formulate an expression that preserves the semantic relationship between \"man\" and \"grandfather\" while transferring that relationship to a new base word, \"woman.\"\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2rRgMca9SSua"
   },
   "source": [
    "### Question 2.5: Finding Analogies [code + written]  (1.5 points)\n",
    "a. For the previous example, it's clear that \"grandmother\" completes the analogy. But give an intuitive explanation as to why the `most_similar` function gives us words like \"granddaughter\", \"daughter\", or \"mother?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WgYQXazQSSua"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    As observed, these words share a <strong>consanguinity</strong> relationship, which intuitively brings them closer together.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p9aAUXEISSub"
   },
   "source": [
    "b. Find an example of analogy that holds according to these vectors (i.e. the intended word is ranked top). In your solution please state the full analogy in the form x:y :: a:b. If you believe the analogy is complicated, explain why the analogy holds in one or two sentences.\n",
    "\n",
    "**Note**: You may have to try many analogies to find one that works!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "id": "CRvYK2xifpq7"
   },
   "outputs": [],
   "source": [
    "# For example: x, y, a, b = (\"\", \"\", \"\", \"\")\n",
    "# ------------------\n",
    "# Write your implementation here.\n",
    "x, y, a, b = (\"steam\", \"hot\", \"ice\", \"cold\")\n",
    "# ------------------\n",
    "\n",
    "# Test the solution\n",
    "assert wv_from_bin.most_similar(positive=[a, y], negative=[x])[0][0] == b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K3QlPqAwSSub"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    \"steam : hot :: ice : cold\": \"steam\" is to \"hot\" as \"ice\" is to \"cold\".\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "SwgcEywwSSuc"
   },
   "source": [
    "### Question 2.6: Incorrect Analogy [code + written] (1.5 points)\n",
    "a. Below, we expect to see the intended analogy \"hand : glove :: foot : **sock**\", but we see an unexpected result instead. Give a potential reason as to why this particular analogy turned out the way it did?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "m-ykWoJoSSuc",
    "outputId": "60fa3812-3e62-429e-c309-349463c75f9e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('45,000-square', 0.4922032058238983),\n",
      " ('15,000-square', 0.4649604558944702),\n",
      " ('10,000-square', 0.45447564125061035),\n",
      " ('6,000-square', 0.44975775480270386),\n",
      " ('3,500-square', 0.4441334009170532),\n",
      " ('700-square', 0.44257497787475586),\n",
      " ('50,000-square', 0.43563973903656006),\n",
      " ('3,000-square', 0.43486514687538147),\n",
      " ('30,000-square', 0.4330596625804901),\n",
      " ('footed', 0.43236875534057617)]\n"
     ]
    }
   ],
   "source": [
    "pprint.pprint(wv_from_bin.most_similar(positive=['foot', 'glove'], negative=['hand']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zn4ruS8MSSud"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    Upon reviewing the top 10 most similar words, many appear nonsensical, such as the analogy \"hand : glove :: foot : 45,000-square.\" We suspect this is due to poor data quality or an insufficient number of training samples for the model to correctly identify the intended analogy.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D1gHyZt0SSud"
   },
   "source": [
    "b. Find another example of analogy that does *not* hold according to these vectors. In your solution, state the intended analogy in the form x:y :: a:b, and state the **incorrect** value of b according to the word vectors (in the previous example, this would be **'45,000-square'**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "ms-DTC8_ftiA"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('saying', 0.5144181251525879),\n",
      " ('should', 0.4947633445262909),\n",
      " ('here', 0.49109554290771484),\n",
      " ('him', 0.4902016520500183),\n",
      " ('government', 0.4864197373390198),\n",
      " ('urged', 0.47555842995643616),\n",
      " ('so', 0.46992477774620056),\n",
      " ('countries', 0.4688504934310913),\n",
      " ('year', 0.46670961380004883),\n",
      " ('because', 0.46662184596061707)]\n"
     ]
    }
   ],
   "source": [
    "# For example: x, y, a, b = (\"\", \"\", \"\", \"\")\n",
    "# ------------------\n",
    "# Write your implementation here.\n",
    "x, y, a, b = (\"empire\", \"emperor\", \"country\", \"president\")\n",
    "# ------------------\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=[a, y], negative=[x]))\n",
    "assert wv_from_bin.most_similar(positive=[a, y], negative=[x])[0][0] != b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "c4x0EHjeSSue"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    The intended analogy is \"empire : emperor :: country : president\", but we get incorrect values, like \"saying\" and \"should\", which are totally unrelated.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yvlycXN-SSuf"
   },
   "source": [
    "### Question 2.7: Guided Analysis of Bias in Word Vectors [written] (1 point)\n",
    "\n",
    "It's important to be cognizant of the biases (gender, race, sexual orientation etc.) implicit in our word embeddings. Bias can be dangerous because it can reinforce stereotypes through applications that employ these models.\n",
    "\n",
    "Run the cell below, to examine (a) which terms are most similar to \"man\" and \"profession\" and most dissimilar to \"woman\" and (b) which terms are most similar to \"woman\" and \"profession\" and most dissimilar to \"man\". Point out the difference between the list of female-associated words and the list of male-associated words, and explain how it is reflecting gender bias."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "XggWA4MhSSuf",
    "outputId": "534a694b-f4fa-479e-9e7c-12b17db3abb8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('reputation', 0.5250176787376404),\n",
      " ('professions', 0.5178037881851196),\n",
      " ('skill', 0.49046966433525085),\n",
      " ('skills', 0.49005505442619324),\n",
      " ('ethic', 0.4897659420967102),\n",
      " ('business', 0.487585186958313),\n",
      " ('respected', 0.485920250415802),\n",
      " ('practice', 0.4821045696735382),\n",
      " ('regarded', 0.4778572618961334),\n",
      " ('life', 0.4760662019252777)]\n",
      "\n",
      "[('professions', 0.5957458019256592),\n",
      " ('practitioner', 0.4988412857055664),\n",
      " ('teaching', 0.48292139172554016),\n",
      " ('nursing', 0.48211804032325745),\n",
      " ('vocation', 0.4788965880870819),\n",
      " ('teacher', 0.47160351276397705),\n",
      " ('practicing', 0.4693780839443207),\n",
      " ('educator', 0.46524327993392944),\n",
      " ('physicians', 0.4628995656967163),\n",
      " ('professionals', 0.46013936400413513)]\n"
     ]
    }
   ],
   "source": [
    "# Run this cell\n",
    "# Here `positive` indicates the list of words to be similar to and `negative` indicates the list of words to be\n",
    "# most dissimilar from.\n",
    "\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=['man', 'profession'], negative=['woman']))\n",
    "print()\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=['woman', 'profession'], negative=['man']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x4g6KbsYSSuh"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    Words most similar to \"woman\" and \"profession\" are predominantly associated with caregiving roles, many of which are typically <strong>low-paid</strong>. In contrast, professions associated with \"man\" are more likely to be linked with terms like \"reputation\" and \"respected,\" which are broadly positive. This disparity highlights the presence of gender stereotypes in our word embedding model, which could negatively impact downstream tasks.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LxJmnS6lSSui"
   },
   "source": [
    "### Question 2.8: Independent Analysis of Bias in Word Vectors [code + written]  (1 point)\n",
    "\n",
    "Use the `most_similar` function to find another pair of analogies that demonstrates some bias is exhibited by the vectors. Please briefly explain the example of bias that you discover."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "PZoDheIfSSui",
    "outputId": "f45fef83-ee36-4ef1-b970-775c3b40c515"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>> Toy - Boy <<<\n",
      "[('toys', 0.7157087922096252),\n",
      " ('hasbro', 0.5164632797241211),\n",
      " ('robot', 0.47317108511924744),\n",
      " ('pet', 0.4670490026473999),\n",
      " ('manufacturer', 0.46681636571884155),\n",
      " ('mattel', 0.4582391679286957),\n",
      " ('lego', 0.45811769366264343),\n",
      " ('miniature', 0.4441472887992859),\n",
      " ('makers', 0.4429824948310852),\n",
      " ('manufactured', 0.44275349378585815)]\n",
      "\n",
      ">>> Toy - Girl <<<\n",
      "[('toys', 0.7094953060150146),\n",
      " ('doll', 0.5932914614677429),\n",
      " ('dolls', 0.5706622004508972),\n",
      " ('barbie', 0.5407706499099731),\n",
      " ('mattel', 0.532855212688446),\n",
      " ('accessories', 0.52069091796875),\n",
      " ('hasbro', 0.49227219820022583),\n",
      " ('jewelry', 0.47385698556900024),\n",
      " ('lego', 0.4690813422203064),\n",
      " ('apparel', 0.4613623321056366)]\n"
     ]
    }
   ],
   "source": [
    "# ------------------\n",
    "# Write your implementation here.\n",
    "obj1, obj2 = \"boy\", \"girl\"\n",
    "subject = \"toy\"\n",
    "\n",
    "print(\">>> Toy - Boy <<<\")\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=[obj1, subject], negative=[obj2]))\n",
    "print()\n",
    "print(\">>> Toy - Girl <<<\")\n",
    "pprint.pprint(wv_from_bin.most_similar(positive=[obj2, subject], negative=[obj1]))\n",
    "# ------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "TGOlmtJoSSuj"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    We use gender stereotypes once more to illustrate that bias extends across different age levels. For example, boys are often associated with toys like \"robot\" and \"lego,\" while girls are commonly linked to \"doll\" and \"barbie.\" This clearly demonstrates the presence of stereotypes.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eK2XVWzmSSuk"
   },
   "source": [
    "### Question 2.9: Thinking About Bias [written] (2 points)\n",
    "\n",
    "a. Give one explanation of how bias gets into the word vectors. Briefly describe a real-world example that demonstrates this source of bias. Your real-world example should be focused on word vectors, as opposed to bias in other AI systems (e.g., ChatGPT)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "19pM85fCSSuk"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    The most intuitive source of bias in word embeddings is the training corpus used to train the model. If the training samples (e.g., documents) are biased towards specific races, the model is likely to learn and reflect these biases, resulting in <strong>racial discrimination</strong>.<br>\n",
    "    A real-world example of this bias is <strong>online racism</strong> observed on platforms like Reddit. According to <a href=\"https://aclanthology.org/N19-1062.pdf\">Manzini et al.</a>, embeddings can exhibit racial biases, such as the association of \"black\" with \"criminal\", as demonstrated in Table 1 of their study.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ILYqJZ7ASSul"
   },
   "source": [
    "b. What is one method you can use to mitigate bias exhibited by word vectors? Briefly describe a real-world example that demonstrates this method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dnJaAB7mSSul"
   },
   "source": [
    "#### <font color=\"red\">Write your answer here.</font>\n",
    "\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "    The commonly adopted methods to mitigate bias are <strong>hard debiasing</strong> and <strong>soft debiasing</strong> (<a href=\"https://arxiv.org/pdf/1607.06520\">Bolukbasi et al.</a>). The first step is to identify the vector subspace that captures the bias. Then, the specific associations (e.g., gender associations)  lying in that subspace are removed from the original word embeddings.<br>\n",
    "    <a href=\"https://aclanthology.org/N19-1062.pdf\">Manzini et al.</a> generalizes the study by identifying the bias subspace in a multi-class setting. Then, a generalized multi-class debiasing can be applied to mitigate biases in multiple dimensions (e.g., gender, race, religion).\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dzh3eEmZSSum"
   },
   "source": [
    "# <font color=\"blue\"> Submission Instructions</font>\n",
    "\n",
    "1. Click the Save button at the top of the Jupyter Notebook.\n",
    "2. Select Cell -> All Output -> Clear. This will clear all the outputs from all cells (but will keep the content of all cells). \n",
    "2. Select Cell -> Run All. This will run all the cells in order, and will take several minutes.\n",
    "3. Once you've rerun everything, select File -> Download as -> PDF via LaTeX (If you have trouble using \"PDF via LaTex\", you can also save the webpage as pdf. <font color='blue'> Make sure all your solutions especially the coding parts are displayed in the pdf</font>, it's okay if the provided codes get cut off because lines are not wrapped in code cells).\n",
    "4. Look at the PDF file and make sure all your solutions are there, displayed correctly. The PDF is the only thing your graders will see!\n",
    "5. Submit your PDF on Gradescope."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "fun",
   "language": "python",
   "name": "fun"
  },
  "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.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}