jupyter/basic_operations_wordnet.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## This demo shows the basic components and operations of the RoWordNet.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "The first operation is to create a wordnet by using the internal resources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import rowordnet\n",
    "wn = rowordnet.RoWordNet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to create a wordnet using your own resources you have to specify a ``filepath`` to the file and whether the file is binary or xml. You can also create an empty wordnet by setting the parameter ``empty`` to ``True``.\n",
    "\n",
    "Now that we have created a wordnet we can search for words. This action will return one or more synsets(the main component of a wordnet - see the synset/relation creation and editing for more details). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of synsets containing literal 'arbore': 20\n",
      "['ENG30-08102402-n', 'ENG30-12339526-n', 'ENG30-03726760-n', 'ENG30-13912260-n', 'ENG30-12752039-n', 'ENG30-13104059-n', 'ENG30-02946824-n', 'ENG30-12402840-n', 'ENG30-12690653-n', 'ENG30-12662772-n', 'ENG30-03127408-n', 'ENG30-11712282-n', 'ENG30-11704791-n', 'ENG30-11640132-n', 'ENG30-12334293-n', 'ENG30-03244231-n', 'ENG30-04472563-n', 'ENG30-04111190-n', 'ENG30-13111174-n', 'ENG30-04316924-n']\n"
     ]
    }
   ],
   "source": [
    "word = 'arbore'\n",
    "synset_ids = wn.synsets(literal=word)\n",
    "print(\"Total number of synsets containing literal '{}': {}\".format(word, len(synset_ids)))\n",
    "print(synset_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To print a detalied information of a synset we use the ``print_synset`` and provide the synset id."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synset: \n",
      "\t  id=ENG30-12752039-n\n",
      "\t  pos=NOUN\n",
      "\t  nonlexicalized=None\n",
      "\t  stamp=None\n",
      "\t  domain=biology\n",
      "\t  definition=Expresie : (Aceraceae); arbore sau arbust din acest gen;\n",
      "\t  sumo=FloweringPlant \n",
      "\t  sumoType=HYPERNYM\n",
      "\t  sentiwn=[0.0, 0.0, 1.0]\n",
      "\t  Literals:\n",
      "\t\t  arbore - 2.6\n",
      "\t\t  arbust - 3.1\n",
      "\t  Outbound relations: \n",
      "\t\t  ENG30-11567411-n - hypernym\n",
      "\t\t  ENG30-12752205-n - member_meronym\n",
      "\t  Inbound relations: \n",
      "\t\t  ENG30-12752666-n - substance_holonym\n",
      "\t\t  ENG30-13109733-n - hyponym\n",
      "\t\t  ENG30-12752039-n - member_meronym\n",
      "\t\t  ENG30-12753573-n - hypernym\n",
      "\t\t  ENG30-12754003-n - hypernym\n",
      "\t\t  ENG30-12755225-n - hypernym\n"
     ]
    }
   ],
   "source": [
    "synset_id = synset_ids[4]\n",
    "wn.print_synset(synset_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To obtain a synset object we simply use ``wn.synset()`` with the synset id as a paramater. We can also obtain the synset object by using ``wn()`` directly and passing the synset id as a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synset(id='ENG30-12752039-n', literals=['arbore', 'arbust'], definition='Expresie : (Aceraceae); arbore sau arbust din acest gen;')\n",
      "Synset(id='ENG30-12752039-n', literals=['arbore', 'arbust'], definition='Expresie : (Aceraceae); arbore sau arbust din acest gen;')\n"
     ]
    }
   ],
   "source": [
    "synset_object = wn.synset(synset_id)\n",
    "print(synset_object)\n",
    "synset_object = wn(synset_id)\n",
    "print(synset_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every synset has a set of words called 'literals'. We can acces them by using the property ``literals`` of a synset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Synset with id ENG30-12752039-n has 2 literals: ['arbore', 'arbust']\n"
     ]
    }
   ],
   "source": [
    "literals = synset_object.literals\n",
    "print(\"Synset with id {} has {} literals: {}\".format(synset_object.id, len(literals), literals))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have accesed the ``literals`` of a synset, we can acces and modify any property(WARNING: You can't modify the ``id``). Now let's try to acces and modify the ``definition`` property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defitionion of the synset with id ENG30-12752039-n: Expresie : (Aceraceae); arbore sau arbust din acest gen;\n",
      "New definition of the synset with id ENG30-12752039-n: This is a new defition\n"
     ]
    }
   ],
   "source": [
    "definition = synset_object.definition\n",
    "print(\"Defitionion of the synset with id {}: {}\".format(synset_object.id, definition))\n",
    "new_definition = \"This is a new defition\"\n",
    "synset_object.definition = new_definition\n",
    "print(\"New definition of the synset with id {}: {}\".format(synset_object.id, synset_object.definition))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Function with ``wn.synsets()`` will return a list containing all the synset ids of the wordnet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of synsets: 59348 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "synsets_id = wn.synsets()\n",
    "print(\"Total number of synsets: {} \\n\".format(len(synsets_id)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are 4 types of parts of speech in RoWordNet : Nouns, Verbs, Adjectives and Adverbs. To filter the synsets you have to provide a part of speech to the ``pos`` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of noun synsets: 41063\n",
      "Total number of verb synsets: 10397\n",
      "Total number of adjective synsets: 4822\n",
      "Total number of adverb synsets: 3066\n"
     ]
    }
   ],
   "source": [
    "from rowordnet import Synset\n",
    "\n",
    "# return all noun synsets\n",
    "synsets_id_nouns = wn.synsets(pos=Synset.Pos.NOUN)\n",
    "print(\"Total number of noun synsets: {}\".format(len(synsets_id_nouns)))\n",
    "# return all verb synsets\n",
    "synsets_id_verbs = wn.synsets(pos=Synset.Pos.VERB)\n",
    "print(\"Total number of verb synsets: {}\".format(len(synsets_id_verbs)))\n",
    "# return all adjective synsets\n",
    "synsets_id_adjectives = wn.synsets(pos=Synset.Pos.ADJECTIVE)\n",
    "print(\"Total number of adjective synsets: {}\".format(len(synsets_id_adjectives)))\n",
    "# return all adverb synsets\n",
    "synsets_id_adverbs = wn.synsets(pos=Synset.Pos.ADVERB)\n",
    "print(\"Total number of adverb synsets: {}\".format(len(synsets_id_adverbs)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We continue with examples of navigating in the wordnet\n",
    "\n",
    "Synsets are linked by relations, encoded as directed edges in a graph. To see all the relations type between by accesing the ``relation_types`` property of the wordnet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This wordnet contains 35 relation types\n"
     ]
    }
   ],
   "source": [
    "print(\"This wordnet contains {} relation types\".format(len(wn.relation_types)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every synset has a number of synsets that it points to (outbound relations) and a set of synsets that point to it (inbound relations). We can acces these synsets and the relations between them by using the functions ``outbound_relations`` and ``inbound_relations``, respectively. We can also access both the inbound and outbound relations of synset through ``relations`` function. Note that the ``relations`` function looses directionality as it is simply a concatenation of the inbound+outbound relations - it is used more as a convenience for printing rather than for operations or search in the word net."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Print all outbound relations of synset with id ENG30-03431745-n\n",
      "\tRelation [hypernym] to synset ENG30-04576971-n\n",
      "\tRelation [part_holonym] to synset ENG30-03287733-n\n",
      "\n",
      "Print all outbound relations of synset with id ENG30-03431745-n\n",
      "\tRelation [hyponym] from synset ENG30-04576971-n\n",
      "\tRelation [part_meronym] from synset ENG30-03287733-n\n",
      "\n",
      "The synset has 4 total relations.\n"
     ]
    }
   ],
   "source": [
    "# print all outbound relations of a synset\n",
    "synset_id = wn.synsets(\"tren\")[0]\n",
    "print(\"Print all outbound relations of synset with id {}\".format(synset_id))\n",
    "outbound_relations = wn.outbound_relations(synset_id)\n",
    "for outbound_relation in outbound_relations:\n",
    "    target_synset_id = outbound_relation[0]        \n",
    "    relation = outbound_relation[1]\n",
    "    print(\"\\tRelation [{}] to synset {}\".format(relation, target_synset_id))\n",
    "    \n",
    "# print all inbound relations of a synset\n",
    "print(\"\\nPrint all outbound relations of synset with id {}\".format(synset_id))    \n",
    "for source_synset_id, relation in wn.inbound_relations(synset_id):\n",
    "    print(\"\\tRelation [{}] from synset {}\".format(relation, source_synset_id))\n",
    "\n",
    "# get all relations of the same synset   \n",
    "relations = wn.relations(synset_id)\n",
    "print(\"\\nThe synset has {} total relations.\".format(len(relations)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To travel through the wordnet you use ``bfswalk()`` by providing a synset id as a starting location. This function ``yields`` a generator that can be further used to travel through the worndet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\tTravel breadth-first through wordnet starting with synset 'ENG30-02377703-n' (first 10 synsets) ...\n",
      "\t\t Step 1: from synset ENG30-02377703-n, with relation [hypernym] to synset ENG30-02374451-n\n",
      "\t\t Step 2: from synset ENG30-02377703-n, with relation [near_eng_derivat] to synset ENG30-01923414-v\n",
      "\t\t Step 3: from synset ENG30-02377703-n, with relation [hyponym] to synset ENG30-02378415-n\n",
      "\t\t Step 4: from synset ENG30-02377703-n, with relation [hyponym] to synset ENG30-02379908-n\n",
      "\t\t Step 5: from synset ENG30-02377703-n, with relation [hyponym] to synset ENG30-02381004-n\n",
      "\t\t Step 6: from synset ENG30-02374451-n, with relation [hypernym] to synset ENG30-02374149-n\n",
      "\t\t Step 7: from synset ENG30-02374451-n, with relation [member_holonym] to synset ENG30-02373843-n\n",
      "\t\t Step 8: from synset ENG30-02374451-n, with relation [part_meronym] to synset ENG30-01899894-n\n",
      "\t\t Step 9: from synset ENG30-02374451-n, with relation [part_meronym] to synset ENG30-01902274-n\n",
      "\t\t Step 10: from synset ENG30-02374451-n, with relation [hyponym] to synset ENG30-02375302-n\n"
     ]
    }
   ],
   "source": [
    "# get a new synset\n",
    "new_synset_id = wn.synsets(\"cal\")[2]\n",
    "# travel the graph Breadth First \n",
    "counter = 0\n",
    "print(\"\\n\\tTravel breadth-first through wordnet starting with synset '{}' (first 10 synsets) ...\"\n",
    "      .format(new_synset_id))\n",
    "for current_synset_id, relation, from_synset_id in wn.bfwalk(new_synset_id):\n",
    "    counter += 1\n",
    "    # bfwalk is a generator that yields, for each call, a BF step through wordnet \n",
    "    # you do actions with current_synset_id, relation, from_synset_id\n",
    "    print(\"\\t\\t Step {}: from synset {}, with relation [{}] to synset {}\"\n",
    "          .format(counter, from_synset_id, relation, current_synset_id))\n",
    "    if counter >= 10:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Being represented as a graph where the nodes are the synset ids and the edges are the relations between them, you can calculate the shortest distance between two synsets with ``shortest_path``. You can additionally provide a filter to this function and the shortest distance will be calculated following the specified relations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List of synsets containing the shortest path from synset with id 'ENG30-02377703-n' to synset with id 'ENG30-02324045-n': \n",
      "['ENG30-02377703-n', 'ENG30-02374451-n', 'ENG30-02462602-n', 'ENG30-02430045-n', 'ENG30-02158739-n', 'ENG30-02324045-n']\n",
      "\n",
      "List of synsets containing the shortest filtered path from synset with id 'ENG30-02377703-n' to synset with id 'ENG30-02324045-n': \n",
      "['ENG30-02377703-n', 'ENG30-02374451-n', 'ENG30-02374149-n', 'ENG30-02373336-n', 'ENG30-02370806-n', 'ENG30-01886756-n', 'ENG30-02323449-n', 'ENG30-02323902-n', 'ENG30-02324045-n']\n"
     ]
    }
   ],
   "source": [
    "# shortest path unfiltered\n",
    "synset1_id = wn.synsets(\"cal\")[2]\n",
    "synset2_id = wn.synsets(\"iepure\")[0]    \n",
    "distance = wn.shortest_path(synset1_id, synset2_id)\n",
    "print(\"List of synsets containing the shortest path from synset with id '{}' to synset with id '{}': \"\n",
    "      .format(synset1_id, synset2_id))\n",
    "print(\"{}\".format(distance))\n",
    "\n",
    "# shortest path filtered with 'hypernym' and 'hyponym' relations\n",
    "relations = set(['hypernym', 'hyponym'])\n",
    "filtered_distance = wn.shortest_path(synset1_id, synset2_id, relations)\n",
    "print(\"\\nList of synsets containing the shortest filtered path from synset with id '{}' to synset with id '{}': \"\n",
    "      .format(synset1_id, synset2_id))\n",
    "print(\"{}\".format(filtered_distance))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There's a special set of relations(hyponym and hypernym) that create what's called the hypernym tree. This tree ilustrates the relations of type \"is a\". For instance, 'flower' is a 'plant'. We have provided several functions that interact with this tree like printing the lowest common ancestor of two synsets or print the path to root starting from a synset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The lowest common ancestor in the hypernym tree of synset ENG30-02377703-n and ENG30-02324045-n is ENG30-01886756-n\n",
      "\n",
      "List of synset ids from synset with id 'ENG30-00006269-n' up to its root in the hypermyn tree: \n",
      "['ENG30-00006269-n', 'ENG30-00004258-n', 'ENG30-00003553-n', 'ENG30-00002684-n']\n"
     ]
    }
   ],
   "source": [
    "# get the lowest common ancestor in the hypernym tree\n",
    "synset1_id = wn.synsets(\"cal\")[2]\n",
    "synset2_id = wn.synsets(\"iepure\")[0]\n",
    "synset_id = wn.lowest_hypernym_common_ancestor(synset1_id, synset2_id)\n",
    "print(\"The lowest common ancestor in the hypernym tree of synset {} and {} is {}\".format(synset1_id, synset2_id, synset_id))\n",
    "\n",
    "# get the path from a given synset to its root in hypermyn tree\n",
    "synset_id = wn.synsets()[0]\n",
    "print(\"\\nList of synset ids from synset with id '{}' up to its root in the hypermyn tree: \".format(synset_id))\n",
    "print(\"{}\".format(wn.synset_to_hypernym_root(synset_id)))"
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}