2_SynonymExtraction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import bs4\n",
    "import re\n",
    "import mysql.connector\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from frenetic import *\n",
    "\n",
    "# French WordNet for getting synonyms\n",
    "fwn = FreNetic(\"./frenetic/wolf-1.0b4.xml\")\n",
    "\n",
    "\n",
    "def getCnrtl(word):\n",
    "\n",
    "    response=requests.get(\"https://www.cnrtl.fr/synonymie/\"+word)\n",
    "    content=response.content\n",
    "\n",
    "    parser = bs4.BeautifulSoup(content, 'html.parser')\n",
    "       \n",
    "    syno_format = parser.find_all(\"h2\")\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "    for item in syno_format:\n",
    "        if (\"Terme introuvable\" in item) or (\"Erreur\" in item) :\n",
    "            return ([])\n",
    "     \n",
    "    \n",
    "    syno_format = parser.find_all(\"td\",class_=\"syno_format\")\n",
    "\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "\n",
    "    syno_format=syno_format.str.extract(\"(\\w+)</a></td>\")\n",
    "\n",
    "    syno_format.columns=[\"Synonym\"]\n",
    "    syno_format[\"Frequency\"]=\"\"\n",
    "\n",
    "    img_format_1 = parser.find_all(\"img\",alt=\"\",height=re.compile(\"\\d+\"),src=re.compile(\"/images/portail/pbon.png\"))\n",
    "    img_format_2 = parser.find_all(\"img\",alt=\"\",height=re.compile(\"\\d+\"),src=re.compile(\"/images/portail/pboff.png\"))\n",
    "\n",
    "    img_format_1=pd.Series(img_format_1).apply(str)\n",
    "    img_format_2=pd.Series(img_format_2).apply(str)\n",
    "\n",
    "    img_format_1=img_format_1.str.extract(\"width=\\\"(\\d+)\\\"\").astype('int64')\n",
    "    img_format_2=img_format_2.str.extract(\"width=\\\"(\\d+)\\\"\").astype('int64')\n",
    "\n",
    "\n",
    "    syno_format[\"Frequency\"]=img_format_1/(img_format_1+img_format_2)*100\n",
    "    return list(syno_format[\"Synonym\"])\n",
    "\n",
    "\n",
    "\n",
    "def getSynonymo(word):\n",
    "\n",
    "    response=requests.get(\"http://www.synonymo.fr/synonyme/\"+word)\n",
    "    content=response.content\n",
    "\n",
    "    parser = bs4.BeautifulSoup(content, 'html.parser')\n",
    "    \n",
    "    \n",
    "    syno_format = parser.find_all(\"h1\")\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "    for item in syno_format:\n",
    "        if (\"Aucun résultat exact n'a été trouvé\" in item) or (\"Aucun résultat pour\" in item) or (\"An Error Was Encountered\" in item):\n",
    "            return ([])\n",
    "    \n",
    "\n",
    "    syno_format = parser.find_all(\"a\", class_=\"word\",title=re.compile(\"\\w+\"))\n",
    "\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "\n",
    "    syno_format=syno_format.str.extract(\">([\\w\\s]+)</a>\")\n",
    "    syno_format.columns=[\"Synonym\"]\n",
    "\n",
    "    return list(syno_format[\"Synonym\"])\n",
    "\n",
    "def getCrisco(word):\n",
    "    \n",
    "    response=requests.get(\"http://www.crisco.unicaen.fr/des/synonymes/\"+word)\n",
    "    content=response.content\n",
    "\n",
    "    parser = bs4.BeautifulSoup(content, 'html.parser')\n",
    "    \n",
    "    \n",
    "    syno_format = parser.find_all(\"p\")\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "    for item in syno_format:\n",
    "        if \"ne possède pas de synonyme dans le DES\" in item:\n",
    "            return ([])\n",
    "    \n",
    "\n",
    "    syno_format = parser.find_all(\"a\", href=re.compile(\"/des/synonymes/\\w+\"))\n",
    "\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "\n",
    "    syno_format=syno_format.str.extract(\">\\xa0(\\w+)\\xa0\")\n",
    "    syno_format.columns=[\"Synonym\"]\n",
    "    syno_format=syno_format.dropna()\n",
    "    syno_format=syno_format.reset_index(drop=True)\n",
    "\n",
    "    return list(syno_format[\"Synonym\"])\n",
    "\n",
    "\n",
    "def getJDM(word):\n",
    "    \n",
    "    restricted_words=[\"\\\\\",\"\\'\"]\n",
    "\n",
    "    def remove_refinements(term):\n",
    "        index=term.find('>')\n",
    "\n",
    "        if index==-1:\n",
    "            return term\n",
    "        else:\n",
    "            return (term[0:index])\n",
    "\n",
    "    if word in restricted_words:\n",
    "        return pd.DataFrame(columns = ['Synonym','Weight'])\n",
    "    else:\n",
    "        config = {\n",
    "        'user': 'mirzapour',\n",
    "        'password': 'mehdim',\n",
    "        'host': 'karadoc.lirmm.fr',\n",
    "        'database': '05012019_rezojdm',\n",
    "        'raise_on_warnings': True\n",
    "         }\n",
    "\n",
    "        jdm_db = mysql.connector.connect(**config)\n",
    "\n",
    "        jdm_cursor = jdm_db.cursor()\n",
    "        jdm_cursor.execute((\"select n2.name, e.weight from nodes n1, nodes n2,\"+\n",
    "                         \"edges e where n1.name='\"+word+\"' and n1.id=e.source\"+\n",
    "                         \" and n2.id=e.destination and e.type=5\"))\n",
    "\n",
    "\n",
    "        df_syn=pd.DataFrame(jdm_cursor.fetchall(),columns=['Synonym','Weight'])\n",
    "        df_syn.sort_values(by=[\"Weight\"], axis=0, ascending=False, inplace=True)\n",
    "\n",
    "        jdm_db.close()\n",
    "\n",
    "\n",
    "        df_syn=df_syn[df_syn[\"Weight\"]>=25]\n",
    "        df_syn=df_syn[~df_syn[\"Synonym\"].str.contains(\"=\")]\n",
    "        df_syn[\"Synonym\"]=df_syn[\"Synonym\"].apply(remove_refinements)\n",
    "\n",
    "        df_syn.sort_values(by=[\"Synonym\",\"Weight\"], axis=0, ascending=False, inplace=True)\n",
    "        df_syn = df_syn.drop_duplicates(subset='Synonym', keep='first')\n",
    "\n",
    "        df_syn.sort_values(by=[\"Weight\"], axis=0, ascending=False, inplace=True)\n",
    "        return df_syn\n",
    "\n",
    "\n",
    "def getJDM_Sense_Table(word):\n",
    "\n",
    "\n",
    "    def keep_refinements(term):\n",
    "            index=term.find('>')\n",
    "\n",
    "            if index==-1:\n",
    "                return term\n",
    "            else:\n",
    "                return (term[index+1:])\n",
    "\n",
    "    config = {\n",
    "            'user': 'mirzapour',\n",
    "            'password': 'mehdim',\n",
    "            'host': 'karadoc.lirmm.fr',\n",
    "            'database': '05012019_rezojdm',\n",
    "            'raise_on_warnings': True\n",
    "             }\n",
    "\n",
    "    jdm_db = mysql.connector.connect(**config)\n",
    "\n",
    "    jdm_cursor = jdm_db.cursor()\n",
    "\n",
    "    jdm_cursor.execute((\"select n1.name, e.weight, n2.name from nodes n1, nodes n2,\"+\n",
    "                             \"edges e where n1.name='\"+word+\"' and n1.id=e.source\"+\n",
    "                             \" and n2.id=e.destination and e.type=1\"))\n",
    "\n",
    "    df_syn=pd.DataFrame(jdm_cursor.fetchall(),columns=['Word','Sense_Weight','Sense_JDM'])\n",
    "    df_syn.sort_values(by=[\"Sense_Weight\"], axis=0, ascending=False, inplace=True)\n",
    "    df_syn.reset_index(drop=True, inplace=True)\n",
    "\n",
    "\n",
    "    df_syn.insert(loc=1,column=\"Sense_Name\",value=\"\")\n",
    "\n",
    "    for counter,value in enumerate(df_syn[\"Sense_JDM\"].apply(keep_refinements)):\n",
    "        jdm_cursor.execute(\"SELECT name FROM nodes where id=\"+ str(value))\n",
    "        fetch_result=jdm_cursor.fetchall()[0][0]\n",
    "        df_syn[\"Sense_Name\"][counter]=fetch_result\n",
    "\n",
    "\n",
    "    # We can use the \"df_syn\" for all senses of a given word   \n",
    "\n",
    "    table_main = pd.DataFrame(columns=[\"Word\",\"Sense\",\"Sense_Weight\",\"Syn_Weight\"])\n",
    "\n",
    "    for item in range(0,len(df_syn)): \n",
    "\n",
    "        table=getJDM(list(df_syn[\"Sense_JDM\"])[item])\n",
    "\n",
    "        table.insert(loc=0,column=\"Sense\",value=\"\")\n",
    "        table[\"Sense\"]=df_syn[\"Sense_Name\"][item]\n",
    "\n",
    "        table.insert(loc=0,column=\"Word\",value=\"\")\n",
    "        table[\"Word\"]=word\n",
    "\n",
    "        table.insert(loc=3,column=\"Sense_Weight\",value=\"\")\n",
    "        table[\"Sense_Weight\"]=df_syn[\"Sense_Weight\"][item]\n",
    "        table_main = pd.concat([table_main, table],sort=False)\n",
    "\n",
    "    return (table_main)\n",
    "\n",
    "\n",
    "def getJDM_Sense(word):\n",
    "    jdm_sense_table=getJDM_Sense_Table(word)\n",
    "    jdm_sense_table=jdm_sense_table.drop([\"Syn_Weight\"], axis=1)\n",
    "    \n",
    "    if len(jdm_sense_table)==0:\n",
    "        return (np.NaN)\n",
    "    else:\n",
    "        return list(jdm_sense_table[\"Synonym\"])\n",
    "\n",
    "    \n",
    "def getJDM_Sense_dic(word):    \n",
    "    \n",
    "    syn_list=getJDM_Sense_Table(word) \n",
    "    \n",
    "    if (len(syn_list)==0):\n",
    "        return (np.NaN)\n",
    "    else:\n",
    "        syn_list=syn_list[[\"Sense\",\"Synonym\"]]\n",
    "\n",
    "        syn_dic={}\n",
    "        for i in range(len(syn_list)):\n",
    "            if not syn_list.iloc[i][\"Sense\"] in syn_dic.keys():\n",
    "                syn_dic[syn_list.iloc[i][\"Sense\"]]=[syn_list.iloc[i][\"Synonym\"]]\n",
    "            else:\n",
    "                syn_dic[syn_list.iloc[i][\"Sense\"]].append(syn_list.iloc[i][\"Synonym\"])\n",
    "\n",
    "        syn_index=0\n",
    "        syn_dic_changed_2_num={}\n",
    "\n",
    "        for i in syn_dic:\n",
    "            syn_dic[i].insert(0,i)\n",
    "            syn_dic_changed_2_num[syn_index]=syn_dic[i]\n",
    "            syn_index+=1\n",
    "\n",
    "        return(syn_dic_changed_2_num)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def getFrWordnet(str):\n",
    "    \n",
    "    if str==\"\":\n",
    "        return ([])\n",
    "    else:\n",
    "        \n",
    "        try:\n",
    "            nsynsets = fwn.synsets(str)\n",
    "        except:\n",
    "            return ([])\n",
    "\n",
    "        synonym_list=[]\n",
    "        for i,syn in enumerate(nsynsets):\n",
    "            for j,lit in enumerate(syn.literals()):\n",
    "                synonym_list.append(lit.span())\n",
    "    \n",
    "        synonym_list = list(dict.fromkeys(synonym_list))\n",
    "    \n",
    "        return (synonym_list)\n",
    "\n",
    "\n",
    "def getDicSyn(word):\n",
    "    word=word.replace(\"é\",\"%E9\")\n",
    "    word=word.replace(\"è\",\"%E8\")\n",
    "    word=word.replace(\"î\",\"%EE\")\n",
    "    word=word.replace(\"û\",\"%FB\")\n",
    "    word=word.replace(\"ô\",\"%F4\")\n",
    "    word=word.replace(\"ç\",\"%E7\")   \n",
    "   \n",
    "    try:\n",
    "        response=requests.get(\"http://www.dictionnaire-synonymes.com/synonyme.php?mot=\"+word)\n",
    "    except:\n",
    "        return (np.NaN)\n",
    "    print(\"http://www.dictionnaire-synonymes.com/synonyme.php?mot=\"+word)\n",
    "    content=response.content\n",
    "\n",
    "    parser = bs4.BeautifulSoup(content, 'html.parser')\n",
    "\n",
    "    syno_format = parser.find_all(\"td\",class_=\"text1\")\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "    for item in syno_format:\n",
    "        if (\"Veuillez vérifiez l'orthographe de votre requête\" in item):\n",
    "            return (np.NaN)\n",
    "\n",
    "    syno_format = parser.find_all(\"a\",class_=[\"lien2\",\"lien3\"])\n",
    "    syno_format=pd.Series(syno_format)\n",
    "    syno_format=syno_format.apply(str)\n",
    "\n",
    "    syno_format=syno_format.str.extract(\"class=\\\"(\\w+)\\\"[\\s\\w]+=\\\"\\w+.\\w+\\?\\w+=[\\w%+]+\\\">([\\w\\s]+)\")\n",
    "    \n",
    "    syno_format.dropna(inplace=True)\n",
    "    syno_format.reset_index(inplace=True,drop=True)\n",
    "\n",
    "    syn_dic={}\n",
    "    syn_index=0\n",
    "    for i in range(len(syno_format[0])):\n",
    "        if syno_format[0][i]==\"lien2\":\n",
    "            syn_dic[syn_index]=[syno_format[1][i]]\n",
    "            syn_index+=1\n",
    "        else:\n",
    "            syn_dic[syn_index-1].append(syno_format[1][i])\n",
    "        \n",
    "    return(syn_dic)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words_table=pd.read_excel(\n",
    "    \"./excels/2_Phase3_Word_Sense_Extraction.xlsx\")\n",
    "\n",
    "for counter,value in enumerate(words_table[\"Word_Corrected\"]):\n",
    "    \n",
    "    words_table[\"JDM_Sense\"][counter]=str(getJDM_Sense_dic(value))\n",
    "    words_table[\"JDM\"][counter]=list(getJDM(value)[\"Synonym\"])\n",
    "    words_table[\"WordNet\"][counter]=getFrWordnet(value)\n",
    "    words_table[\"Cnrtl\"][counter]=getCnrtl(value)\n",
    "    words_table[\"Synonymo\"][counter]=getSynonymo(value)\n",
    "    words_table[\"Cisco\"][counter]=getCrisco(value)\n",
    "    words_table[\"DicSyn_Sense\"][counter]=str(getDicSyn(value))\n",
    "\n",
    "    print(counter)\n",
    "    words_table.to_excel(\"./excels/2_Phase3_Word_Sense_Extraction.xlsx\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "words_table=pd.read_excel(\n",
    "    \"./excels/2_Phase3_Word_Sense_Extraction.xlsx\")\n",
    "\n",
    "feature_lists=[\"JDM_Sense\",\"JDM\",\"WordNet\",\"Cnrtl\",\"Synonymo\",\"Cisco\",\"DicSyn_Sense\"]\n",
    "\n",
    "words_table=words_table[feature_lists]\n",
    "words_table.fillna(\"[]\", inplace=True)\n",
    "\n",
    "statistic={}\n",
    "for col in words_table.columns:\n",
    "    statistic[col]=100*((len(words_table)-len(words_table[col][words_table[col]==\"[]\"]))/len(words_table))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "\n",
    "statistic[\"DicSyn\"] = statistic.pop(\"DicSyn_Sense\")\n",
    "plt.bar(statistic.keys(), statistic.values())\n",
    "\n",
    "plt.ylabel('Percentage')\n",
    "plt.title('Availability of Synonyms in Different Sources')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}