chapter_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "de25cddd",
   "metadata": {},
   "source": [
    "## Chapter 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ed12ff00",
   "metadata": {},
   "outputs": [],
   "source": [
    "import nltk\n",
    "from nltk.corpus import *\n",
    "from nltk.book import *\n",
    "import string\n",
    "import matplotlib.pyplot as plt\n",
    "import random\n",
    "from collections import defaultdict\n",
    "from nltk.util import ngrams"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c767cdf3",
   "metadata": {},
   "source": [
    "◑ Define a conditional frequency distribution over the Names corpus that allows you to see which initial letters are more frequent for males vs. females"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "40556f09",
   "metadata": {},
   "outputs": [],
   "source": [
    "names_female = names.words(\"female.txt\")\n",
    "names_male = names.words(\"male.txt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8aade472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Female names ['Abagael', 'Abagail', 'Abbe', 'Abbey', 'Abbi', 'Abbie', 'Abby', 'Abigael', 'Abigail', 'Abigale'] \n",
      "Male names ['Aamir', 'Aaron', 'Abbey', 'Abbie', 'Abbot', 'Abbott', 'Abby', 'Abdel', 'Abdul', 'Abdulkarim']\n"
     ]
    }
   ],
   "source": [
    "print(\"Female names {} \\nMale names {}\".format(names_female[:10], names_male[:10]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d54a73f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='Samples', ylabel='Counts'>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.ConditionalFreqDist(\n",
    "    (gender, name[0])\n",
    "    for gender in [\"female\", \"male\"]\n",
    "    for name in names.words(gender + \".txt\")\n",
    ").plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c53c88a",
   "metadata": {},
   "source": [
    "◑ Pick a pair of texts and study the differences between them, in terms of vocabulary, vocabulary richness, genre, etc. Can you find pairs of words which have quite different meanings across the two texts, such as monstrous in Moby Dick and in Sense and Sensibility?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f0c94b1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "genesis = text3\n",
    "monty = text6\n",
    "gen_len = len(genesis)\n",
    "mon_len = len(monty)\n",
    "gen_vocab = set([w.lower() for w in genesis])\n",
    "mon_vocab = set([w.lower() for w in monty])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2e950a37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length comparison\n",
      "Genesis    44764\n",
      "Monty      16967\n"
     ]
    }
   ],
   "source": [
    "print(\"Length comparison\")\n",
    "print(\"Genesis {:>8}\".format(gen_len))\n",
    "print(\"Monty {:>10}\".format(mon_len))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "02ea083b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocab size\n",
      "Genesis     2628\n",
      "Monty       1855 \n",
      "\n",
      "We can see that Genesis has poor vocab compared to Monty Python.\n",
      "The vocab/length ration for Genesis is 0.05870789026896613 and for Monty 0.10932987564095008\n"
     ]
    }
   ],
   "source": [
    "print(\"Vocab size\")\n",
    "print(\"Genesis {:>8}\".format(len(gen_vocab)))\n",
    "print(\"Monty {:>10} \\n\".format(len(mon_vocab)))\n",
    "print(\"We can see that Genesis has poor vocab compared to Monty Python.\\n\\\n",
    "The vocab/length ration for Genesis is {} and for Monty {}\".format((len(gen_vocab)/gen_len), (len(mon_vocab)/mon_len)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eaed0f7",
   "metadata": {},
   "source": [
    "◑ Read the BBC News article: UK's Vicky Pollards 'left behind' http://news.bbc.co.uk/1/hi/education/6173441.stm. The article gives the following statistic about teen language: \"the top 20 words used, including yeah, no, but and like, account for around a third of all words.\" How many word types account for a third of all word tokens, for a variety of text sources? What do you conclude about this statistic? Read more about this on LanguageLog, at http://itre.cis.upenn.edu/~myl/languagelog/archives/003993.html."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "3f573376",
   "metadata": {},
   "outputs": [],
   "source": [
    "news = brown.words(categories = \"news\")\n",
    "fiction = brown.words(categories = \"fiction\")\n",
    "humor = brown.words(categories = \"humor\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "cbfb0163",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4318"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "news_freq = nltk.FreqDist(news)\n",
    "int(len(nltk.FreqDist(news)) * 0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a057ea",
   "metadata": {},
   "source": [
    "4318 words are quite a lot to print here, so I will print 20 most common for each genre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "4619ba73",
   "metadata": {},
   "outputs": [],
   "source": [
    "news_20 = [w for (w, f) in news_freq.most_common(20)]\n",
    "fiction_20 = [w for (w, f) in nltk.FreqDist(fiction).most_common(20)]\n",
    "humor_20 = [w for (w, f) in nltk.FreqDist(humor).most_common(20)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "4f863c9d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Most frequent words in \n",
      "\n",
      "news ['the', ',', '.', 'of', 'and', 'to', 'a', 'in', 'for', 'The', 'that', '``', 'is', 'was', \"''\", 'on', 'at', 'with', 'be', 'by'] \n",
      "fiction[',', '.', 'the', 'and', 'to', 'of', 'a', 'was', 'in', 'he', 'his', 'had', '``', \"''\", '?', 'that', 'I', 'He', 'with', 'it'] \n",
      "humor[',', 'the', '.', 'of', 'and', 'a', 'to', '``', \"''\", 'in', 'was', 'that', 'I', 'it', '?', 'for', 'had', 'he', 'his', 'you']\n"
     ]
    }
   ],
   "source": [
    "print(\"Most frequent words in \\n\\nnews {} \\nfiction{} \\nhumor{}\".format(news_20, fiction_20, humor_20))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2cd4c42",
   "metadata": {},
   "source": [
    "Taking only 20 most frequent words, gives us either a punctuation or a stop word, unsurprisingly. I will try it out with some preprocessing now."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "df9b1764",
   "metadata": {},
   "outputs": [],
   "source": [
    "news_clean = [w.lower() for w in news if w.lower() not in stopwords.words(\"english\") and w not in string.punctuation]\n",
    "fiction_clean = [w.lower() for w in fiction if w.lower() not in stopwords.words(\"english\") and w not in string.punctuation]\n",
    "humor_clean = [w.lower() for w in humor if w.lower() not in stopwords.words(\"english\") and w not in string.punctuation]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "bdac4b29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('``', 732),\n",
       " (\"''\", 702),\n",
       " ('said', 406),\n",
       " ('--', 300),\n",
       " ('mrs.', 253),\n",
       " ('would', 246),\n",
       " ('new', 241),\n",
       " ('one', 213),\n",
       " ('last', 177),\n",
       " ('two', 174),\n",
       " ('mr.', 170),\n",
       " ('first', 158),\n",
       " ('state', 153),\n",
       " ('year', 142),\n",
       " ('president', 142),\n",
       " ('home', 132),\n",
       " ('also', 129),\n",
       " ('made', 107),\n",
       " ('time', 103),\n",
       " ('years', 102)]"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nltk.FreqDist(news_clean).most_common(20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6cf0a2",
   "metadata": {},
   "source": [
    "◑ Investigate the table of modal distributions and look for other patterns. Try to explain them in terms of your own impressionistic understanding of the different genres. Can you find other closed classes of words that exhibit significant differences across different genres?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "e132b288",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                   I  you   he  she   we they \n",
      "           news  179   55  451   42   77  205 \n",
      "       religion  155  100  137   10  176  115 \n",
      "        hobbies  154  383  155   21  100  177 \n",
      "science_fiction   98   81  139   36   30   53 \n",
      "        romance  951  456  702  496   78  168 \n",
      "          humor  239  131  146   58   32   70 \n"
     ]
    }
   ],
   "source": [
    "cfd = nltk.ConditionalFreqDist(\n",
    "         (genre, word)\n",
    "         for genre in brown.categories()\n",
    "         for word in brown.words(categories=genre) if word in pronouns)\n",
    "genres = ['news', 'religion', 'hobbies', 'science_fiction', 'romance', 'humor']\n",
    "pronouns = ['I', 'you', 'he', 'she', 'we', 'they']\n",
    "cfd.tabulate(conditions=genres, samples=pronouns)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cc22d74",
   "metadata": {},
   "source": [
    "◑ The CMU Pronouncing Dictionary contains multiple pronunciations for certain words. How many distinct words does it contain? What fraction of words in this dictionary have more than one possible pronunciation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "de799cf5",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_pron = len(cmudict.entries())\n",
    "vocab_cmu = [w.lower() for (w, phone) in cmudict.entries()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "95b90b05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count of words that have more than one pronunciation in CMU is 10282\n"
     ]
    }
   ],
   "source": [
    "print(\"The count of words that have more than one pronunciation in CMU is {}\".format(all_pron - len(set(vocab_cmu))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "95192286",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "word_occur = Counter(vocab_cmu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "c8f710e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's see what are the 5 words with most possible pronunciations\n",
    "most_pron_5 = sorted(word_occur, key = word_occur.get, reverse = True)[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "2ab88c9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "The word february has 5 pronunciations\n",
      "\n",
      "['F', 'EH1', 'B', 'Y', 'AH0', 'W', 'EH2', 'R', 'IY0']\n",
      "['F', 'EH1', 'B', 'AH0', 'W', 'EH2', 'R', 'IY0']\n",
      "['F', 'EH1', 'B', 'R', 'UW0', 'W', 'EH2', 'R', 'IY0']\n",
      "['F', 'EH1', 'B', 'UW0', 'W', 'EH2', 'R', 'IY0']\n",
      "['F', 'EH1', 'B', 'Y', 'UW0', 'W', 'EH2', 'R', 'IY0']\n",
      "\n",
      "\n",
      "The word february's has 5 pronunciations\n",
      "\n",
      "['F', 'EH1', 'B', 'Y', 'AH0', 'W', 'EH2', 'R', 'IY0', 'Z']\n",
      "['F', 'EH1', 'B', 'AH0', 'W', 'EH2', 'R', 'IY0', 'Z']\n",
      "['F', 'EH1', 'B', 'R', 'UW0', 'W', 'EH2', 'R', 'IY0', 'Z']\n",
      "['F', 'EH1', 'B', 'UW0', 'W', 'EH2', 'R', 'IY0', 'Z']\n",
      "['F', 'EH1', 'B', 'Y', 'UW0', 'W', 'EH2', 'R', 'IY0', 'Z']\n",
      "\n",
      "\n",
      "The word abkhazian has 4 pronunciations\n",
      "\n",
      "['AE0', 'B', 'K', 'HH', 'AA1', 'Z', 'IY0', 'AH0', 'N']\n",
      "['AE0', 'B', 'K', 'HH', 'AE1', 'Z', 'IY0', 'AH0', 'N']\n",
      "['AE0', 'B', 'K', 'HH', 'AA1', 'Z', 'Y', 'AH0', 'N']\n",
      "['AE0', 'B', 'K', 'HH', 'AE1', 'Z', 'Y', 'AH0', 'N']\n",
      "\n",
      "\n",
      "The word activists has 4 pronunciations\n",
      "\n",
      "['AE1', 'K', 'T', 'AH0', 'V', 'AH0', 'S', 'T', 'S']\n",
      "['AE1', 'K', 'T', 'IH0', 'V', 'IH0', 'S', 'T', 'S']\n",
      "['AE1', 'K', 'T', 'AH0', 'V', 'AH0', 'S']\n",
      "['AE1', 'K', 'T', 'IH0', 'V', 'IH0', 'S']\n",
      "\n",
      "\n",
      "The word actually has 4 pronunciations\n",
      "\n",
      "['AE1', 'K', 'CH', 'AH0', 'W', 'AH0', 'L', 'IY0']\n",
      "['AE1', 'K', 'SH', 'L', 'IY0']\n",
      "['AE1', 'K', 'CH', 'L', 'IY0']\n",
      "['AE1', 'K', 'SH', 'AH0', 'L', 'IY0']\n"
     ]
    }
   ],
   "source": [
    "for w in most_pron_5:\n",
    "    print(\"\\n\\nThe word {} has {} pronunciations\\n\".format(w, word_occur[w]))\n",
    "    print(*[pron for pron in cmudict.dict()[w]], sep = \"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b331e52",
   "metadata": {},
   "source": [
    "◑ What percentage of noun synsets have no hyponyms? You can get all noun synsets using wn.all_synsets('n')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "4cbe061c",
   "metadata": {},
   "outputs": [],
   "source": [
    "no_hypo_syn = [syn for syn in wordnet.all_synsets('n') if len(syn.hyponyms()) == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "0a0e8303",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65422\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Synset('congener.n.03'),\n",
       " Synset('benthos.n.02'),\n",
       " Synset('dwarf.n.03'),\n",
       " Synset('heterotroph.n.01'),\n",
       " Synset('parent.n.02')]"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(len(no_hypo_syn)) # Count of words with no hyponyms is 65422\n",
    "no_hypo_syn[:5]         # firts five examples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "406c44c5",
   "metadata": {},
   "source": [
    "◑ Define a function supergloss(s) that takes a synset s as its argument and returns a string consisting of the concatenation of the definition of s, and the definitions of all the hypernyms and hyponyms of s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "0b70b7ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "def supergloss(synset):\n",
    "    hypos = synset.hyponyms()\n",
    "    hypers = synset.hypernyms()\n",
    "    return {\"definition\" : synset.definition(), \n",
    "            \"hypo_def\" : [(hypo.lemma_names()[0], hypo.definition()) for hypo in hypos], \n",
    "            \"hyper_def\" :[(hyper.lemma_names()[0], hyper.definition()) for hyper in hypers]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "103500ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a motor vehicle with four wheels; usually propelled by an internal combustion engine\n",
      "('bus', 'a car that is old and unreliable')\n",
      "('motor_vehicle', 'a self-propelled wheeled vehicle that does not run on rails')\n"
     ]
    }
   ],
   "source": [
    "car_gloss = supergloss(wordnet.synset(\"car.n.01\"))\n",
    "print(car_gloss[\"definition\"])   # definition of the synset\n",
    "print(car_gloss[\"hypo_def\"][2])  # definition of the third hyponym\n",
    "print(car_gloss[\"hyper_def\"][0])  # definition of the first hypernym"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "112d618e",
   "metadata": {},
   "source": [
    "◑ Write a program to find all words that occur at least three times in the Brown Corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "843f08da",
   "metadata": {},
   "outputs": [],
   "source": [
    "brown_words = brown.words()\n",
    "dict_brown = Counter([w.lower() for w in brown_words])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "af0cc2df",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator_of_3_count_w_brown():\n",
    "    for w, freq in dict_brown.items():\n",
    "        if freq == 3:\n",
    "            yield w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "c098b758",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "awarding\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "brown_gen = generator_of_3_count_w_brown()\n",
    "print(next(brown_gen))\n",
    "print(dict_brown[next(brown_gen)]) # sanity check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "04ed1cdb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "caldwell\n"
     ]
    }
   ],
   "source": [
    "print(next(brown_gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb5b449f",
   "metadata": {},
   "source": [
    "◑ Write a program to generate a table of lexical diversity scores (i.e. token/type ratios), as we saw in 1.1. Include the full set of Brown Corpus genres (nltk.corpus.brown.categories()). Which genre has the lowest diversity (greatest number of tokens per type)? Is this what you would have expected?\n",
    "\n",
    "__I will skip this one since the lexical diversity code was already shown in the book.__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "993c3e8d",
   "metadata": {},
   "source": [
    "◑ Write a function that finds the 50 most frequently occurring words of a text that are not stopwords.\n",
    "\n",
    "__Already implemented similar code above with News, Fiction and Humor texts__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "c3a353e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def most_freq_n(tokens, n = 5):\n",
    "    \"\"\"\n",
    "    Calculates most frequent n words in a given text. By default n = 5\n",
    "    \"\"\"\n",
    "    \n",
    "    if type(tokens) == str:\n",
    "        tokens = nltk.word_tokenize(tokens)\n",
    "        \n",
    "    word_clean = []\n",
    "\n",
    "    for w in tokens:\n",
    "        if w.lower() not in stopwords.words(\"english\") and w not in string.punctuation:\n",
    "            word_clean.append(w)\n",
    "            \n",
    "    freq = nltk.FreqDist(word_clean)\n",
    "    \n",
    "    return freq.most_common(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "95f6d033",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('``', 3499), (\"''\", 3457), ('--', 1397), ('would', 1280), ('one', 1230)]\n"
     ]
    }
   ],
   "source": [
    "print(most_freq_n(brown.words(categories = news), 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32c647cb",
   "metadata": {},
   "source": [
    "◑ Write a program to print the 50 most frequent bigrams (pairs of adjacent words) of a text, omitting bigrams that contain stopwords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 278,
   "id": "a720ea84",
   "metadata": {},
   "outputs": [],
   "source": [
    "def most_freq_n_ngram(tokens, N = 5, ngram = 2):\n",
    "    \"\"\"\n",
    "    Calculates most frequent N ngrams words in a given token list. \n",
    "    By default ngram = 2 and N = 5 \n",
    "    \n",
    "    \"\"\"\n",
    "    # If raw string text received, firts tokenize it\n",
    "    if type(tokens) == str:\n",
    "        tokens = nltk.word_tokenize(tokens)\n",
    "    \n",
    "    token_clean = [w for w in tokens if w.lower() not in stopwords.words(\"english\") and w not in string.punctuation]\n",
    "    bigrams = nltk.bigram(tokens)\n",
    "    freq = nltk.FreqDist(token_clean)\n",
    "            \n",
    "    return freq.most_common(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a04c3633",
   "metadata": {},
   "source": [
    "◑ Write a function word_freq() that takes a word and the name of a section of the Brown Corpus as arguments, and computes the frequency of the word in that section of the corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "8a37a3b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def word_freq(word, genre):\n",
    "    freq = nltk.FreqDist(brown.words(categories = genre))\n",
    "    return freq[word]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70ef6303",
   "metadata": {},
   "source": [
    "◑ Write a program to guess the number of syllables contained in a text, making use of the CMU Pronouncing Dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "1e039fde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3, ['F', 'AY1', 'ER0', 'AA2', 'R', 'M']),\n",
       " (2, ['F', 'AY1', 'R', 'AA2', 'R', 'M'])]"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def vowel_count(pron):\n",
    "    return sum([1 for phone in pron for char in phone if char.isdigit()])\n",
    "\n",
    "[(vowel_count(pron), pron) for pron in cmudict.dict()[\"firearm\"]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0218f886",
   "metadata": {},
   "source": [
    "◑ Define a function hedge(text) which processes a text and produces a new version with the word 'like' between every third word."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 282,
   "id": "d4ebd0c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def hedge(text):\n",
    "    \n",
    "    if type(text) == str:\n",
    "        text = nltk.word_tokenize(text)\n",
    "        \n",
    "    new_text = []\n",
    "    for i, tok in enumerate(text, 1):\n",
    "        new_text.append(tok)\n",
    "        if i % 3 == 0:\n",
    "            new_text.append(\"like\")\n",
    "    return new_text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "id": "255de09b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I', 'am', 'learning', 'like', 'natural', 'language', 'processing', 'like']\n"
     ]
    }
   ],
   "source": [
    "print(hedge(\"I am learning natural language processing\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed4a1364",
   "metadata": {},
   "source": [
    "★ Zipf's Law: Let f(w) be the frequency of a word w in free text. Suppose that all the words of a text are ranked according to their frequency, with the most frequent word first. Zipf's law states that the frequency of a word type is inversely proportional to its rank (i.e. f × r = k, for some constant k). For example, the 50th most common word type should occur three times as frequently as the 150th most common word type.\n",
    "\n",
    "Write a function to process a large text and plot word frequency against word rank using pylab.plot. Do you confirm Zipf's law? (Hint: it helps to use a logarithmic scale). What is going on at the extreme ends of the plotted line?\n",
    "Generate random text, e.g., using random.choice(\"abcdefg \"), taking care to include the space character. You will need to import random first. Use the string concatenation operator to accumulate characters into a (very) long string. Then tokenize this string, and generate the Zipf plot as before, and compare the two plots. What do you make of Zipf's Law in the light of this?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "id": "fddd2643",
   "metadata": {},
   "outputs": [],
   "source": [
    "def zipf(text, rank = 20):\n",
    "    freqs = [v for w, v in most_freq_n(text, n = rank)]\n",
    "    plt.plot(range(1,rank+1), freqs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "id": "c7e0b7f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "zipf(news_clean)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2168188",
   "metadata": {},
   "source": [
    "★ Modify the text generation program in 2.2 further, to do the following tasks:\n",
    "\n",
    "Store the n most likely words in a list words then randomly choose a word from the list using random.choice(). (You will need to import random first.)\n",
    "Select a particular genre, such as a section of the Brown Corpus, or a genesis translation, one of the Gutenberg texts, or one of the Web texts. Train the model on this corpus and get it to generate random text. You may have to experiment with different start words. How intelligible is the text? Discuss the strengths and weaknesses of this method of generating random text.\n",
    "Now train your system using two distinct genres and experiment with generating text in the hybrid genre. Discuss your observations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "95038d9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_model(text, length = 20, number = 200):\n",
    "    \n",
    "    \"\"\"\n",
    "    text - generated text will be based on this\n",
    "    length - what length should b ethe generated text\n",
    "    number - most frequent N (number) counts wll be extracted from text for text generation\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    freq_words = [w for w, v in most_freq_n(text, n = number)]\n",
    "    bi_list = list(nltk.bigrams(freq_words))\n",
    "    bigram_2 = nltk.bigrams(bi_list)\n",
    "    \n",
    "    cfd = nltk.ConditionalFreqDist(bigram_2)\n",
    "    word = random.choice(bi_list)\n",
    "    \n",
    "    for i in range(length):\n",
    "        print(word[0], end=' ')\n",
    "        word = cfd[word].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c63a4a0c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'most_freq_n' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-cc7cc525e31c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Does not make much sense still\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mgenerate_model\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtext2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlength\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m20\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnumber\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m500\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-10-bd5c7ad0ef29>\u001b[0m in \u001b[0;36mgenerate_model\u001b[1;34m(text, length, number)\u001b[0m\n\u001b[0;32m      8\u001b[0m     \"\"\"\n\u001b[0;32m      9\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 10\u001b[1;33m     \u001b[0mfreq_words\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mw\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mw\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mv\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mmost_freq_n\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtext\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mn\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnumber\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     11\u001b[0m     \u001b[0mbi_list\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnltk\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbigrams\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfreq_words\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     12\u001b[0m     \u001b[0mbigram_2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnltk\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbigrams\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbi_list\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'most_freq_n' is not defined"
     ]
    }
   ],
   "source": [
    "# Does not make much sense still\n",
    "generate_model(text2, length = 20, number = 500)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa3adf88",
   "metadata": {},
   "source": [
    "★ Define a function find_language() that takes a string as its argument, and returns a list of languages that have that string as a word. Use the udhr corpus and limit your searches to files in the Latin-1 encoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "id": "71d3d445",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_language(string):\n",
    "    languages = [file for file in udhr.fileids() if \"Latin1\" in file]\n",
    "    candidate_lang = [lang for lang in languages if string in udhr.words(fileids = lang)]\n",
    "    return candidate_lang"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "6e37cce3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bichelamar-Latin1',\n",
       " 'Bikol_Bicolano-Latin1',\n",
       " 'Cakchiquel-Latin1',\n",
       " 'Chamorro-Latin1',\n",
       " 'Chuuk_Trukese-Latin1',\n",
       " 'English-Latin1',\n",
       " 'Friulian_Friulano-Latin1',\n",
       " 'Hiligaynon-Latin1',\n",
       " 'Ibibio_Efik-Latin1',\n",
       " 'Iloko_Ilocano-Latin1',\n",
       " 'Kapampangan-Latin1',\n",
       " 'Kiche_Quiche-Latin1',\n",
       " 'Luxembourgish_Letzebuergeusch-Latin1',\n",
       " 'Mam-Latin1',\n",
       " 'Marshallese-Latin1',\n",
       " 'NigerianPidginEnglish-Latin1',\n",
       " 'Sharanahua-Latin1',\n",
       " 'SolomonsPidgin_Pijin-Latin1',\n",
       " 'Tiv-Latin1',\n",
       " 'TokPisin-Latin1',\n",
       " 'Trukese_Chuuk-Latin1',\n",
       " 'Waray-Latin1']"
      ]
     },
     "execution_count": 399,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "find_language(\"man\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "id": "0a2fe454",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53"
      ]
     },
     "execution_count": 400,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Bichelamar = udhr.words(fileids = \"Bichelamar-Latin1\")\n",
    "freq_bichelamar = nltk.FreqDist(Bichelamar)\n",
    "freq_bichelamar[\"man\"]  # let us see how many time it appeared on that language text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ba8165",
   "metadata": {},
   "source": [
    "★ What is the branching factor of the noun hypernym hierarchy? I.e. for every noun synset that has hyponyms — or children in the hypernym hierarchy — how many do they have on average? You can get all noun synsets using wn.all_synsets('n')."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "id": "83becba6",
   "metadata": {},
   "outputs": [],
   "source": [
    "nouns = wordnet.all_synsets('n')\n",
    "nouns_with_hyponyms = [(syn, len(syn.hyponyms())) for syn in nouns if len(syn.hyponyms()) > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "id": "a158afc4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.543820763194153"
      ]
     },
     "execution_count": 414,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([count for syn, count in nouns_with_hyponyms])/len(nouns_with_hyponyms)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4de0a97",
   "metadata": {},
   "source": [
    "★ The polysemy of a word is the number of senses it has. Using WordNet, we can determine that the noun dog has 7 senses with: len(wn.synsets('dog', 'n')). Compute the average polysemy of nouns, verbs, adjectives and adverbs according to WordNet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afc34c43",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58713610",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a0c725c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cc5f4554",
   "metadata": {},
   "source": [
    "★ Use one of the predefined similarity measures to score the similarity of each of the following pairs of words. Rank the pairs in order of decreasing similarity. How close is your ranking to the order given here, an order that was established experimentally by (Miller & Charles, 1998): \n",
    "\n",
    "car-automobile, gem-jewel, journey-voyage, boy-lad, coast-shore, asylum-madhouse, magician-wizard, midday-noon, furnace-stove, food-fruit, bird-cock, bird-crane, tool-implement, brother-monk, lad-brother, crane-implement, journey-car, monk-oracle, cemetery-woodland, food-rooster, coast-hill, forest-graveyard, shore-woodland, monk-slave, coast-forest, lad-wizard, chord-smile, glass-magician, rooster-voyage, noon-string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "id": "6da844a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {\"car\":\"automobile\", \"gem\":\"jewel\", \"journey\":\"voyage\", \"boy\":\"lad\", \"coast\":\"shore\", \"asylum\":\"madhouse\", \n",
    " \"magician\":\"wizard\", \"midday\":\"noon\", \"furnace\":\"stove\", \"food\":\"fruit\", \"bird\":\"cock\", \"bird\":\"crane\", \n",
    " \"tool\":\"implement\", \"brother\":\"monk\", \"lad\":\"brother\", \"crane\":\"implement\", \"journey\":\"car\", \"monk\":\"oracle\", \"cemetery\":\"woodland\", \n",
    " \"food\":\"rooster\", \"coast\":\"hill\", \"forest\":\"graveyard\", \"shore\":\"woodland\", \"monk\":\"slave\", \"coast\":\"forest\", \"lad\":\"wizard\", \"chord\":\"smile\", \n",
    " \"glass\":\"magician\", \"rooster\":\"voyage\", \"noon\":\"string\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 462,
   "id": "be36eb17",
   "metadata": {},
   "outputs": [],
   "source": [
    "sims = defaultdict(float)\n",
    "for w1, w2 in dict1.items():\n",
    "    sims[(w1, w2)] = wordnet.synsets(w1)[0].path_similarity(wordnet.synsets(w2)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 466,
   "id": "f7b91f5b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('car', 'automobile'),\n",
       " ('midday', 'noon'),\n",
       " ('tool', 'implement'),\n",
       " ('boy', 'lad'),\n",
       " ('lad', 'wizard'),\n",
       " ('monk', 'slave'),\n",
       " ('shore', 'woodland'),\n",
       " ('magician', 'wizard'),\n",
       " ('gem', 'jewel'),\n",
       " ('asylum', 'madhouse'),\n",
       " ('brother', 'monk'),\n",
       " ('bird', 'crane'),\n",
       " ('cemetery', 'woodland'),\n",
       " ('glass', 'magician'),\n",
       " ('crane', 'implement'),\n",
       " ('coast', 'forest'),\n",
       " ('chord', 'smile'),\n",
       " ('furnace', 'stove'),\n",
       " ('forest', 'graveyard'),\n",
       " ('food', 'rooster'),\n",
       " ('noon', 'string'),\n",
       " ('journey', 'car'),\n",
       " ('rooster', 'voyage')]"
      ]
     },
     "execution_count": 466,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(sims, key = sims.get, reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a957651e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27f56408",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}