notebooks/7_WordNet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Accessing WordNet through the NLTK interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">- [Accessing WordNet](#Accessing-WordNet)\n",
    ">\n",
    ">\n",
    ">- [WN-based Semantic Similarity](#WN-based-Semantic-Similarity)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accessing WordNet\n",
    "\n",
    "WordNet 3.0 can be accessed from NLTK by calling the appropriate NLTK corpus reader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import wordnet as wn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieving Synsets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The easiest way to retrieve synsets is by submitting the relevant lemma to the `synsets()` method, that returns the list of all the synsets containing it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Synset('dog.n.01'), Synset('frump.n.01'), Synset('dog.n.03'), Synset('cad.n.01'), Synset('frank.n.02'), Synset('pawl.n.01'), Synset('andiron.n.01'), Synset('chase.v.01')]\n"
     ]
    }
   ],
   "source": [
    "print(wn.synsets('dog'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The optional paramater `pos` allows you to constrain the search to a given part of speech \n",
    "\n",
    "- available options: `wn.NOUN`, `wn.VERB`, `wn.ADJ`, `wn.ADV`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Synset('dog.n.01'), Synset('frump.n.01'), Synset('dog.n.03'), Synset('cad.n.01'), Synset('frank.n.02'), Synset('pawl.n.01'), Synset('andiron.n.01')]\n"
     ]
    }
   ],
   "source": [
    "# let's ignore the verbal synsets from our previous results\n",
    "print(wn.synsets('dog', pos = wn.NOUN))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the `synset()` method together with the notation `lemma.pos.number` (e.g. `dog.n.01`) to access a given synset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a member of the genus Canis (probably descended from the common wolf) that has been domesticated by man since prehistoric times; occurs in many breeds'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# retrive the gloss of a given synset\n",
    "wn.synset('dog.n.01').definition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['the dog barked all night']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's see some examples\n",
    "wn.synset('dog.n.01').examples()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did anyone notice something weird in these results? Why did I get `frank.n.02`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Lemma('frank.n.02.frank'),\n",
       " Lemma('frank.n.02.frankfurter'),\n",
       " Lemma('frank.n.02.hotdog'),\n",
       " Lemma('frank.n.02.hot_dog'),\n",
       " Lemma('frank.n.02.dog'),\n",
       " Lemma('frank.n.02.wiener'),\n",
       " Lemma('frank.n.02.wienerwurst'),\n",
       " Lemma('frank.n.02.weenie')]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# let's retrieve the lemmas associated with a given synset\n",
    "wn.synset('frank.n.02').lemmas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What's the definition?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a smooth-textured sausage of minced beef or pork usually smoked; often served on a bread roll'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('frank.n.02').definition()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The notation `lemmas.pos.number` is used to identify the **name** of the synset, that is the unique id that is used to store it in the semantic resources \n",
    "\n",
    "- note that it is different from the notation used to refer to synset lemmas, e.g. `frank.n.02.frank`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'frank.n.02'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('frank.n.02').name()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Applied to our original query..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('dog.n.01'),\n",
       " Synset('frump.n.01'),\n",
       " Synset('dog.n.03'),\n",
       " Synset('cad.n.01'),\n",
       " Synset('frank.n.02'),\n",
       " Synset('pawl.n.01'),\n",
       " Synset('andiron.n.01')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# synsets for a given word\n",
    "wn.synsets('dog', pos = wn.NOUN)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Lemma('dog.n.01.dog'),\n",
       " Lemma('dog.n.01.domestic_dog'),\n",
       " Lemma('dog.n.01.Canis_familiaris')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# synonyms for a particular meaning of a word\n",
    "wn.synset('dog.n.01').lemmas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a member of the genus Canis (probably descended from the common wolf) that has been domesticated by man since prehistoric times; occurs in many breeds'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.01').definition()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Lemma('dog.n.03.dog')]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.03').lemmas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'informal term for a man'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.03').definition()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q. How are the senses in WordNet ordered?**\n",
    "\n",
    "A. *WordNet senses are ordered using sparse data from semantically tagged text. The order of the senses is given simply so that some of the most common uses are listed above others (and those for which there is no data are randomly ordered). The sense numbers and ordering of senses in WordNet should be considered random for research purposes.*\n",
    "\n",
    "(source: the [FAQ section](https://wordnet.princeton.edu/frequently-asked-questions) of the official WordNet web page)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the method `all_synsets()` allows you to retrieve all the synsets in the resource:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synset('able.a.01')\n",
      "Synset('unable.a.01')\n",
      "Synset('abaxial.a.01')\n",
      "Synset('adaxial.a.01')\n",
      "Synset('acroscopic.a.01')\n",
      "Synset('basiscopic.a.01')\n",
      "Synset('abducent.a.01')\n",
      "Synset('adducent.a.01')\n",
      "Synset('nascent.a.01')\n",
      "Synset('emergent.s.02')\n"
     ]
    }
   ],
   "source": [
    "for synset in list(wn.all_synsets())[:10]:\n",
    "    print(synset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... again, you can use the optional `pos` paramter to constrain your search:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synset('a_cappella.r.01')\n",
      "Synset('ad.r.01')\n",
      "Synset('ce.r.01')\n",
      "Synset('bc.r.01')\n",
      "Synset('bce.r.01')\n",
      "Synset('horseback.r.01')\n",
      "Synset('barely.r.01')\n",
      "Synset('just.r.06')\n",
      "Synset('hardly.r.02')\n",
      "Synset('anisotropically.r.01')\n"
     ]
    }
   ],
   "source": [
    "for synset in list(wn.all_synsets(wn.ADV))[:10]:\n",
    "    print(synset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retrieving Semantic and Lexical Relations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the Nouns sub-net\n",
    "\n",
    "NLTK makes it easy to explore the WordNet hierarchy. The `hyponyms()` method allows you to retrieve all the immediate hyponyms of our target synset "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('basenji.n.01'),\n",
       " Synset('corgi.n.01'),\n",
       " Synset('cur.n.01'),\n",
       " Synset('dalmatian.n.02'),\n",
       " Synset('great_pyrenees.n.01'),\n",
       " Synset('griffon.n.02'),\n",
       " Synset('hunting_dog.n.01'),\n",
       " Synset('lapdog.n.01'),\n",
       " Synset('leonberg.n.01'),\n",
       " Synset('mexican_hairless.n.01'),\n",
       " Synset('newfoundland.n.01'),\n",
       " Synset('pooch.n.01'),\n",
       " Synset('poodle.n.01'),\n",
       " Synset('pug.n.01'),\n",
       " Synset('puppy.n.01'),\n",
       " Synset('spitz.n.01'),\n",
       " Synset('toy_dog.n.01'),\n",
       " Synset('working_dog.n.01')]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.01').hyponyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to move in the opposite direction (i.e. towards more general synsets) we can use:\n",
    "\n",
    "- either the `hypernyms()` method to retrieve the immediate hypernym (or hypernyms in the following case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('canine.n.02'), Synset('domestic_animal.n.01')]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.01').hypernyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- or the `hypernym_paths()` method to retrieve all the hyperonymyc  chain **up to the root node**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[Synset('entity.n.01'),\n",
       "  Synset('physical_entity.n.01'),\n",
       "  Synset('object.n.01'),\n",
       "  Synset('whole.n.02'),\n",
       "  Synset('living_thing.n.01'),\n",
       "  Synset('organism.n.01'),\n",
       "  Synset('animal.n.01'),\n",
       "  Synset('chordate.n.01'),\n",
       "  Synset('vertebrate.n.01'),\n",
       "  Synset('mammal.n.01'),\n",
       "  Synset('placental.n.01'),\n",
       "  Synset('carnivore.n.01'),\n",
       "  Synset('canine.n.02'),\n",
       "  Synset('dog.n.01')],\n",
       " [Synset('entity.n.01'),\n",
       "  Synset('physical_entity.n.01'),\n",
       "  Synset('object.n.01'),\n",
       "  Synset('whole.n.02'),\n",
       "  Synset('living_thing.n.01'),\n",
       "  Synset('organism.n.01'),\n",
       "  Synset('animal.n.01'),\n",
       "  Synset('domestic_animal.n.01'),\n",
       "  Synset('dog.n.01')]]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('dog.n.01').hypernym_paths()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important semantic relation for the nouns sub-net is **meronymy**, that links an object (holonym) with its parts (meronym). There are three semantic relations of this kind in WordNet:\n",
    "\n",
    "\n",
    "- **Part meronymy**: the relation between an object and its separable components:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('burl.n.02'),\n",
       " Synset('crown.n.07'),\n",
       " Synset('limb.n.02'),\n",
       " Synset('stump.n.01'),\n",
       " Synset('trunk.n.01')]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('tree.n.01').part_meronyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Substance meronymy**: the relation between an object and the substance it is made of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('heartwood.n.01'), Synset('sapwood.n.01')]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('tree.n.01').substance_meronyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- **Member meronymy**: the relation between a group and its members "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('forest.n.01')]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('tree.n.01').member_holonyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Instances** do not have hypernyms, but **instance_hypernyms**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('national_capital.n.01')]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# amsterdam is a national capital vs *Amsterdam is a kind of a national capital\n",
    "wn.synset('amsterdam.n.01').instance_hypernyms()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('amsterdam.n.01').hypernyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### the Verbs sub-net\n",
    "\n",
    "Moving in the Verbs sub-net, the **troponymy** relation can be navigated by using the same methods used to navigate the nominal hyperonymyc relations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('rest.v.05')]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('sleep.v.01').hypernyms()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[Synset('lie.v.02'),\n",
       "  Synset('recumb.v.01'),\n",
       "  Synset('rest.v.05'),\n",
       "  Synset('sleep.v.01')]]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('sleep.v.01').hypernym_paths()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The other central relation in the organization of the verbs is the **entailment** one:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('chew.v.01'), Synset('swallow.v.01')]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.synset('eat.v.01').entailments()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Adjective clusters\n",
    "\n",
    "Adjectives are organized in clusters of **satellites** adjectives (labeled as `lemma.s.number`) connected to a central adjective (labeled as `lemma.a.number`) by means of the **similar_to** relation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('fast.a.01')]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a satellite adjective is linked just to one central adjective\n",
    "wn.synset('quick.s.01').similar_tos()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('accelerated.s.01'),\n",
       " Synset('alacritous.s.01'),\n",
       " Synset('blistering.s.03'),\n",
       " Synset('double-quick.s.01'),\n",
       " Synset('express.s.02'),\n",
       " Synset('fast-breaking.s.01'),\n",
       " Synset('fast-paced.s.01'),\n",
       " Synset('fleet.s.01'),\n",
       " Synset('high-speed.s.01'),\n",
       " Synset('hurrying.s.01'),\n",
       " Synset('immediate.s.05'),\n",
       " Synset('instantaneous.s.01'),\n",
       " Synset('meteoric.s.03'),\n",
       " Synset('quick.s.01'),\n",
       " Synset('rapid.s.01'),\n",
       " Synset('rapid.s.02'),\n",
       " Synset('smart.s.06'),\n",
       " Synset('windy.s.03'),\n",
       " Synset('winged.s.02')]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a central adjective is linked to many satellite adjectives\n",
    "wn.synset('fast.a.01').similar_tos()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **lemmas** of the central adjective of each cluster, moreover, are connected to their **antonyms**, that is to lemmas that have the opposite meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Lemma('slow.a.01.slow')]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wn.lemma('fast.a.01.fast').antonyms()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But take note:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "antonymy is a LEXICAL relation, it cannot involve synsets\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    wn.synset('fast.a.01').antonyms()\n",
    "except AttributeError:\n",
    "    print(\"antonymy is a LEXICAL relation, it cannot involve synsets\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WN-based Semantic Similarity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Simulating the human ability to estimate semantic distances between concepts is crucial for:\n",
    "\n",
    "\n",
    "- Psycholinguistics: for long time the study of human semantic memory has been tied to the study of concepts similarity\n",
    "\n",
    "\n",
    "- Natural Language Processing: for any task that requires some sort of semantic comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes of Semantic Distance Measures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Relatedness\n",
    "\n",
    "- two concepts are related if **a relation of any sort** holds between them\n",
    "\n",
    "\n",
    "- information can be extracted from:\n",
    "\n",
    "    - semantic networks\n",
    "    \n",
    "    - dictionaries\n",
    "    \n",
    "    - corpora"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Similarity\n",
    "\n",
    "\n",
    "- it is a special case of relatedness\n",
    "\n",
    "\n",
    "- the relation holding between two concepts **by virtue of their ontological status**, i.e. by virtue of their taxonomic positions (Resnik, 1995)\n",
    "\n",
    "    - car - bicycle\n",
    "    - \\*car - fuel\n",
    "\n",
    "\n",
    "- information can be extracted from\n",
    "\n",
    "    - hierarchical networks\n",
    "    \n",
    "    - taxnomies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WordNet-based Similarity Measures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "dog = wn.synset('dog.n.01')\n",
    "cat = wn.synset('cat.n.01')\n",
    "hit = wn.synset('hit.v.01')\n",
    "slap = wn.synset('slap.v.01')\n",
    "fish = wn.synset('fish.n.01')\n",
    "bird = wn.synset('bird.n.01')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Path Length-based measures\n",
    "\n",
    "\n",
    "These measures are based on $pathlen(c_1, c_2)$: \n",
    "\n",
    "-  i.e. the number of arc in the shorted path connecting two nodes $c_1$ and $c_2$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](images/pathlen.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you can use the `shortest_path_distance()` method to count the number of arcs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fish.shortest_path_distance(bird)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog.shortest_path_distance(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When two notes belongs to different sub-nets, it does not return any values..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(dog.shortest_path_distance(hit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... unless you simulate the existance of a **dummy root** by setting the `simulate_root` option to `True`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(dog.shortest_path_distance(hit, simulate_root = True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is quite handy expecially when working on the **verb sub-net** that **do not have a unique root node** (differently to what happens in the nouns sub-net)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(hit.shortest_path_distance(slap))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(hit.shortest_path_distance(slap, simulate_root = True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Simple Path Length**:\n",
    "\n",
    "$$sim_{simple}(c_1,c_2) = \\frac{1}{pathlen(c_1,c_2) + 1}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "use the `path_similarity()` method to calculate this measure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog.path_similarity(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Leacock & Chodorow (1998)**\n",
    "\n",
    "$$sim_{L\\&C}(c_1,c_2) = -log \\left(\\frac{pathlen(c_1,c_2)}{2 \\times D}\\right)$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where $D$ is the maximum depth of the taxonomy\n",
    "\n",
    "- as a consequence, $2 \\times D$ is the maximum possible pathlen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0281482472922856"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog.lch_similarity(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "you cannot compare synset belonging to different pos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing the lch similarity requires Synset('dog.n.01') and Synset('hit.v.01') to have the same part of speech.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    dog.lch_similarity(hit)\n",
    "except Exception as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Wu & Palmer (1994)\n",
    "\n",
    "This measure is based on the notion of **Least Common Subsumer**\n",
    "\n",
    "-  i.e. the lowest node that dominates both synsets, e.g. `LCS({fish}, {bird}) = {vertebrate, craniate}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](images/lcs.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NLTK allows you to use the `lowest_common_hypernyms()` method to identify the Least Common Subsumer of two nodes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Synset('carnivore.n.01')]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dog.lowest_common_hypernyms(cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If necessary, use option `simulate_root` to simulate the existance onf a dummy root: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Synset('*ROOT*')]\n"
     ]
    }
   ],
   "source": [
    "print(hit.lowest_common_hypernyms(slap, simulate_root = True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wu & Palmer (1998) proposed to measure the semantic simliiarity between concepts by contrasting the depth of the LCS with the depths of the nodes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$sim_{W\\&P(c_1, c_2)} = \\frac{2 \\times depth(LCS(c_1, c_2))}{depth(c_1) + depth(c_2)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where $depth(s)$ is the number of arcs between the root node and the node $s$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the minimum and the maximum depths of each node can be calculated with the `min_depth()` and `max_depth()` modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 13\n"
     ]
    }
   ],
   "source": [
    "print(dog.min_depth(), dog.max_depth())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "...and the `wup_similarity()` (authors' names) method to calculate this measure (option `simulate_root` available)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8571428571428571\n"
     ]
    }
   ],
   "source": [
    "print(dog.wup_similarity(cat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Information Content-based measures\n",
    "\n",
    "- the **Information Content** of a concept $C$ is the probability of a randomly selected word to be an instance of the concept $C$ (i.e. the synset $c$ or one of its hyponyms)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$IC(C) = -log(P(C))$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Following Resnik (1995), corpus frequencies can be used to estimate this probability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$P(C) = \\frac{freq(C)}{N} = \\frac{\\sum_{w \\in words(c)}count(w)}{N}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- $words(c)$ = set of words that are hierarchically included by $C$ (i.e. its hyponyms)\n",
    "\n",
    "\n",
    "- N = number of corpus tokens for which there is a representation in WordNet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A fragment of the WN nominal hierarchy, in which each node has been labeled with its $P(C)$ (from Lin, 1998)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![alt text](images/ic.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Resnik (1995)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$sim_{resnik}(c_1,c_2) = IC(LCS(c_1,c_2)) = -log(P(LCS(c_1,c_2)))$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several Information Content dictionaries are available in NLTK..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import wordnet_ic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the IC estimated from the brown corpus\n",
    "brown_ic = wordnet_ic.ic('ic-brown.dat')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the IC estimated from the semcor\n",
    "semcor_ic = wordnet_ic.ic('ic-semcor.dat')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... or it can be estimated form an available corpus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import genesis\n",
    "genesis_ic = wn.ic(genesis, False, 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that these calculation of the resnick measure depends on the corpus used to generate the information content "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.911666509036577\n",
      "7.2549003421277245\n",
      "7.204023991374837\n"
     ]
    }
   ],
   "source": [
    "print(dog.res_similarity(cat, ic = brown_ic))\n",
    "print(dog.res_similarity(cat, ic = semcor_ic))\n",
    "print(dog.res_similarity(cat, ic = genesis_ic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Lin (1998)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$sim_{lin}(c_1,c_2) = \\frac{log(P(common(c_1,c_2)))}{log(P(description(c_1,c_2)))} = \\frac{2 \\times IC(LCS(c_1,c_2))}{IC(c_1) + IC(c_2)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- $common(c_1,c_2)$ = the information that is common between $c_1$ and $c_2$\n",
    "\n",
    "\n",
    "- $description(c_1,c_2)$ = the information that is needed to describe $c_1$ and $c_2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8768009843733973\n",
      "0.8863288628086228\n",
      "0.8043806652422293\n"
     ]
    }
   ],
   "source": [
    "print(dog.lin_similarity(cat, ic = brown_ic))\n",
    "print(dog.lin_similarity(cat, ic = semcor_ic))\n",
    "print(dog.lin_similarity(cat, ic = genesis_ic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Jiang & Conrath (1997)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$sim_{J\\&C}(c_1,c_2) = \\frac{1}{dist(c_1,c_2)} = \\frac{1}{IC(c_1) + IC(c_2) - 2 \\times IC(LCS(c_1, c_2))}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.4497755285516739\n",
      "0.537382154955756\n",
      "0.28539390848096946\n"
     ]
    }
   ],
   "source": [
    "print(dog.jcn_similarity(cat, ic = brown_ic))\n",
    "print(dog.jcn_similarity(cat, ic = semcor_ic))\n",
    "print(dog.jcn_similarity(cat, ic = genesis_ic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### WordNet-based Relatedness Measures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The Lesk algorithm (1986)\n",
    "\n",
    "\n",
    "- *“how to tell a pine cone from an ice cream cone”*\n",
    "\n",
    "\n",
    "- Lesk's intuition: let's have a look at the dictionary glosses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pine [1]: *kind of **evergreen tree** with needle-shaped leaves*\n",
    "\n",
    "pine [2]: *waste away through sorrow or illness*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "cone [1]: *solid body which narrows to a point*\n",
    "\n",
    "cone [2]: *something of this shape wheter solid or hollow*\n",
    "\n",
    "cone [3]: *fruit of certain **evergreen tree**.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extended Lesk (Banerjee and Pedersen, 2003)\n",
    "\n",
    "Glosses overlap score = sum of $n^2$, where $n$ is the length in words of each locution shared by two glosses "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- in what follows the gloss overlap score is $1^2 + 3^2$\n",
    "\n",
    "`{chest of drawers, chest, bureau, dresser}` : *a **piece of furniture** with drawers for keeping **clothes**.*\n",
    "\n",
    "`{wardrobe, closet, press}` : *a tall **piece of furniture** that provides storage space for **clothes**.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This measure takes into consideration also che glosses of the synsets that are related to the target synsets by one of an apriori specified set of relations RELS:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$sim_{eLesk}(c_1, c_2) = \\sum_{r,q \\in RELS}overlap\\ (gloss(r(c_1)),\\ gloss(q(c_2)))$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Now, here's a challenge for you...\n",
    "\n",
    "Let's suppose you have a list of word pair and that you want to measure their similarity by using WordNet. Your immediate problem is polisemy: a single word may refer to multiple concepts, so that a lemma may appear in more WordNet synsets. \n",
    "\n",
    "**Can you think of a way to deal with this issue** other that relying on some existing WSD tool? (TIP: *can you think of a way of filtering out some senses and/or combining multiple similarity scores in order to derive an unique word pair similarity score?*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}