Annexes Partie 2 Chapitre 5
A-2-5.1. Phase0 : Filtrage Catégoriel
• Définition des
traits (comportements) :
traits applications _AddSlotsIfAbsent: ( | catN = () | )
traits applications _AddSlotsIfAbsent: ( | genre = () | )
traits applications _AddSlotsIfAbsent: ( | nombre = () | )
traits applications _AddSlotsIfAbsent: ( | semantique = () | )
traits applications _AddSlotsIfAbsent: ( | category = () | )
traits genre _Define: ( |
_ parent* = traits clonable.
^ copy = (clone).
^ printString = (
'(', type_genre printString, ', ',
marque_genre printString, ')' ).
| )
traits nombre _Define: ( |
_ parent* = traits clonable.
^ copy = (clone).
^ printString = (
'(', type_nombre printString, ', ',
marque_nombre printString, ')' ).
| )
traits semantique _Define: ( |
_ parent* = traits clonable.
^ copy = (clone).
^ printString = (
'(', traits printString, ', ',
sense printString, ', ',
classe printString, ')' ).
| )
traits category _Define: ( |
_ parent* = traits clonable.
^ copy = (clone).
^ printString = (
'(', type printString, ')' ).
| )
traits catN _Define: ( |
_ parent* = traits clonable.
^ copy = (clone).
| )
• Définition des prototypes :
prototypes applications _AddSlotsIfAbsent : ( | catN = () | )
prototypes applications _AddSlotsIfAbsent: ( | genre = () | )
prototypes applications _AddSlotsIfAbsent: ( | nombre = () | )
prototypes applications _AddSlotsIfAbsent: ( | semantique = () | )
prototypes applications _AddSlotsIfAbsent: ( | category = () | )
genre _Define: ( |
_ parent* = traits genre.
^ type_genre <- ''.
^ marque_genre <- ''.
| )
nombre _Define: ( |
_ parent* = traits nombre.
^ type_nombre <- ''.
^ marque_nombre <- ''.
| )
semantique _Define: ( |
_ parent* = traits semantique.
^ traits <- ''.
^ sense <- ''.
^ classe <- ''.
| )
category _Define: ( |
_ parent* = traits category.
^ type <- ''.
| )
catN _Define: ( |
_ parent* = traits catN.
^ forme <- ''.
^ genre <- ''.
^ categorie <- ''.
^ nombre <- ''.
^ semantique <- ''.
| )
Pour créer de nouvelles entités prototypiques représentant des unités lexicales donné, on dispose des prototypes dont les attributs sont associées à des chaînes vides. Ces attributs seront valués à la création d'un prototype associé à l'élément lexical donné. Ci-dessous, le créateur des prototypes
catN :
_AddSlots: (| newN = () |)
newN _Define: (|
_ parent* = traits catN.
^ genre <- ''.
^ nombre <- ''.
^ forme <- ''.
^ categorie <- ''.
^ semantique <- ''.
^ addforme: t = ( forme: t ).
^ addgenre: t = ( genre: t ).
^ addsemantique: t = ( semantique: t ).
^ addcategorie: t = ( categorie: t ).
^ addnombre: t = ( nombre: t )
|)
Le lexique de test comprend des éléments construits de la manière suivante :
_AddSlots: (| lumiere |)
lumiere: newN copy
lumiere addforme: 'lumiere'
lumiere addgenre: (genre copy type_genre:'Fem')
lumiere addnombre: (nombre copy type_nombre: 'Sing')
lumiere addcategorie: (category copy type: 'Nom')
lumiere addsemantique: (((semantique copy traits: '')classe: '') sense: 'cf Petit Robert')
_AddSlots: (| moulin |)
moulin: newN copy
moulin addforme: 'moulin'
moulin addgenre: (genre copy type_genre:'Masc')
moulin addnombre: (nombre copy type_nombre: 'Sing')
moulin addcategorie: (category copy type: 'Nom')
moulin addsemantique: (((semantique copy traits: '')classe: 'Producteur de NaN')sense: 'cf Petit Robert')
_AddSlots: (| a |)
a: newPrep copy addforme: 'a'
a addcategorie: (category copy type: 'Prep')
On peut aussi adopter le dispositif standard de création des prototypes, à savoir le clonage, pour multiplier les prototypes lexicaux: on se sert d'un prototype lexical existant pour en créer un autre représentant une entité proche du précédent.
_AddSlots: (| paroles |)
paroles: lumiere copy
paroles addforme: 'paroles'
paroles addnombre: (nombre copy type_nombre: 'Plur')
paroles addsemantique: (((semantique copy traits: '')classe:'') sense: 'cf Petit Robert')
Figure a-2-5.1 : Un réseau de prototypes pour représenter le lexique.
Le code correspondant au prototype
regle est le suivant :
traits applications _AddSlotsIfAbsent: ( | regle = () | )
traits regle _Define: ( |
parent* = traits clonable.
|)
prototypes applications _AddSlotsIfAbsent: ( | regle = () | )
regle _Define: ( |
parent* = traits regle.
^ number <- ''.
^ position <- 0.
^ lhs <- vector copy.
^ lhsContent <- vector copy.
^ rhs <- vector copy.
^ rhsContent <- vector copy.
^ rhsContentForme <- vector copy.
^ addlhs: t = ( lhs: lhs copyAddLast: t).
^ addrhs: t = ( rhs: rhs copyAddLast: t).
^ newPosition: t = (position: (position + 1)).
^ addLhsContent <- ''.
^ addRhsContent: t = (
rhsContent: ( rhsContent copyAddLast: t).
).
^ addRhsContentForme: t = (
rhsContentForme: (rhsContentForme copyAddLast: t).
addLhsContent:
(((rhs size) _Eq: (rhsContent size))
ifTrue: [
(lhsContent: ((((aNaN copy
addN1: (rhsContent at: 0))
addprep: (rhsContent at: 1))
addN2: (rhsContent at: 2)))]).).|)
Le démarrage de chaque analyse initialise part les attributs du prototype associé à la règle à construire et enregistre la suite de mots à analyser.
regle lhsContent: (vector copy)
regle rhsContent: (vector copy)
regle rhsContentForme: (vector copy)
regle lhs: (vector copy)
regle rhs: (vector copy)
regle addrhs: 'Nom'
regle addrhs: 'Prep'
regle addrhs: 'Nom'
regle addlhs: 'NaN'
regle position: 0
textExample setInputTextExample: 'moulin'
textExample setInputTextExample: 'a'
textExample setInputTextExample: 'paroles'
inspect: textExample
Figure a-2-5.2 : Un prototype de parseur.
L'analyse commence et se déroule de la manière suivante :
1. Lecture de la suite de mots à analyser.
textToParse setInputText: textExample
2. On prend les entrées lexicales enregistrées une par une et on recherche les prototypes lexicaux associés qui permettent de mettre à jour la règle à construire :
Description du prototype contenant la règle à construire
( | parent* = <an object>.
^ number <- ''.
^ position <- 0.
^ lhs <- vector{'NaN'}.
^ lhsContent <- vector{}.
^ rhs <- vector{ 'Nom', 'Prep', 'Nom'}.
^ rhsContent <- vector{}.
^ rhsContentForme <- vector{}.
^ addlhs: t = ( lhs: lhs copyAddLast: t).
^ addrhs: t = ( rhs: rhs copyAddLast: t).
^ newPosition: t = ( position: (position + 1)).
^ addLhsContent <- ''.
^ addRhsContent: t = (
rhsContent: ( rhsContent copyAddLast: t). ).
^ addRhsContentForme: t = (
rhsContentForme: (rhsContentForme copyAddLast: t).
addLhsContent:
(((rhs size) _Eq: (rhsContent size))
ifTrue: [ (lhsContent: ((((aNaN copy addN1: (rhsContent at: 0)) addprep: (rhsContent at: 1))addN2: (rhsContent at: 2)))]).). | )
Modalités d'utilisation des attributs décrits ci-dessus
• L'attribut position donne la position dans la règle en construction;
• L'attribut lhs contient la catégorie du Lhs à construire;
• L'attribut lhsContent contiend le prototype Lhs construit (s'il est construit...);
• L'attribut rhs contient la description de la règle à construire;
• L'attribut rhsContent contiend tous les prototypes rhs construits au cours de l'analyse et correspondants au valeurs catégorielles contenues dans l'attribut rhs;
• L'attribut rhsContentForme donne la valeur du forme des prototypes de l'attribut précédent.
Les autres attributs permettent de construire les attributs pré-cités.
Sur l'exemple donné la règle construite a l'allure suivante :
• Description de la règle construite
( | parent* = <an object>.
^ number <- ''.
^ position <- 3.
^ lhs <- vector{'NaN'}.
^ lhsContent <- <an object>.
^ rhs <- vector{ 'Nom', 'Prep', 'Nom'}.
^ rhsContent <- vector{ <an object>, <an object>, <an object>}.
^ rhsContentForme <- vector{ 'moulin', 'a', 'paroles'}.
^ addlhs: t = ( lhs: lhs copyAddLast: t).
^ addrhs: t = ( rhs: rhs copyAddLast: t).
^ newPosition: t = ( position: (position + 1)).
^ addLhsContent <- <an object>.
^ addRhsContent: t = (
rhsContent: ( rhsContent copyAddLast: t).
).
^ addRhsContentForme: t = (
rhsContentForme: (rhsContentForme copyAddLast: t).
addLhsContent:
(((rhs size) _Eq: (rhsContent size))
ifTrue: [
(lhsContent: ((((aNaN copy
addN1: (rhsContent at: 0))
addprep: (rhsContent at: 1))
addN2: (rhsContent at: 2)))]).). | )
• Description du Lhs Construit
( | _ parent* = <an object>.
^ n1 <- <an object>.
^ prep <- <an object>.
^ n2 <- <an object>.
^ categorie <- 'NaN'.
^ addN1: t = ( n1: t ).
^ addprep: t = ( prep: t ).
^ addN2: t = ( n2: t ).| )
• Description de chacun des éléments du Lhs Construit
1. Le prototype Nom associé à moulin :
( | _ parent* = <an object>.
^ genre <- <an object>.
^ nombre <- <an object>.
^ forme <- 'moulin'.
^ categorie <- <an object>.
^ semantique <- <an object>.
^ addforme: t = ( forme: t ).
^ addgenre: t = ( genre: t ).
^ addsemantique: t = ( semantique: t ).
^ addcategorie: t = ( categorie: t ).
2.Le prototype Préposition associé à a
( | _ parent* = <an object>.
^ forme <- 'a'.
^ categorie <- <an object>.
^ addcategorie: t = ( categorie: t ).
^ addforme: t = ( forme: t ). | )
3.Le prototype Nom associé à paroles
( | _ parent* = <an object>.
^ genre <- <an object>.
^ nombre <- <an object>.
^ forme <- 'paroles'.
^ categorie <- <an object>.
^ semantique <- <an object>.
^ addforme: t = ( forme: t ).
^ addgenre: t = ( genre: t ).
^ addsemantique: t = ( semantique: t ).
^ addcategorie: t = ( categorie: t ).
^ addnombre: t = ( nombre: t ). |)
Figure a-2-5.3 : Résultat d'analyse sur
"un moulin à paroles de vipères".A-2-5.2. Phase1 : Affinement du filtrage
On donne ici le code
associé aux classes sémantiques.
traits applications _AddSlotsIfAbsent: ( | pourEntrée = () | )
traits pourEntree
_Define: ( |
_parent* = traits clonable.
^copy = (clone).
^printString = ('(', classe printString, ')' ).
|)
traits applications _AddSlotsIfAbsent: ( | pourSortie = () | )
traits pourSortie
_Define: ( |
_parent* = traits clonable.
^copy = (clone).
^printString = ('(', classe printString, ')' ).
|)
traits applications _AddSlotsIfAbsent: ( | avecEnergie = () | )
traits avecEnergie
_Define: ( |
_parent* = traits clonable.
^copy = (clone).
^printString = ('(', classe printString, ')' ).
|)
traits applications _AddSlotsIfAbsent: ( | avecPartieDe = () | )
traits avecPartieDe
_Define: ( |
_parent* = traits clonable.
^copy = (clone).
^printString = ('(', classe printString, ')' ).
|)
globals applications _AddSlotsIfAbsent: ( | pourEntree = () | )
pourEntree: _Define: ( |
_parent* = traits pourEntree.
^classe = 'POUR/Entrée'.
|)
globals applications _AddSlotsIfAbsent: ( | pourSortie = () | )
pourSortie: _Define: ( |
_parent* = traits pourSortie
^classe = 'POUR/Sortie'.
|)
globals applications _AddSlotsIfAbsent: ( | avecEnergie = () | )
avecEnergie: _Define: ( |
_parent* = traits avecEnergie.
^classe = 'AVEC/Energie'.
|)
globals applications _AddSlotsIfAbsent: ( | avecPartieDe = () | )
avecPartieDe: _Define: ( |
_parent* = trait avecPartieDe.
^classe = 'AVEC/Partie-de'.
|)
On a défini les objets traits et les prototypes associés aux catégories définissant les formes complexes N1 à N2 de la manière suivante :
traits applications _AddSlotsIfAbsent: ( | catN1aN2 = () | )
traits catN1aN2
_Define: ( |
_parent* = traits clonable.
^copy = (clone).
^printString = (
'(Classe: ', (semantiqueClasse classe ) printString, ', Categorie: ',
categorie printString, ', LhsN1àN2: ',
(n1 forme) printString, ', PrepN1àN2: ',
(prep forme) printString, ', RhsN1àN2: ',
(n2 forme) printString, ', formeN1àN2: ',
(forme_N1àN2) printString, ')' ).
|)
globals applications _AddSlotsIfAbsent: ( | catN1aN2 = () | )
cat1aN2: _Define: ( |
_parent* = traits catN1aN2.
^n1 <- ''.
^prep <- ''.
^n2 <- ''.
^semantiqueClasse <- ''.
^forme_N1aN2 <- ''.
^addN1: t = (n1: t).
^addPrep: t = (prep: t).
^addN2: t = (n2: t).
^addSemantiqueClasse: t = (semantiqueClasse: t).
^addFormeN1aN2: t = (forme_N1aN2: t).
|)
On créé les prototypes N1 à N2 de la manière suivante :
_AddSlots: ( | moulin_a_paroles = () | )
moulin_a_paroles: catN1àN2 copy
moulin_a_paroles addN1: moulin (ce dernier représente le prototype lexical associé à "moulin")
moulin_a_paroles addN2: paroles
moulin_a_paroles addPrep: a
moulin_a_paroles addSemantiqueClasse: (pourSortie copy)
moulin_a_paroles addForme_N1aN2: 'moulin a paroles'
Pour créer un nouveau prototype
N1 à N2, soit on répète cette opération en effectuant les assignations adéquates, soit on effectue une copie du prototype moulin_a_paroles et on modifie les attributs du prototype cloné :
_AddSlots: ( | moulin_a_gauffres = () | )
moulin_a_gauffres: moulin_a_paroles copy
moulin_a_gauffres addN2: gauffres
moulin_a_gauffres addFormeN1aN2: 'moulin a gauffres'
• Prototypes lexicaux créateurs de prototypes :
un protoToBuild: (vector copy) asList
_AddSlots: (| sn2 |)
sn2: catSnMoulinaN2 copy
un protoToBuild addLast:sn2
leD protoToBuild: (vector copy) asList
_AddSlots: (| sn1 |)
sn1: catSn copy
_AddSlots: (| p1 |)
p1: catP copy
sn1 protoToBuild: (((vector copy) asList) addLast: p1)
leD protoToBuild addLast:sn1
moulin protoToBuild: (vector copy) asList
moulin protoToBuild addLast: (catN1aN2 copy)
analyseV protoToBuild: (vector copy) asList
_AddSlots: (| sv2 |)
sv2: catSVt copy
analyseV protoToBuild addLast: sv2
A-2-5.3. Phase3 : Analyse par un réseau de prototypes
• Début de l'analyse:
Self 27> 'Phase4/4.1/parser_prototypes.new' _RunScript
reading ./Phase4/4.1/parser_prototypes.new...
manager
'Self 28>'Phase4/4.1/ph1-proto-declencheurs.new' _RunScript
reading ./Phase4/4.1/ph1-proto-declencheurs.new...
Initialisation de la phrase à analyser :
Self 29>textExample inputTextExample removeAll
textExample setInputTextExample : 'le'
textExample setInputTextExample : 'manager'
textExample setInputTextExample : 'analyse'
textExample setInputTextExample : 'un'
textExample setInputTextExample : 'moulin'
textExample setInputTextExample : 'a'
textExample setInputTextExample : 'paroles'
list{<object 41>}
list{}
Self 30> list{'le'}
Self 31> list{'le', 'manager'}
Self 32> list{'le', 'manager', 'analyse'}
Self 33> list{'le', 'manager', 'analyse', 'un'}
Self 34> list{'le', 'manager', 'analyse', 'un', 'moulin'}
Self 35> list{'le', 'manager', 'analyse', 'un', 'moulin', 'a'}
Self 36> list{'le', 'manager', 'analyse', 'un', 'moulin', 'a', 'paroles'}
Self 37> manager parser : (textExample inputTextExample)
Noeuds initiaux :
(0-('Clit'/'le')-1)
(0-('Det'/'le')-1)
(1-('Nom'/'manager')-2)
(2-('Vt'/'analyse')-3)
(3-('Det'/'un')-4)
(4-('Nom'/'moulin')-5)
(5-('Prep'/'a')-6)
(6-('Nom'/'paroles')-7)
(Prototype initial :
-------------------
'le'/'Clit')
(Prototype initial :
-------------------
'le'/'Det')
(Prototype(s) nouveau(x) a construire :
--------------------------------------
0-(Cat :'Sn'-NeededCat :'Nom'-Forme :'(le *)')-1)
(Prototype initial :
-------------------
'manager'/'Nom')
(Prototype initial :
-------------------
'analyse'/'Vt')
(Prototype(s) nouveau(x) a construire :
--------------------------------------
2-(Cat :'Sv'-NeededCat :'Sn'-Forme :'(analyse *)')-3)
(Prototype initial :
-------------------
'un'/'Det')
(Prototype(s) nouveau(x) a construire :
--------------------------------------
3-(Cat :'Sn'-NeededCat :'MoulinaN2'-Forme :'(un *)')-4)
(Prototype initial :
-------------------
'moulin'/'Nom')
(Prototype initial :
-------------------
'moulin'/'Nom')
(Prototype(s) nouveau(x) a construire :
--------------------------------------
4-(Cat :'N1aN2'-NeededCat :'Prep'-Forme :'')-5)
(Prototype initial :
-------------------
'a'/'Prep')
(Prototype initial :
-------------------
'paroles'/'Nom')
( Prototype extrait a construire :
-------------------------------
4-(Cat a construire :'N1aN2'-Forme construite :''-NeededCat :'Prep')-5)
( Prototype disponible retenu :
-----------------------------
5-(Cat :'Prep'-Forme :'a')-6)
( Prototype resultant :
----------------------
4-(Cat :'N1aN2'-Forme construite :''-NeededCat :'Nom')-6)
( Prototype extrait a construire :
-------------------------------
3-(Cat a construire :'Sn'-Forme construite :'(un *)'-NeededCat :'MoulinaN2')-4)
( Prototype extrait a construire :
-------------------------------
2-(Cat a construire :'Sv'-Forme construite :'(analyse *)'-NeededCat :'Sn')-3)
( Prototype extrait a construire :
-------------------------------
0-(Cat a construire :'Sn'-Forme construite :'(le *)'-NeededCat :'Nom')-1)
( Prototype disponible retenu :
-----------------------------
1-(Cat :'Nom'-Forme :'manager')-2)
( Prototype resultant :
----------------------
0-(Cat :'Sn'-Forme construite :'(le manager)'-NeededCat :'')-2)
(Prototype construit :
---------------------
0-(Cat :'Sn'-Forme construite :'(le manager)')-2)
(Nouveau prototype a construire :
--------------------------------
0-(Cat :'P'-Forme :'((le manager) *)')-2)
( Prototype extrait a construire :
-------------------------------
0-(Cat a construire :'P'-Forme construite :'((le manager) *)'-NeededCat :'Sv')-2)
( Prototype extrait a construire :
-------------------------------
4-(Cat a construire :'N1aN2'-Forme construite :''-NeededCat :'Nom')-6)
( Prototype disponible retenu :
-----------------------------
6-(Cat :'Nom'-Forme :'paroles')-7)
( Prototype resultant :
----------------------
4-(Cat :'N1aN2'-Forme construite :'(moulin a paroles)'-NeededCat :'')-7)
( Prototype extrait a construire :
-------------------------------
3-(Cat a construire :'Sn'-Forme construite :'(un *)'-NeededCat :'MoulinaN2')-4)
( Prototype disponible retenu :
-----------------------------
4-(Cat :'MoulinaN2'-Forme :'(moulin a paroles)')-7)
( Prototype resultant :
----------------------
3-(Cat :'Sn'-Forme construite :'(un (moulin a paroles))'-NeededCat :'')-7)
(Prototype construit :
---------------------
3-(Cat :'Sn'-Forme construite :'(un (moulin a paroles))')-7)
( Prototype extrait a construire :
-------------------------------
2-(Cat a construire :'Sv'-Forme construite :'(analyse *)'-NeededCat :'Sn')-3)
( Prototype disponible retenu :
-----------------------------
3-(Cat :'Sn'-Forme :'(un (moulin a paroles))')-7)
( Prototype resultant :
----------------------
2-(Cat :'Sv'-Forme construite :'(analyse (un (moulin a paroles)))'-NeededCat :'')-7)
(Prototype construit :
---------------------
2-(Cat :'Sv'-Forme construite :'(analyse (un (moulin a paroles)))')-7)
( Prototype extrait a construire :
-------------------------------
0-(Cat a construire :'P'-Forme construite :'((le manager) *)'-NeededCat :'Sv')-2)
( Prototype disponible retenu :
-----------------------------
2-(Cat :'Sv'-Forme :'(analyse (un (moulin a paroles)))')-7)
( Prototype resultant :
----------------------
0-(Cat :'P'-Forme construite :'((le manager) (analyse (un (moulin a paroles))))'-NeededCat :'')-7)
(Prototype construit :
---------------------
0-(Cat :'P'-Forme construite :'((le manager) (analyse (un (moulin a paroles))))')-7)
nil
Self 38> manager displayResult
(0-( Cat : 'Clit'/'le')-1)
(0-( Cat : 'Det'/'le')-1)
(1-( Cat : 'Nom'/'manager')-2)
(2-( Cat : 'Vt'/'analyse')-3)
(3-( Cat : 'Det'/'un')-4)
(4-( Cat : 'Nom'/'moulin')-5)
(4-( Cat : 'Nom'/'moulin')-5)
(5-( Cat : 'Prep'/'a')-6)
(6-( Cat : 'Nom'/'paroles')-7)
(0-( Cat : 'Sn'/'(le manager)')-2)
(4-( Cat : 'MoulinaN2'/'(moulin a paroles)')-7)
(3-( Cat : 'Sn'/'(un (moulin a paroles))')-7)
(2-( Cat : 'Sv'/'(analyse (un (moulin a paroles)))')-7)
(0-( Cat : 'P'/'((le manager) (analyse (un (moulin a paroles))))')-7)
nil
• Prototypes lexicaux créateurs de prototypes :
une protoToBuild: (vector copy) asList.
_AddSlots: (| sn1 |)
sn1: catSn copy
_AddSlots: (| p1 |)
p1: catP copy
sn1 protoToBuild: (((vector copy) asList) addLast: p1)
une protoToBuild addLast:sn1
_AddSlots: (| sn3 |)
sn3: catSnAdjN copy
_AddSlots: (| p2 |)
p2: catP copy
sn3 protoToBuild: (((vector copy) asList) addLast: p2)
une protoToBuild addLast:sn3
laD protoToBuild: (vector copy) asList.
_AddSlots: (| sn2 |)
sn2: catSn copy
laD protoToBuild: (((vector copy) asList) addLast:sn2)
laClit protoToBuild: (vector copy) asList.
_AddSlots: (| sv1 |)
sv1: catSVtClit copy
laClit protoToBuild addLast: sv1
briseV protoToBuild: (vector copy) asList.
_AddSlots: (| sv2 |)
sv2: catSVt copy
briseV protoToBuild addLast: sv2
petiteAdj protoToBuild: (vector copy) asList.
_AddSlots: (| adjn1 |)
adjn1: catAdjn copy
petiteAdj protoToBuild addLast: adjn1
• Initialisation de la phrase à analyser :
Self 4> textExample inputTextExample removeAll
textExample setInputTextExample: 'une'
textExample setInputTextExample: 'petite'
textExample setInputTextExample: 'brise'
textExample setInputTextExample: 'la'
textExample setInputTextExample: 'glace'
list{}
Self 5> list{'une'}
Self 6> list{'une', 'petite'}
Self 7> list{'une', 'petite', 'brise'}
Self 8> list{'une', 'petite', 'brise', 'la'}
Self 9> list{'une', 'petite', 'brise', 'la', 'glace'}
• Début de l'analyse :
Self 10> manager parser: (textExample inputTextExample)
Noeuds initiaux:
(0-('Det'/'une')-1)
(1-('Nom'/'petite')-2)
(1-('Adj'/'petite')-2)
(2-('Nom'/'brise')-3)
(2-('Vt'/'brise')-3)
(3-('Det'/'la')-4)
(3-('Clit'/'la')-4)
(3-('Clit'/'la')-4)
(4-('Nom'/'glace')-5)
(4-('Vt'/'glace')-5)
(Prototype initial:
-------------------
'une'/'Det')
(Prototype(s) nouveau(x) a construire:
--------------------------------------
0-(Cat:'Sn'-NeededCat:'Nom'-Forme:'(une *)')-1)
(Prototype(s) nouveau(x) a construire:
--------------------------------------
0-(Cat:'Sn'-NeededCat:'AdjN'-Forme:'(une *)')-1)
(Prototype initial:
-------------------
'petite'/'Nom')
(Prototype initial:
-------------------
'petite'/'Adj')
(Prototype(s) nouveau(x) a construire:
--------------------------------------
1-(Cat:'AdjN'-NeededCat:'Nom'-Forme:'(petite *)')-2)
(Prototype initial:
-------------------
'brise'/'Nom')
(Prototype initial:
-------------------
'brise'/'Vt')
(Prototype(s) nouveau(x) a construire:
--------------------------------------
2-(Cat:'Sv'-NeededCat:'Sn'-Forme:'(brise *)')-3)
(Prototype initial:
-------------------
'la'/'Det')
(Prototype initial:
-------------------
'la'/'Det')
(Prototype(s) nouveau(x) a construire:
--------------------------------------
3-(Cat:'Sn'-NeededCat:'Nom'-Forme:'(la *)')-4)
(Prototype initial:
-------------------
'la'/'Clit')
(Prototype initial:
-------------------
'la'/'Clit')
(Prototype(s) nouveau(x) a construire:
--------------------------------------
3-(Cat:'Sv'-NeededCat:'Vt'-Forme:'(la *)')-4)
(Prototype initial:
-------------------
'glace'/'Nom')
(Prototype initial:
-------------------
'glace'/'Vt')
( Prototype extrait a construire:
-------------------------------
3-(Cat a construire:'Sv'-Forme construite:'(la *)'-NeededCat:'Vt')-4)
( Prototype disponible retenu:
-----------------------------
4-(Cat:'Vt'-Forme:'glace')-5)
( Prototype resultant:
----------------------
3-(Cat:'Sv'-Forme construite:'(la glace)'-NeededCat:'')-5)
(Prototype construit:
---------------------
3-(Cat:'Sv'-Forme construite:'(la glace)')-5)
( Prototype extrait a construire:
-------------------------------
3-(Cat a construire:'Sn'-Forme construite:'(la *)'-NeededCat:'Nom')-4)
( Prototype disponible retenu:
-----------------------------
4-(Cat:'Nom'-Forme:'glace')-5)
( Prototype resultant:
----------------------
3-(Cat:'Sn'-Forme construite:'(la glace)'-NeededCat:'')-5)
(Prototype construit:
---------------------
3-(Cat:'Sn'-Forme construite:'(la glace)')-5)
( Prototype extrait a construire:
-------------------------------
2-(Cat a construire:'Sv'-Forme construite:'(brise *)'-NeededCat:'Sn')-
( Prototype disponible retenu:
-----------------------------
3-(Cat:'Sn'-Forme:'(la glace)')-5)
( Prototype resultant:
----------------------
2-(Cat:'Sv'-Forme construite:'(brise (la glace))'-NeededCat:'')-5)
(Prototype construit:
---------------------
2-(Cat:'Sv'-Forme construite:'(brise (la glace))')-5)
( Prototype extrait a construire:
-------------------------------
1-(Cat a construire:'AdjN'-Forme construite:'(petite *)'-NeededCat:'Nom')-2)
( Prototype disponible retenu:
-----------------------------
2-(Cat:'Nom'-Forme:'brise')-3)
( Prototype resultant:
----------------------
1-(Cat:'AdjN'-Forme construite:'(petite brise)'-NeededCat:'')-3)
(Prototype construit:
---------------------
1-(Cat:'AdjN'-Forme construite:'(petite brise)')-3)
( Prototype extrait a construire:
-------------------------------
0-(Cat a construire:'Sn'-Forme construite:'(une *)'-NeededCat:'AdjN')-
( Prototype disponible retenu:
-----------------------------
1-(Cat:'AdjN'-Forme:'(petite brise)')-3)
( Prototype resultant:
----------------------
0-(Cat:'Sn'-Forme construite:'(une (petite brise))'-NeededCat:'')-3)
(Prototype construit:
---------------------
0-(Cat:'Sn'-Forme construite:'(une (petite brise))')-3)
(Nouveau prototype a construire:
--------------------------------
0-(Cat:'P'-Forme:'((une (petite brise)) *)')-3)
( Prototype extrait a construire:
-------------------------------
0-(Cat a construire:'Sn'-Forme construite:'(une *)'-NeededCat:'Nom')-1
( Prototype disponible retenu:
-----------------------------
1-(Cat:'Nom'-Forme:'petite')-2)
( Prototype resultant:
----------------------
0-(Cat:'Sn'-Forme construite:'(une petite)'-NeededCat:'')-2)
(Prototype construit:
---------------------
0-(Cat:'Sn'-Forme construite:'(une petite)')-2)
(Nouveau prototype a construire:
--------------------------------
0-(Cat:'P'-Forme:'((une petite) *)')-2)
( Prototype extrait a construire:
-------------------------------
0-(Cat a construire:'P'-Forme construite:'((une petite) *)'-NeededCat:'Sv')-2)
( Prototype disponible retenu:
-----------------------------
2-(Cat:'Sv'-Forme:'(brise (la glace))')-5)
( Prototype resultant:
----------------------
0-(Cat:'P'-Forme construite:'((une petite) (brise (la glace)))'-NeededCat:'')-5)
(Prototype construit:
---------------------
0-(Cat:'P'-Forme construite:'((une petite) (brise (la glace)))')-5)
( Prototype extrait a construire:
-------------------------------
0-(Cat a construire:'P'-Forme construite:'((une (petite brise)) *)'-NeededCat:'Sv')-3)
( Prototype disponible retenu:
-----------------------------
3-(Cat:'Sv'-Forme:'(la glace)')-5)
( Prototype resultant:
----------------------
0-(Cat:'P'-Forme construite:'((une (petite brise)) (la glace))'-NeededCat:'')-5)
(Prototype construit:
---------------------
0-(Cat:'P'-Forme construite:'((une (petite brise)) (la glace))')-5)
nil
• Fin de l'analyse. Le
manager contient les éléments construits au cours de l'analyse :
Self 11> manager displayResult
(0-( Cat: 'Det'/'une')-1)
(1-( Cat: 'Nom'/'petite')-2)
(1-( Cat: 'Adj'/'petite')-2)
(2-( Cat: 'Nom'/'brise')-3)
(2-( Cat: 'Vt'/'brise')-3)
(3-( Cat: 'Det'/'la')-4)
(3-( Cat: 'Det'/'la')-4)
(3-( Cat: 'Clit'/'la')-4)
(3-( Cat: 'Clit'/'la')-4)
(4-( Cat: 'Nom'/'glace')-5)
(4-( Cat: 'Vt'/'glace')-5)
(3-( Cat: 'Sv'/'(la glace)')-5)
(3-( Cat: 'Sn'/'(la glace)')-5)
(2-( Cat: 'Sv'/'(brise (la glace))')-5)
(1-( Cat: 'AdjN'/'(petite brise)')-3)
(0-( Cat: 'Sn'/'(une (petite brise))')-3)
(0-( Cat: 'Sn'/'(une petite)')-2)
(0-( Cat: 'P'/'((une petite) (brise (la glace)))')-5)
(0-( Cat: 'P'/'((une (petite brise)) (la glace))')-5)
nil
Self 12>
Figure a-2-5.4 : Un réseau de prototypes pour
"une petite brise la glace".A-2-5.4. Mise en place d'un affinage progressif pour la construction du sens des séquences moulin à N2
Self 79> Debut Analyse....
Noeuds initiaux :
(0-('Nom'/'moulin')-1)
(1-('Prep'/'a')-2)
(2-('Nom'/'paroles')-3)
(Prototype initial :
-------------------
'moulin'/'Nom')
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'AVEC/Energie'>
Ajout du N1 au prototype specialise MoulinaN2 <classe :'AVEC/Partie-de'>
(Prototype(s) nouveau(x) a construire :
--------------------------------------
0-(Cat:'N1aN2'-NeededCat:'Prep'-Forme:'moulin' )')-1)
(Prototype initial :
-------------------
'a'/'Prep')
(Prototype initial :
-------------------
'paroles'/'Nom')
( Prototype extrait a construire :
-------------------------------
0-(Cat a construire :'N1aN2'-Forme construite : 'moulin')'-NeededCat :'Prep')-1)
( Prototype disponible retenu :
-----------------------------
1-(Cat :'Prep'-Forme :'a')-2)
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'AVEC/Energie'>
Ajout de la Prep au prototype specialise MoulinaN2 <classe :'AVEC/Partie-de'>
( Prototype resultant :
----------------------
0-(Cat :'N1aN2'-Forme construite : 'moulin a ')-NeededCat :'Nom')-2)
( Prototype extrait a construire :
-------------------------------
0-(Cat a construire :'N1aN2'-Forme construite : 'moulin a ')-NeededCat :'Nom')-2)
( Prototype disponible retenu :
-----------------------------
2-(Cat :'Nom'-Forme :'paroles')-3)
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'AVEC/Energie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'AVEC/Partie-de'>
La sémantique construite n'entre pas dans le modèle sémantique construit.
Le menu qui suit vous permet de modifier les valeurs sémantiques attachées
aux entrées lexicales représentées.
-------------------------------------------------------
<1 : Display Semantique>
<2 : Modify Semantique>
<3 : New Semantique>
Select a number or q to quit Gaspar-Semantique :1
-------------------------------------------------------
<1 : Display Semantique N1>
<2 : Display Semantique Prep
<3 : Display Semantique N2
Select a number or q to quit Gaspar-Display-Semantique :3
-------------------------------------------------------
Categorie :
(Type :'Nom')
Morph :
<Lemme : 'parole'><Forme : 'paroles'><Forme Plur : 'paroles'><Forme Sing : 'parole'>
<Classe : 'nom-a-plur-en-s'>
Semantique :
Trait :
(comptable : '-')
(humain : '-')
(artefact : '-')
(vivant : '-')
(anime : '-')
(abstrait : '-')
(concret : '+')
(Nparole : '+')
(ali : '-')
(synth : '-')
(energie : '+')
(deverbal : '-')
Classe :
''
Predicat :
Relation :
Accord :
<Genre : 'Fem'><Nombre : 'Plur'>
-------------------------------------------------------
<1 : Display Semantique N1>
<2 : Display Semantique Prep
<3 : Display Semantique N2
Select a number or q to quit Gaspar-Display-Semantique :q
-------------------------------------------------------
Gaspar-Display-Semantique Shut Down
-------------------------------------------------------
<1 : Display Semantique>
<2 : Modify Semantique>
<3 : New Semantique>
Select a number or q to quit Gaspar-Semantique :2
-------------------------------------------------------
-------------------------------------------------------
<1 : Mod Semantique N1>
<2 : Mod Semantique Prep>
<3 : Mod semnatique N2>
Select a number or q to quit Gaspar-Mod-Semantique :3
-------------------------------------------------------
Nouvelles valeurs pour les traits semantiques du N2
---------------------------------------------------
Trait Concret :+
Trait Comptable :-
Trait Abstrait :-
Trait Nparole :+
Trait Energie :-
Trait humain :-
Trait vivant :-
Trait anime :-
Trait Synth :-
Trait deverbal :-
Trait Artefact :-
-----------------------------------------
Categorie :
(Type :'Nom')
Morph :
<Lemme : 'parole'><Forme : 'paroles'><Forme Plur : 'paroles'><Forme Sing : 'parole'>
<Classe : 'nom-a-plur-en-s'>
Semantique :
Trait :
(comptable : '-')
(humain : '-')
(artefact : '-')
(vivant : '-')
(anime : '-')
(abstrait : '-')
(concret : '+')
(Nparole : '+')
(ali : '-')
(synth : '-')
(energie : '-')
(deverbal : '-')
Classe :
''
Predicat :
Relation :
Accord :
<Genre : 'Fem'><Nombre : 'Plur'>
Pour Une nouvelle analyse, quitter GasparSemantique en repondant par <y>.
Nouvelle analyse :y
-------------------------------------------------------
<1 : Mod Semantique N1>
<2 : Mod Semantique Prep>
<3 : Mod semnatique N2>
Select a number or q to quit Gaspar-Mod-Semantique :q
-------------------------------------------------------
Gaspar-Modd-Semantique Shut Down
-------------------------------------------------------
<1 : Display Semantique>
<2 : Modify Semantique>
<3 : New Semantique>
Select a number or q to quit Gaspar-Semantique :q
-------------------------------------------------------
Gaspar-Semantique Shut Down
(reprise de l'analyse avec les nouvelles valeurs sémantiques pour paroles)
<NewParsing :'y'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Entree'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'POUR/Sortie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'AVEC/Energie'>
Ajout du N2 au prototype specialise MoulinaN2 <classe :'AVEC/Partie-de'>
( Prototype resultant :
----------------------
0-(Cat :'N1aN2'-Forme construite :'(moulin a paroles)'-NeededCat :'')-3)
...Fin Analyse
(0-( Cat : 'Nom'/'moulin')-1)
(1-( Cat : 'Prep'/'a')-2)
(2-( Cat : 'Nom'/'paroles')-3)
(0-( Cat : 'MoulinaN2'/'(moulin a paroles)')-3)
-0-
<Classe reconnue :'POUR/Sortie'>
<Forme :'(moulin a paroles)'>
Semantique : Comptable Concret Abstrait Energie Vivant Anime Humain Nparole Synth Ali Deverbal
<('-','+','-','-','','','+','+','-','-','')>
-3-
Prototypes Initiaux :3
Prototypes a Construire Declenches :1
Prototypes Extraits :2
Prototypes Construits :4
manager
Self 80>