Ajout d'un format de poids dans nltk
This commit is contained in:
parent
84e9f74c3a
commit
7474b8cdb3
GPG Key ID:
7054D5D6A90F084F
Binary file not shown.
@ -21,7 +21,7 @@ Le chat la mange avec ses dents
|
|||||||
Avec quoi le chat mange la souris ?
|
Avec quoi le chat mange la souris ?
|
||||||
Le rat donne un fromage à la souris
|
Le rat donne un fromage à la souris
|
||||||
Un fromage est donné par le rat à la souris
|
Un fromage est donné par le rat à la souris
|
||||||
A quelle souris un fromage est donné par le rat ?
|
À quelle souris un fromage est donné par le rat ?
|
||||||
Il le donne à la souris
|
Il le donne à la souris
|
||||||
Il le lui donne
|
Il le lui donne
|
||||||
Il souhaite que mon voisin lui donne le chat
|
Il souhaite que mon voisin lui donne le chat
|
||||||
|
|||||||
853
test.ipynb
Normal file
853
test.ipynb
Normal file
@ -0,0 +1,853 @@
|
|||||||
|
{
|
||||||
|
"cells": [
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 1,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"from nltk.ccg import chart, lexicon\n",
|
||||||
|
"from nltk.ccg.lexicon import CCGLexicon, Token, augParseCategory\n",
|
||||||
|
"from nltk.ccg.chart import CCGChart,CCGLeafEdge\n",
|
||||||
|
"from nltk.tree import Tree\n",
|
||||||
|
"import pandas as pd\n",
|
||||||
|
"import numpy as np"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"# Weighed Lexicon"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 2,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"from warnings import warn\n",
|
||||||
|
"\n",
|
||||||
|
"class WeighedToken(Token):\n",
|
||||||
|
" def __init__(self, token, categ, semantics=None, weight = 1.0):\n",
|
||||||
|
" super().__init__(token, categ, semantics= semantics)\n",
|
||||||
|
" self._weight = weight\n",
|
||||||
|
" def weight(self):\n",
|
||||||
|
" \"\"\"1.0 is considered the default weight for any token\"\"\"\n",
|
||||||
|
" try:\n",
|
||||||
|
" return self._weight\n",
|
||||||
|
" except AttributeError:\n",
|
||||||
|
" warn(f\"[{self.token} : {str(self)}] : this token has no weight attribute, defaulted to 1.0.\")\n",
|
||||||
|
" return 1.0\n",
|
||||||
|
"\n",
|
||||||
|
"class WeighedLexicon(CCGLexicon):\n",
|
||||||
|
" def __init__(self, start, primitives, families, entries):\n",
|
||||||
|
" super().__init__(start, primitives, families, entries)\n",
|
||||||
|
"\n",
|
||||||
|
" def weight(self, entry):\n",
|
||||||
|
" return entry.weight()"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"# CYK"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 3,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"valz = {\n",
|
||||||
|
" '>' : 0.8,\n",
|
||||||
|
" '<' : 0.7\n",
|
||||||
|
"}\n",
|
||||||
|
"def rweight(rule):\n",
|
||||||
|
" s = rule.__str__()\n",
|
||||||
|
" if s in valz:\n",
|
||||||
|
" return valz[s]\n",
|
||||||
|
" else:\n",
|
||||||
|
" return 1.0 # Base rules weight\n",
|
||||||
|
"\n",
|
||||||
|
"# Implements the CYK algorithm, code partly taken from nltk\n",
|
||||||
|
"def weightedParse(tokens, lex, rules):\n",
|
||||||
|
" \"\"\"made to take weighed tokens and lexicons\"\"\"\n",
|
||||||
|
" chart = CCGChart(list(tokens))\n",
|
||||||
|
" \n",
|
||||||
|
" # Initialize leaf edges.\n",
|
||||||
|
" for index in range(chart.num_leaves()):\n",
|
||||||
|
" for token in lex.categories(chart.leaf(index)):\n",
|
||||||
|
" new_edge = CCGLeafEdge(index, token, chart.leaf(index))\n",
|
||||||
|
" new_edge.weight = token.weight()\n",
|
||||||
|
" chart.insert(new_edge, ())\n",
|
||||||
|
"\n",
|
||||||
|
" # Select a span for the new edges\n",
|
||||||
|
" for span in range(2, chart.num_leaves() + 1):\n",
|
||||||
|
" for start in range(0, chart.num_leaves() - span + 1):\n",
|
||||||
|
" \n",
|
||||||
|
" bestedge = None\n",
|
||||||
|
" \n",
|
||||||
|
" # Try all possible pairs of edges that could generate\n",
|
||||||
|
" # an edge for that span\n",
|
||||||
|
" for part in range(1, span):\n",
|
||||||
|
" lstart = start\n",
|
||||||
|
" mid = start + part\n",
|
||||||
|
" rend = start + span\n",
|
||||||
|
"\n",
|
||||||
|
" for left in chart.select(span=(lstart, mid)):\n",
|
||||||
|
" for right in chart.select(span=(mid, rend)):\n",
|
||||||
|
" # Generate all possible combinations of the two edges\n",
|
||||||
|
" for rule in rules:\n",
|
||||||
|
" edgez = list(rule.apply(chart, lex, left, right))\n",
|
||||||
|
" if(len(edgez)==1):\n",
|
||||||
|
" edge = edgez[0]\n",
|
||||||
|
" edge.weight = rweight(rule) * left.weight * right.weight\n",
|
||||||
|
" edge.triple = (rule,left,right)\n",
|
||||||
|
" if (bestedge == None) or (bestedge.weight < edge.weight):\n",
|
||||||
|
" bestedge = edge\n",
|
||||||
|
" elif(len(edgez)!=0):\n",
|
||||||
|
" print(\"Too many new edges (unsupported rule used)\")\n",
|
||||||
|
" \n",
|
||||||
|
" # end for rule loop\n",
|
||||||
|
" # end for right loop\n",
|
||||||
|
" # end for left loop\n",
|
||||||
|
" # end for part loop\n",
|
||||||
|
" return chart\n",
|
||||||
|
"\n",
|
||||||
|
"def wpToTree(edge):\n",
|
||||||
|
" if isinstance(edge,CCGLeafEdge):\n",
|
||||||
|
" return Tree((edge.token(),\"Leaf\"),[Tree(edge.token(),[edge.leaf()])])\n",
|
||||||
|
" else:\n",
|
||||||
|
" return Tree(\n",
|
||||||
|
" (chart.Token(None,edge.categ()),edge.triple[0].__str__()),\n",
|
||||||
|
" [wpToTree(t) for t in (edge.triple[1:])])\n",
|
||||||
|
"\n",
|
||||||
|
"def bestTree(tokens, lex, rules):\n",
|
||||||
|
" # We build the weighgted parse tree using cky\n",
|
||||||
|
" wChart = weightedParse(tokens, lex, rules)\n",
|
||||||
|
" # We get the biggest edge\n",
|
||||||
|
" e = list(wChart.select(start=0,end=len(tokens)))[0]\n",
|
||||||
|
" # We get the tree that brought us to this edge\n",
|
||||||
|
" t = wChart._trees(e, True, dict(), Tree)[0]\n",
|
||||||
|
" # (wpToTree(e),e.weight)\n",
|
||||||
|
" return (t,e.weight)"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "markdown",
|
||||||
|
"metadata": {},
|
||||||
|
"source": [
|
||||||
|
"# Application"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 4,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [],
|
||||||
|
"source": [
|
||||||
|
"from numbers import Number\n",
|
||||||
|
"from nltk.sem.logic import Expression\n",
|
||||||
|
"from nltk.ccg.api import PrimitiveCategory\n",
|
||||||
|
"\n",
|
||||||
|
"def to_pseudo_entries(table, consider_semantics = False):\n",
|
||||||
|
" \"\"\"returns a list of lists in the format ['word', 'category', 'weight', None]\n",
|
||||||
|
" if consider_semantics == false else ['word', 'category', weight, 'semantic']\n",
|
||||||
|
" that is left to be converted into tokens by to_wlex_entries\"\"\"\n",
|
||||||
|
"\n",
|
||||||
|
" entries = list()\n",
|
||||||
|
" for line in range(len(table['MOT'])):\n",
|
||||||
|
" for wdi, word in enumerate(table['MOT'][line].replace(\" \", \"\").split('/')):\n",
|
||||||
|
" for j in range(3):\n",
|
||||||
|
" if isinstance(table['Cat'+str(j)][line],str):\n",
|
||||||
|
" category = table['Cat'+str(j)][line]\n",
|
||||||
|
" weight = float(table['Weights'+str(j)][line]) if isinstance(table['Weights'+str(j)][line], Number) else 1.0\n",
|
||||||
|
" if consider_semantics:\n",
|
||||||
|
" semantic = (table['Sem'+str(j)][line].replace('\\\\\\\\', '\\\\').split('/'))[wdi]\n",
|
||||||
|
" else:\n",
|
||||||
|
" semantic = None\n",
|
||||||
|
" entries.append([word, category, weight, semantic])\n",
|
||||||
|
" return entries\n",
|
||||||
|
"\n",
|
||||||
|
"def to_wlex_entries(pseudo_entries, primitives, families, var=None):\n",
|
||||||
|
" \"\"\"returns the entries to a weighed lexicon from pseudo_entries generated by to_pseudo_entries\"\"\"\n",
|
||||||
|
" entries = dict()\n",
|
||||||
|
" for entry in pseudo_entries:\n",
|
||||||
|
" if entry[0] not in entries:\n",
|
||||||
|
" entries[entry[0]] = list()\n",
|
||||||
|
" categ, _ = augParseCategory(entry[1], primitives, families, var)\n",
|
||||||
|
" token = WeighedToken(token= entry[0],\n",
|
||||||
|
" categ= categ,\n",
|
||||||
|
" semantics= Expression.fromstring(entry[-1]),\n",
|
||||||
|
" weight= entry[2])\n",
|
||||||
|
" entries[entry[0]].append(token)\n",
|
||||||
|
" return entries\n",
|
||||||
|
" "
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 9,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [
|
||||||
|
{
|
||||||
|
"name": "stdout",
|
||||||
|
"output_type": "stream",
|
||||||
|
"text": [
|
||||||
|
"{}\n",
|
||||||
|
"\\n v.à(v,n)\n",
|
||||||
|
"\\n v.avec(v,n)\n",
|
||||||
|
"chat\n",
|
||||||
|
"\\n m.de(n,m)\n",
|
||||||
|
"dents\n",
|
||||||
|
"\\n.donne(n)\n",
|
||||||
|
"\\n m.donne(n,m)\n",
|
||||||
|
"\\n.mange(n)\n",
|
||||||
|
"\\n m.mange(n,m)\n",
|
||||||
|
"donner\n",
|
||||||
|
"\\n.donner(n)\n",
|
||||||
|
"\\n.dormir(n)\n",
|
||||||
|
"\\n.dormir(n)\n",
|
||||||
|
"elle\n",
|
||||||
|
"il\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"\\n m.et(n,m)\n",
|
||||||
|
"\\x y.et(x,y)\n",
|
||||||
|
"\\v w n.et(v,w,n)\n",
|
||||||
|
"fromage\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"\\P.exists x.P(x)\n",
|
||||||
|
"\\P.exists x.P(x)\n",
|
||||||
|
"\\P.exists x.P(x)\n",
|
||||||
|
"\\P.exists x.P(x)\n",
|
||||||
|
"\\P.exists x.P(x)\n",
|
||||||
|
"\\n.mangé(n)\n",
|
||||||
|
"\\n.mangé(n)\n",
|
||||||
|
"\\n.donné(n)\n",
|
||||||
|
"\\n.méchant(n)\n",
|
||||||
|
"\\n.méchant(n)\n",
|
||||||
|
"\\n.noir(n)\n",
|
||||||
|
"\\n.noir(n)\n",
|
||||||
|
"\\v n.paisiblement(v,n)\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"{}\n",
|
||||||
|
"rat\n",
|
||||||
|
"soeur\n",
|
||||||
|
"\\n m.souhaite(m,n)\n",
|
||||||
|
"\\n m.pourchasse(m,n)\n",
|
||||||
|
"\\n m.attrappe(m,n)\n",
|
||||||
|
"souris\n",
|
||||||
|
"{}\n",
|
||||||
|
"voisin\n",
|
||||||
|
"1 le chat dort\n",
|
||||||
|
"Found derivation tree with weight 0.5599999999999999\n",
|
||||||
|
" le chat dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
"----------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.chat(x))}\n",
|
||||||
|
"1 il dort\n",
|
||||||
|
"Found derivation tree with weight 0.7\n",
|
||||||
|
" il dort\n",
|
||||||
|
" N {il} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
"------------------------------<\n",
|
||||||
|
" S {dormir(il)}\n",
|
||||||
|
"1 le chat dort paisiblement\n",
|
||||||
|
"Found derivation tree with weight 0.39199999999999996\n",
|
||||||
|
" le chat dort paisiblement\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} (S\\N) {\\n.dormir(n)} ((S\\N)\\(S\\N)) {\\v n.paisiblement(v,n)}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" --------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {\\n.paisiblement(\\n.dormir(n),n)}\n",
|
||||||
|
"--------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {paisiblement(\\n.dormir(n),exists x.chat(x))}\n",
|
||||||
|
"2 le chat noir dort\n",
|
||||||
|
"Found derivation tree with weight 0.39199999999999996\n",
|
||||||
|
" le chat noir dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} (N\\N) {\\n.noir(n)} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" ------------------------------<\n",
|
||||||
|
" N {noir(chat)}\n",
|
||||||
|
"-------------------------------------------------------->\n",
|
||||||
|
" N {exists x.noir(chat,x)}\n",
|
||||||
|
"------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.noir(chat,x))}\n",
|
||||||
|
"1 le méchant chat dort\n",
|
||||||
|
"Found derivation tree with weight 0.44800000000000006\n",
|
||||||
|
" le méchant chat dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} (N/N) {\\n.méchant(n)} N {chat} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" --------------------------------->\n",
|
||||||
|
" N {méchant(chat)}\n",
|
||||||
|
"----------------------------------------------------------->\n",
|
||||||
|
" N {exists x.méchant(chat,x)}\n",
|
||||||
|
"---------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.méchant(chat,x))}\n",
|
||||||
|
"2 le très méchant chat dort\n",
|
||||||
|
"Found derivation tree with weight 0.35840000000000005\n",
|
||||||
|
" le très méchant chat dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} ((N/N)/(N/N)) {{}} (N/N) {\\n.méchant(n)} N {chat} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" ------------------------------------------->\n",
|
||||||
|
" (N/N) {{}(\\n.méchant(n))}\n",
|
||||||
|
" ----------------------------------------------------->\n",
|
||||||
|
" N {{}(\\n.méchant(n),chat)}\n",
|
||||||
|
"------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.{}(\\n.méchant(n),chat,x)}\n",
|
||||||
|
"-----------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.{}(\\n.méchant(n),chat,x))}\n",
|
||||||
|
"7 le chat de la sœur de mon voisin dort\n",
|
||||||
|
"Found derivation tree with weight 0.11239423999999998\n",
|
||||||
|
" le chat de la sœur de mon voisin dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((N/N)\\N) {\\n m.de(n,m)} (N/N) {\\P.exists x.P(x)} N {soeur} ((N/N)\\N) {\\n m.de(n,m)} (N/N) {\\P.exists x.P(x)} N {voisin} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" ------------------------------------<\n",
|
||||||
|
" (N/N) {\\m.de(chat,m)}\n",
|
||||||
|
" -------------------------------------<\n",
|
||||||
|
" (N/N) {\\m.de(soeur,m)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.voisin(x)}\n",
|
||||||
|
" --------------------------------------------------------------------------->\n",
|
||||||
|
" N {de(soeur,exists x.voisin(x))}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.de(soeur,exists x.voisin(x),x)}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {de(chat,exists x.de(soeur,exists x.voisin(x),x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.de(chat,exists x.de(soeur,exists x.voisin(x),x),x)}\n",
|
||||||
|
"-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.de(chat,exists x.de(soeur,exists x.voisin(x),x),x))}\n",
|
||||||
|
"2 le chat que mon voisin lui donne mange\n",
|
||||||
|
"Found derivation tree with weight 0.14049279999999997\n",
|
||||||
|
" le chat que mon voisin lui donne mange\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((N\\N)/S) {{}} (N/N) {\\P.exists x.P(x)} N {voisin} ((S\\N)/(S\\N)) {{}} (S\\N) {\\n.donne(n)} (S\\N) {\\n.mange(n)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.voisin(x)}\n",
|
||||||
|
" ----------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.donne(n))}\n",
|
||||||
|
" -------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(\\n.donne(n),exists x.voisin(x))}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------->\n",
|
||||||
|
" (N\\N) {{}({}(\\n.donne(n),exists x.voisin(x)))}\n",
|
||||||
|
" ---------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" N {{}({}(\\n.donne(n),exists x.voisin(x)),chat)}\n",
|
||||||
|
"----------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.{}({}(\\n.donne(n),exists x.voisin(x)),chat,x)}\n",
|
||||||
|
"--------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {mange(exists x.{}({}(\\n.donne(n),exists x.voisin(x)),chat,x))}\n",
|
||||||
|
"8 le chat qui dort est noir\n",
|
||||||
|
"Found derivation tree with weight 0.25087999999999994\n",
|
||||||
|
" le chat qui dort est noir\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((N\\N)/(S\\N)) {{}} (S\\N) {\\n.dormir(n)} ((S\\N)/(N/N)) {{}} (N\\N) {\\n.noir(n)}\n",
|
||||||
|
" ------------------------------------------>\n",
|
||||||
|
" (N\\N) {{}(\\n.dormir(n))}\n",
|
||||||
|
" ----------------------------------------------------<\n",
|
||||||
|
" N {{}(\\n.dormir(n),chat)}\n",
|
||||||
|
"------------------------------------------------------------------------------>\n",
|
||||||
|
" N {exists x.{}(\\n.dormir(n),chat,x)}\n",
|
||||||
|
" ---------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.noir(n))}\n",
|
||||||
|
"----------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(\\n.noir(n),exists x.{}(\\n.dormir(n),chat,x))}\n",
|
||||||
|
"1 le chat mange la souris\n",
|
||||||
|
"Found derivation tree with weight 0.35840000000000005\n",
|
||||||
|
" le chat mange la souris\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((S\\N)/N) {\\n m.mange(n,m)} (N/N) {\\P.exists x.P(x)} N {souris}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.mange(exists x.souris(x),m)}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {mange(exists x.souris(x),exists x.chat(x))}\n",
|
||||||
|
"1 le chat la mange\n",
|
||||||
|
"Found derivation tree with weight 0.44799999999999995\n",
|
||||||
|
" le chat la mange\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((S\\N)/((S\\N)/N)) {{}} ((S\\N)/N) {\\n m.mange(n,m)}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ----------------------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n m.mange(n,m))}\n",
|
||||||
|
"-----------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(\\n m.mange(n,m),exists x.chat(x))}\n",
|
||||||
|
"1 il la mange\n",
|
||||||
|
"Found derivation tree with weight 0.5599999999999999\n",
|
||||||
|
" il la mange\n",
|
||||||
|
" N {il} ((S\\N)/((S\\N)/N)) {{}} ((S\\N)/N) {\\n m.mange(n,m)}\n",
|
||||||
|
" ----------------------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n m.mange(n,m))}\n",
|
||||||
|
"-------------------------------------------------------------<\n",
|
||||||
|
" S {{}(\\n m.mange(n,m),il)}\n",
|
||||||
|
"1 quel chat mange la souris ?\n",
|
||||||
|
"Found derivation tree with weight 0.2867200000000001\n",
|
||||||
|
" quel chat mange la souris ?\n",
|
||||||
|
" ((S/(S\\N))/N) {{}} N {chat} ((S\\N)/N) {\\n m.mange(n,m)} (N/N) {\\P.exists x.P(x)} N {souris} (S\\S) {{}}\n",
|
||||||
|
"------------------------------>\n",
|
||||||
|
" (S/(S\\N)) {{}(chat)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.mange(exists x.souris(x),m)}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" S {{}(chat,\\m.mange(exists x.souris(x),m))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}({}(chat,\\m.mange(exists x.souris(x),m)))}\n",
|
||||||
|
"1 qui mange la souris ?\n",
|
||||||
|
"Found derivation tree with weight 0.35840000000000005\n",
|
||||||
|
" qui mange la souris ?\n",
|
||||||
|
" (S/(S\\N)) {{}} ((S\\N)/N) {\\n m.mange(n,m)} (N/N) {\\P.exists x.P(x)} N {souris} (S\\S) {{}}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.mange(exists x.souris(x),m)}\n",
|
||||||
|
"----------------------------------------------------------------------------------->\n",
|
||||||
|
" S {{}(\\m.mange(exists x.souris(x),m))}\n",
|
||||||
|
"-----------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}({}(\\m.mange(exists x.souris(x),m)))}\n",
|
||||||
|
"1 quelle souris mange le chat ?\n",
|
||||||
|
"Found derivation tree with weight 0.2867200000000001\n",
|
||||||
|
" quelle souris mange le chat ?\n",
|
||||||
|
" ((S/(S\\N))/N) {{}} N {souris} ((S\\N)/N) {\\n m.mange(n,m)} (N/N) {\\P.exists x.P(x)} N {chat} (S\\S) {{}}\n",
|
||||||
|
"-------------------------------->\n",
|
||||||
|
" (S/(S\\N)) {{}(souris)}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ----------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.mange(exists x.chat(x),m)}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" S {{}(souris,\\m.mange(exists x.chat(x),m))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}({}(souris,\\m.mange(exists x.chat(x),m)))}\n",
|
||||||
|
"1 la souris est mangée par le chat\n",
|
||||||
|
"Found derivation tree with weight 0.20070400000000002\n",
|
||||||
|
" la souris est mangée par le chat\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {souris} ((S\\N)/Pp) {{}} Pp {\\n.mangé(n)} (((S\\N)\\(S\\N))/N) {{}} (N/N) {\\P.exists x.P(x)} N {chat}\n",
|
||||||
|
"-------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ----------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.mangé(n))}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ------------------------------------------------------------>\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {{}(exists x.chat(x))}\n",
|
||||||
|
" -----------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {{}(exists x.chat(x),{}(\\n.mangé(n)))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(exists x.chat(x),{}(\\n.mangé(n)),exists x.souris(x))}\n",
|
||||||
|
"1 elle est mangée par le chat\n",
|
||||||
|
"Found derivation tree with weight 0.25088000000000005\n",
|
||||||
|
" elle est mangée par le chat\n",
|
||||||
|
" N {elle} ((S\\N)/Pp) {{}} Pp {\\n.mangé(n)} (((S\\N)\\(S\\N))/N) {{}} (N/N) {\\P.exists x.P(x)} N {chat}\n",
|
||||||
|
" ----------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.mangé(n))}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ------------------------------------------------------------>\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {{}(exists x.chat(x))}\n",
|
||||||
|
" -----------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {{}(exists x.chat(x),{}(\\n.mangé(n)))}\n",
|
||||||
|
"---------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(exists x.chat(x),{}(\\n.mangé(n)),elle)}\n",
|
||||||
|
"1 quelle souris est mangée par le chat ?\n",
|
||||||
|
"Found derivation tree with weight 0.16056320000000004\n",
|
||||||
|
" quelle souris est mangée par le chat ?\n",
|
||||||
|
" ((S/(S\\N))/N) {{}} N {souris} ((S\\N)/Pp) {{}} Pp {\\n.mangé(n)} (((S\\N)\\(S\\N))/N) {{}} (N/N) {\\P.exists x.P(x)} N {chat} (S\\S) {{}}\n",
|
||||||
|
"-------------------------------->\n",
|
||||||
|
" (S/(S\\N)) {{}(souris)}\n",
|
||||||
|
" ----------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.mangé(n))}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ------------------------------------------------------------>\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {{}(exists x.chat(x))}\n",
|
||||||
|
" -----------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {{}(exists x.chat(x),{}(\\n.mangé(n)))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" S {{}(souris,{}(exists x.chat(x),{}(\\n.mangé(n))))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}({}(souris,{}(exists x.chat(x),{}(\\n.mangé(n)))))}\n",
|
||||||
|
"1 le chat mange la souris avec ses dents\n",
|
||||||
|
"Found derivation tree with weight 0.16056320000000004\n",
|
||||||
|
" le chat mange la souris avec ses dents\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((S\\N)/N) {\\n m.mange(n,m)} (N/N) {\\P.exists x.P(x)} N {souris} (((S\\N)\\(S\\N))/N) {\\n v.avec(v,n)} (N/N) {\\P.exists x.P(x)} N {dents}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.mange(exists x.souris(x),m)}\n",
|
||||||
|
" ------------------------------------->\n",
|
||||||
|
" N {exists x.dents(x)}\n",
|
||||||
|
" ------------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.avec(v,exists x.dents(x))}\n",
|
||||||
|
" --------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {avec(\\m.mange(exists x.souris(x),m),exists x.dents(x))}\n",
|
||||||
|
"--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {avec(\\m.mange(exists x.souris(x),m),exists x.dents(x),exists x.chat(x))}\n",
|
||||||
|
"1 le chat la mange avec ses dents\n",
|
||||||
|
"Found derivation tree with weight 0.20070400000000002\n",
|
||||||
|
" le chat la mange avec ses dents\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((S\\N)/((S\\N)/N)) {{}} ((S\\N)/N) {\\n m.mange(n,m)} (((S\\N)\\(S\\N))/N) {\\n v.avec(v,n)} (N/N) {\\P.exists x.P(x)} N {dents}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ----------------------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n m.mange(n,m))}\n",
|
||||||
|
" ------------------------------------->\n",
|
||||||
|
" N {exists x.dents(x)}\n",
|
||||||
|
" ------------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.avec(v,exists x.dents(x))}\n",
|
||||||
|
" ------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {avec({}(\\n m.mange(n,m)),exists x.dents(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {avec({}(\\n m.mange(n,m)),exists x.dents(x),exists x.chat(x))}\n",
|
||||||
|
"0 avec quoi le chat mange la souris ?\n",
|
||||||
|
"Pas de dérivation tout court :/\n",
|
||||||
|
"1 le rat donne un fromage à la souris\n",
|
||||||
|
"Found derivation tree with weight 0.16056320000000004\n",
|
||||||
|
" le rat donne un fromage à la souris\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {rat} ((S\\N)/N) {\\n m.donne(n,m)} (N/N) {\\P.exists x.P(x)} N {fromage} (((S\\N)\\(S\\N))/N) {\\n v.à(v,n)} (N/N) {\\P.exists x.P(x)} N {souris}\n",
|
||||||
|
"----------------------------------->\n",
|
||||||
|
" N {exists x.rat(x)}\n",
|
||||||
|
" --------------------------------------->\n",
|
||||||
|
" N {exists x.fromage(x)}\n",
|
||||||
|
" -------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.donne(exists x.fromage(x),m)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ----------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.à(v,exists x.souris(x))}\n",
|
||||||
|
" -------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {à(\\m.donne(exists x.fromage(x),m),exists x.souris(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {à(\\m.donne(exists x.fromage(x),m),exists x.souris(x),exists x.rat(x))}\n",
|
||||||
|
"1 un fromage est donné par le rat à la souris\n",
|
||||||
|
"Found derivation tree with weight 0.08991539200000002\n",
|
||||||
|
" un fromage est donné par le rat à la souris\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {fromage} ((S\\N)/Pp) {{}} Pp {\\n.donné(n)} (((S\\N)\\(S\\N))/N) {{}} (N/N) {\\P.exists x.P(x)} N {rat} (((S\\N)\\(S\\N))/N) {\\n v.à(v,n)} (N/N) {\\P.exists x.P(x)} N {souris}\n",
|
||||||
|
"--------------------------------------->\n",
|
||||||
|
" N {exists x.fromage(x)}\n",
|
||||||
|
" ----------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n.donné(n))}\n",
|
||||||
|
" ----------------------------------->\n",
|
||||||
|
" N {exists x.rat(x)}\n",
|
||||||
|
" ----------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {{}(exists x.rat(x))}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {{}(exists x.rat(x),{}(\\n.donné(n)))}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ----------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.à(v,exists x.souris(x))}\n",
|
||||||
|
" ---------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {à({}(exists x.rat(x),{}(\\n.donné(n))),exists x.souris(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {à({}(exists x.rat(x),{}(\\n.donné(n))),exists x.souris(x),exists x.fromage(x))}\n",
|
||||||
|
"0 à quelle souris un fromage est donné par le rat ?\n",
|
||||||
|
"Pas de dérivation tout court :/\n",
|
||||||
|
"1 il le donne à la souris\n",
|
||||||
|
"Found derivation tree with weight 0.25088000000000005\n",
|
||||||
|
" il le donne à la souris\n",
|
||||||
|
" N {il} ((S\\N)/((S\\N)/N)) {{}} ((S\\N)/N) {\\n m.donne(n,m)} (((S\\N)\\(S\\N))/N) {\\n v.à(v,n)} (N/N) {\\P.exists x.P(x)} N {souris}\n",
|
||||||
|
" ----------------------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\n m.donne(n,m))}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ----------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.à(v,exists x.souris(x))}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {à({}(\\n m.donne(n,m)),exists x.souris(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {à({}(\\n m.donne(n,m)),exists x.souris(x),il)}\n",
|
||||||
|
"0 il le lui donne\n",
|
||||||
|
"Pas de dérivation tout court :/\n",
|
||||||
|
"1 il souhaite que mon voisin lui donne le chat\n",
|
||||||
|
"Found derivation tree with weight 0.12845056000000002\n",
|
||||||
|
" il souhaite que mon voisin lui donne le chat\n",
|
||||||
|
" N {il} ((S\\N)/N) {\\n m.souhaite(m,n)} (N/S) {{}} (N/N) {\\P.exists x.P(x)} N {voisin} ((S\\N)/(S\\N)) {{}} ((S\\N)/N) {\\n m.donne(n,m)} (N/N) {\\P.exists x.P(x)} N {chat}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.voisin(x)}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ----------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.donne(exists x.chat(x),m)}\n",
|
||||||
|
" ------------------------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {{}(\\m.donne(exists x.chat(x),m))}\n",
|
||||||
|
" ---------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {{}(\\m.donne(exists x.chat(x),m),exists x.voisin(x))}\n",
|
||||||
|
" --------------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {{}({}(\\m.donne(exists x.chat(x),m),exists x.voisin(x)))}\n",
|
||||||
|
" ----------------------------------------------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.souhaite(m,{}({}(\\m.donne(exists x.chat(x),m),exists x.voisin(x))))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {souhaite(il,{}({}(\\m.donne(exists x.chat(x),m),exists x.voisin(x))))}\n",
|
||||||
|
"1 il souhaite donner le chat à mon voisin\n",
|
||||||
|
"Found derivation tree with weight 0.16056320000000004\n",
|
||||||
|
" il souhaite donner le chat à mon voisin\n",
|
||||||
|
" N {il} ((S\\N)/N) {\\n m.souhaite(m,n)} (N/N) {\\n.donner(n)} (N/N) {\\P.exists x.P(x)} N {chat} (((S\\N)\\(S\\N))/N) {\\n v.à(v,n)} (N/N) {\\P.exists x.P(x)} N {voisin}\n",
|
||||||
|
" ------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
" ---------------------------------------------------------->\n",
|
||||||
|
" N {donner(exists x.chat(x))}\n",
|
||||||
|
" ------------------------------------------------------------------------------------------>\n",
|
||||||
|
" (S\\N) {\\m.souhaite(m,donner(exists x.chat(x)))}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.voisin(x)}\n",
|
||||||
|
" ----------------------------------------------------------------------->\n",
|
||||||
|
" ((S\\N)\\(S\\N)) {\\v.à(v,exists x.voisin(x))}\n",
|
||||||
|
" -----------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S\\N) {à(\\m.souhaite(m,donner(exists x.chat(x))),exists x.voisin(x))}\n",
|
||||||
|
"-------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {à(\\m.souhaite(m,donner(exists x.chat(x))),exists x.voisin(x),il)}\n",
|
||||||
|
"0 le chat de mon voisin pourchasse et attrape la souris\n",
|
||||||
|
"Pas de dérivation tout court :/\n",
|
||||||
|
"2 la souris dort et le chat de mon voisin attrape la souris\n",
|
||||||
|
"Found derivation tree with weight 0.05035261952\n",
|
||||||
|
" la souris dort et le chat de mon voisin attrape la souris\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {souris} (S\\N) {\\n.dormir(n)} ((S/S)\\S) {\\x y.et(x,y)} (N/N) {\\P.exists x.P(x)} N {chat} ((N/N)\\N) {\\n m.de(n,m)} (N/N) {\\P.exists x.P(x)} N {voisin} ((S\\N)/N) {\\n m.attrappe(m,n)} (N/N) {\\P.exists x.P(x)} N {souris}\n",
|
||||||
|
"-------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
"------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.souris(x))}\n",
|
||||||
|
"--------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S/S) {\\y.et(dormir(exists x.souris(x)),y)}\n",
|
||||||
|
" ------------------------------------<\n",
|
||||||
|
" (N/N) {\\m.de(chat,m)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.voisin(x)}\n",
|
||||||
|
" -------------------------------------------------------------------------->\n",
|
||||||
|
" N {de(chat,exists x.voisin(x))}\n",
|
||||||
|
" ---------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.de(chat,exists x.voisin(x),x)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ---------------------------------------------------------------------->\n",
|
||||||
|
" (S\\N) {\\m.attrappe(m,exists x.souris(x))}\n",
|
||||||
|
" --------------------------------------------------------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {attrappe(exists x.de(chat,exists x.voisin(x),x),exists x.souris(x))}\n",
|
||||||
|
"---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" S {et(dormir(exists x.souris(x)),attrappe(exists x.de(chat,exists x.voisin(x),x),exists x.souris(x)))}\n",
|
||||||
|
"1 le chat dort et la souris dort\n",
|
||||||
|
"Found derivation tree with weight 0.17561599999999997\n",
|
||||||
|
" le chat dort et la souris dort\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} (S\\N) {\\n.dormir(n)} ((S/S)\\S) {\\x y.et(x,y)} (N/N) {\\P.exists x.P(x)} N {souris} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
"------------------------------------>\n",
|
||||||
|
" N {exists x.chat(x)}\n",
|
||||||
|
"----------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.chat(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------<\n",
|
||||||
|
" (S/S) {\\y.et(dormir(exists x.chat(x)),y)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" ------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.souris(x))}\n",
|
||||||
|
"------------------------------------------------------------------------------------------------------------------------------------------------>\n",
|
||||||
|
" S {et(dormir(exists x.chat(x)),dormir(exists x.souris(x)))}\n",
|
||||||
|
"2 le chat et la souris dorment\n",
|
||||||
|
"Found derivation tree with weight 0.25088\n",
|
||||||
|
" le chat et la souris dorment\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((N/N)\\N) {\\n m.et(n,m)} (N/N) {\\P.exists x.P(x)} N {souris} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" ------------------------------------<\n",
|
||||||
|
" (N/N) {\\m.et(chat,m)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" -------------------------------------------------------------------------->\n",
|
||||||
|
" N {et(chat,exists x.souris(x))}\n",
|
||||||
|
"---------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.et(chat,exists x.souris(x),x)}\n",
|
||||||
|
"--------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.et(chat,exists x.souris(x),x))}\n",
|
||||||
|
"2 le chat et la souris dorment\n",
|
||||||
|
"Found derivation tree with weight 0.25088\n",
|
||||||
|
" le chat et la souris dorment\n",
|
||||||
|
" (N/N) {\\P.exists x.P(x)} N {chat} ((N/N)\\N) {\\n m.et(n,m)} (N/N) {\\P.exists x.P(x)} N {souris} (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
" ------------------------------------<\n",
|
||||||
|
" (N/N) {\\m.et(chat,m)}\n",
|
||||||
|
" -------------------------------------->\n",
|
||||||
|
" N {exists x.souris(x)}\n",
|
||||||
|
" -------------------------------------------------------------------------->\n",
|
||||||
|
" N {et(chat,exists x.souris(x))}\n",
|
||||||
|
"---------------------------------------------------------------------------------------------------->\n",
|
||||||
|
" N {exists x.et(chat,exists x.souris(x),x)}\n",
|
||||||
|
"--------------------------------------------------------------------------------------------------------------------------<\n",
|
||||||
|
" S {dormir(exists x.et(chat,exists x.souris(x),x))}\n"
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"source": [
|
||||||
|
"# Catégories primitives et familles\n",
|
||||||
|
"primitives = ['S', 'N', 'Pp']\n",
|
||||||
|
"V = augParseCategory(\"S\\\\N\", primitives = primitives, families={})\n",
|
||||||
|
"families = {'V': V}\n",
|
||||||
|
"\n",
|
||||||
|
"# On importe notre lexique sous forme de tableur\n",
|
||||||
|
"table = pd.read_excel(\"CategoriesGramaticalesCombinatoire.ods\", engine=\"odf\")\n",
|
||||||
|
"#print(table.keys())\n",
|
||||||
|
"\n",
|
||||||
|
"# On le convertit en Lexique pondéré\n",
|
||||||
|
"pe = to_pseudo_entries(table, consider_semantics = True)\n",
|
||||||
|
"#print(pe)\n",
|
||||||
|
"wEntries = to_wlex_entries(pseudo_entries= pe, primitives= primitives, families= families)\n",
|
||||||
|
"#print([list(map(lambda x: f\"{k} : \"+ str(x) + str(x._semantics), L)) for k, L in wEntries.items()])\n",
|
||||||
|
"lex = WeighedLexicon(start= 'S', primitives= primitives, families= families, entries= wEntries)\n",
|
||||||
|
"\n",
|
||||||
|
"\n",
|
||||||
|
"# On récupère le nombre de mots qui ont été définis\n",
|
||||||
|
"# n = len(table['MOT'])\n",
|
||||||
|
"\n",
|
||||||
|
"# On donne la liste des catégories primitives\n",
|
||||||
|
"# lexstring = ':- S,N,Pp\\n'\n",
|
||||||
|
"# On ajoute la notation V pour N\\S\n",
|
||||||
|
"# lexstring += 'V :: S\\\\N\\n'\n",
|
||||||
|
"\n",
|
||||||
|
"# On lis les données depuis le tableur en une chaine de caractère parsable\n",
|
||||||
|
"#for i in range(n):\n",
|
||||||
|
"# for j in range(3):\n",
|
||||||
|
"# if isinstance(table['Cat'+str(j)][i],str):\n",
|
||||||
|
"# for mot in table['MOT'][i].split('/'):\n",
|
||||||
|
"# lexstring+=mot+' => ' + table['Cat'+str(j)][i] + '\\n'\n",
|
||||||
|
"\n",
|
||||||
|
"# Pour inverser les slash dans le lexicon\n",
|
||||||
|
"#lexstring = lexstring.replace('\\\\','#').replace('/','\\\\').replace('#','/')\n",
|
||||||
|
"\n",
|
||||||
|
"# On crée notre lexique\n",
|
||||||
|
"# lex = lexicon.fromstring(lexstring)\n",
|
||||||
|
"\n",
|
||||||
|
"# On crée le parser, on donne l'ensemble des règles qu'il est cencé connaître\n",
|
||||||
|
"parser = chart.CCGChartParser(lex, chart.DefaultRuleSet)\n",
|
||||||
|
"#parser = chart.CCGChartParser(lex, chart.ApplicationRuleSet)\n",
|
||||||
|
"\n",
|
||||||
|
"printTotal=True\n",
|
||||||
|
"printDerivations=not printTotal\n",
|
||||||
|
"\n",
|
||||||
|
"# On lit les phrases dans le fichier\n",
|
||||||
|
"with open('phrases.txt') as f:\n",
|
||||||
|
" lines = f.readlines()\n",
|
||||||
|
"\n",
|
||||||
|
" lines.append(\"le chat et la souris dorment\")\n",
|
||||||
|
" \n",
|
||||||
|
" for phrase in lines:\n",
|
||||||
|
" # On met tout en minuscule\n",
|
||||||
|
" phrase = phrase.lower().strip()\n",
|
||||||
|
" if printDerivations:\n",
|
||||||
|
" print(\"=\"*77)\n",
|
||||||
|
" print('#',phrase)\n",
|
||||||
|
" # lex = lexicon.fromstring(lexstring)\n",
|
||||||
|
" parser = chart.CCGChartParser(lex, chart.ApplicationRuleSet)\n",
|
||||||
|
"\n",
|
||||||
|
" # Et on affiche tous les arbres de dérivation trouvés\n",
|
||||||
|
" i=0\n",
|
||||||
|
" for parse in parser.parse(phrase.split()):\n",
|
||||||
|
" i+=1\n",
|
||||||
|
" if printDerivations:\n",
|
||||||
|
" chart.printCCGDerivation(parse)\n",
|
||||||
|
" \n",
|
||||||
|
" if printTotal:\n",
|
||||||
|
" print(i,phrase)\n",
|
||||||
|
" \n",
|
||||||
|
" \n",
|
||||||
|
" # On affiche la dérivation la meilleure pour l'arbre\n",
|
||||||
|
" if (i==0):\n",
|
||||||
|
" print(\"Pas de dérivation tout court :/\")\n",
|
||||||
|
" else:\n",
|
||||||
|
"\n",
|
||||||
|
" t,d = bestTree(phrase.split(), lex, chart.ApplicationRuleSet)\n",
|
||||||
|
" print(\"Found derivation tree with weight\",d)\n",
|
||||||
|
" chart.printCCGDerivation(t)"
|
||||||
|
]
|
||||||
|
},
|
||||||
|
{
|
||||||
|
"cell_type": "code",
|
||||||
|
"execution_count": 10,
|
||||||
|
"metadata": {},
|
||||||
|
"outputs": [
|
||||||
|
{
|
||||||
|
"name": "stdout",
|
||||||
|
"output_type": "stream",
|
||||||
|
"text": [
|
||||||
|
"? => (S\\S) {{}}\n",
|
||||||
|
"attrape => ((S\\N)/N) {\\n m.attrappe(m,n)}\n",
|
||||||
|
"avec => (((S\\N)\\(S\\N))/N) {\\n v.avec(v,n)}\n",
|
||||||
|
"chat => N {chat}\n",
|
||||||
|
"de => ((N/N)\\N) {\\n m.de(n,m)}\n",
|
||||||
|
"dents => N {dents}\n",
|
||||||
|
"donne => (S\\N) {\\n.donne(n)} | ((S\\N)/N) {\\n m.donne(n,m)}\n",
|
||||||
|
"donner => N {donner} | (N/N) {\\n.donner(n)}\n",
|
||||||
|
"donné => Pp {\\n.donné(n)}\n",
|
||||||
|
"dorment => (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
"dort => (S\\N) {\\n.dormir(n)}\n",
|
||||||
|
"elle => N {elle}\n",
|
||||||
|
"est => ((S\\N)/Pp) {{}} | ((S\\N)/(N/N)) {{}} | ((S\\N)/(N\\N)) {{}}\n",
|
||||||
|
"et => ((N/N)\\N) {\\n m.et(n,m)} | ((S/S)\\S) {\\x y.et(x,y)} | (((S\\N)/(S\\N))\\(S\\N)) {\\v w n.et(v,w,n)}\n",
|
||||||
|
"fromage => N {fromage}\n",
|
||||||
|
"il => N {il}\n",
|
||||||
|
"la => ((S\\N)/((S\\N)/N)) {{}} | (N/N) {\\P.exists x.P(x)}\n",
|
||||||
|
"le => ((S\\N)/((S\\N)/N)) {{}} | (N/N) {\\P.exists x.P(x)}\n",
|
||||||
|
"lui => ((S\\N)/(S\\N)) {{}}\n",
|
||||||
|
"mange => (S\\N) {\\n.mange(n)} | ((S\\N)/N) {\\n m.mange(n,m)}\n",
|
||||||
|
"mangé => Pp {\\n.mangé(n)}\n",
|
||||||
|
"mangée => Pp {\\n.mangé(n)}\n",
|
||||||
|
"mon => (N/N) {\\P.exists x.P(x)}\n",
|
||||||
|
"méchant => (N/N) {\\n.méchant(n)} | (N\\N) {\\n.méchant(n)}\n",
|
||||||
|
"noir => (N\\N) {\\n.noir(n)} | (N/N) {\\n.noir(n)}\n",
|
||||||
|
"paisiblement => ((S\\N)\\(S\\N)) {\\v n.paisiblement(v,n)}\n",
|
||||||
|
"par => (((S\\N)\\(S\\N))/N) {{}}\n",
|
||||||
|
"pourchasse => ((S\\N)/N) {\\n m.pourchasse(m,n)}\n",
|
||||||
|
"que => ((N\\N)/S) {{}} | (N/S) {{}}\n",
|
||||||
|
"quel => (((((S\\N)\\(S\\N))/N)\\(S/S))/N) {{}} | ((S/(S\\N))/N) {{}}\n",
|
||||||
|
"quelle => (((((S\\N)\\(S\\N))/N)\\(S/S))/N) {{}} | ((S/(S\\N))/N) {{}}\n",
|
||||||
|
"qui => ((N\\N)/(S\\N)) {{}} | (S/(S\\N)) {{}}\n",
|
||||||
|
"quoi => (((S/S)\\(((S\\N)\\(S\\N))/N))/N) {{}}\n",
|
||||||
|
"rat => N {rat}\n",
|
||||||
|
"ses => (N/N) {\\P.exists x.P(x)}\n",
|
||||||
|
"souhaite => ((S\\N)/N) {\\n m.souhaite(m,n)}\n",
|
||||||
|
"souris => N {souris}\n",
|
||||||
|
"sœur => N {soeur}\n",
|
||||||
|
"très => ((N/N)/(N/N)) {{}}\n",
|
||||||
|
"un => (N/N) {\\P.exists x.P(x)}\n",
|
||||||
|
"voisin => N {voisin}\n",
|
||||||
|
"à => (((S\\N)\\(S\\N))/N) {\\n v.à(v,n)}\n"
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"source": [
|
||||||
|
"print(lex)"
|
||||||
|
]
|
||||||
|
}
|
||||||
|
],
|
||||||
|
"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.9.1"
|
||||||
|
}
|
||||||
|
},
|
||||||
|
"nbformat": 4,
|
||||||
|
"nbformat_minor": 2
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user