c
a
d
r
a
t






  Entrée  
   Ressources   
    Codes  
     Étiquetage  
 
+  Des ressources en corpus, isotopies et programmes
+  Des articles d’ études sur le traitement automatique de la langue
+  Les pages du site pour des recherches, informations, résumés...


 
     l’utilisation et le code de la catégorisation grammaticale pour le français, en Python   
La page d’utilisation du logiciel Notule avec le détail des diverses parties du code

 1.  mode d’emploi

Le catégoriseur vient d'être installé et lancé. Pour opérer un traitement sur un texte, l'on peut soit l'ouvrir dans l’éditeur, en allant sur Fichier/Ouvrir, soit le saisir directement, par exemple en le collant. Pour un collage, il faut user du raccourci CTRL/V. L'éditeur supporte mal les accents en copié/collé et peut afficher un message d'erreur du type unicode.

L'opération de catégorisation se lance dans Outil/Catégorisation. Elle va concerner un paragraphe, chacun sera l'objet d'une opération. Si le texte comporte cinq paragraphes, le programme se lancera cinq fois, et affichera dix fenêtres. En enregistrant un résultat, veillez à rajouter l'extension .txt.

L'éditeur sert essentiellement à catégoriser des textes peu volumineux et à tester des énoncés. Pour catégoriser une oeuvre complète, il faut effectuer quelques petites manipulations, comme appeler le programme sous une autre fonction.

Dans le menu, des étapes intermédiaires à la catégorisation sont exploitables, comme le découpage en mot d'un texte ou la concaténation des formes, lesquelles opérations sont complémentaires. L'on peut aussi étiqueter un texte sans le traiter, pour vérifier les étiquettes ou effectuer d'autres travaux statistiques.


 2.  déroulement de la catégorisation

La console Python déroule tout le détail des étapes de catégorisation. Comme décrit dans le chapitre sur la rapidité, le programme est lent. De plus il peut monopoliser les ressources de votre ordinateur, pour soit bloquer momentanément certaines applications, soit fixer les fenêtres de Python. À vous de juger de sa rentabilité pour des corpus importants. Il se peut que certains signes typogaphiques peu courants parasitent la catégorisation ou même le programme en générant un code d'erreur, c'est parfois le cas avec des corpus peu ordinaires.

Une fois l'opération terminée Notule affiche deux fenêtres, une avec les étiquettes détaillées, l'autre pour les abrégées. Il génère aussi dans le répertoire où se trouve le programme Python, normalement sur C:\Python22\Notule, deux fichiers :
- un format .txt avec le texte catégorisé détaillé
- un format .xml avec le texte catégorisé détaillé.

Le texte, c'est-à-dire la variable corp, passe par une série de transformations. Chacune d'entre elles est une fonction, aussi appelée pour notre propre terminologie, lorsqu'il s'agit d'un ensemble de règles, un bloc.


 3.  écriture d’une règle

Le programme repose sur l'algorithme de catégorisation et l'interface graphique. Celle-ci avait pour origine un éditeur de texte écrit par Brent Burley, en 2002, et modifié pour nos besoins, en ajoutant la gestion de fichiers.

La description des règles qui suit est relativement succincte. En attendant d'être un véritable tutoriel, développement plus minutieux et plus pédagogique, elle est une approche détaillée du principe. Pour compléter la connaissance du code Python et du programme Notule, l'on peut se familiariser avec le principe des chaînes et listes du langage.

Chaque chapitre est l’objet de plusieurs passages, et chaque mot-outil d’un ou plusieurs chapitres, généralement deux, un en debut de catégorisation et un autre en fin. Il est donc possible de réécrire entièrement les règles d'un mot outil en remplaçant deux chapitres, sans déséquilibrer le reste de la catégorisation, ce qui simplifie la perspective d’un travail collaboratif.

Pour se promener dans les lignes du programme, il faut utiliser le raccourci Alt-G.

 3.1.  identification

Première étape. Prenons exemple d’un bloc à la ligne 4326. Il est rédigé en lui donnant un nom, ici PPas, et lui attribuant la variable contenant le texte corp, puis à la ligne suivante en affichant l’objet du traitement dans la console Python, avec print, enfin en donnant une annotation, avec le croisillon, #, pour s’y repérer dans le code. Le titre, affichage et note explicitent la même chose, mais la redondance, parfois, est souhaitable.




def PPas(corp):
    Proc("PARTICIPE PASSE")
    # Participe passé,

 3.2.  contenu

Deuxième étape. Le code suivant décrit la règle. La ligne 4329 pointe le type d'ambiguïté. L'on reconnaît la classe grammaticale. Le crochet ouvrant pointe qu'elle est comprise dans l'étiquette. La ligne 4330 commente l'opération effectuée si les requêtes sont vérifiées. Il s'agit de soustraire le participe passé de l'étiquette. De même pour la ligne 4331 et 4332. Cette dernière contient la variable amb_r pour ambiguïté résolue, où le signe moins pointe la suppression. La ligne suivante, 4333, déroule trois séquences :
° La première est brève et claire, elle dit que notre catégorie participe passé précédée d'un déterminant simple aiguille sur une suppression, l'ambiguïté est réprésentée par le point d'interrogation ;
° La seconde fait de même avec un infinitif seul (pointé par une accolade), suivi d'une étiquette où se trouve un pronom personnel complément, puis de notre catégorie. Elle se base sur le fait qu'un pronom est antéposé à l'infinitif. Il n'y pas d'exemple associé, contrairement à la régle suivante ;
° Elle indique qu'une séquence canonique : déterminant suivi d'un nom puis de notre catégorie et terminée par une ponctuation forte ne peut impliquer un participe passé, sauf s'il s'agit de sa seule étiquette, c'est-à-dire en emploi d'adjectif. La suppression ne peut pas concerner une étiquette à la classe unique.

L'avant-dernière ligne appelle la fonction Regle qui contient toutes nos variables pour la résolution. Enfin, la variable corp modifiée est renvoyée, pour une nouvelle fonction. L'ensemble des règles du bloc PPas se retrouve dans une autre fonction, celle qui va hiérarchiser toutes les opérations.



[...]

amb="[vpp:ppas"
# -PPAS
Proc("-PPas /",",")
amb_r="-vpp:ppas"
sui=[["dét","?"],["{vii:infi","[pro:pers/comp","?"],["dét","nom","?","{po"]] # 3: Les avions découverts
corp=Regle(corp,amb,amb_r,sui)

return corp

 3.3.  hiérarchie

Troisième et dernière étape. Une fois le bloc rédigé, sa fonction est appelée dans une autre fonction, celle de CompilRegles(corp): ligne 7037, pour un PPas(corp), en 7052.




def CompilRegles(corp):
    corp=CompilRegles_MotOutil(corp)
    # Règles sur les ambiguités déterminants et pronoms
    corp=CojNom(corp)
    corp=DetProNom_genre(corp)
    corp=DetPro(corp)
    corp=Det(corp)
    corp=Des(corp)
    corp=AdvDetPro(corp)
    corp=AdvNomPreVer(corp)
    # Règles de préparation sur l'ambiguïté du verbe et du nom
    corp=Nom_prepa(corp)
    corp=Ver_Prepa(corp)
    # Règles sur les participes, les adjectifs et les infinitifs
    corp=AdvNom(corp)
    corp=PPas(corp)

Cette fonction est incluse à celle qui va dérouler l'ensemble des bloc de règles, à savoir Compil(corp), l.7169.

Une nouvelle règle ou groupe de règles doit donc se situer quelque part dans une fonction de type Compil, en respectant le facteur hiérarchique des problèmes, selon le principe de complexité.




def Compil(corp):
    Delete()
    # Règles sur le nom propre, cas sémantiques et interjections     
    if processus==1:
        print corp
    corp=NomPropReaf(corp)
    # Fusion des mots composés
    corp=FusionGlobal_mot_comp(corp)
    # Règles de préparation sur les mots-outils
    corp=Aussi_prepa(corp)
    corp=Bien_prepa(corp)
    corp=LangInco(corp)
    corp=CasSeman(corp)
    corp=Dire(corp)
    corp=NomProp_prepa(corp)

 4.  insertion d’une base lexicale

Pour insérer un dictionnaire ou un lexique, et l'inclure donc dans la chaîne de catégorisation l'on peut tout simplement rajouter à la suite d'un fichier votre base tabulaire. Dans ce cas il faut éviter les dictionnaires alphabétiques puisque ceux-ci ne sont consultés qu'en cas d'absence dans la base des mots-outils, Outil.txt. Le mieux est de le coller à la suite des noms propres, NomCitPay.txt.

Cette nouvelle base doit être fléchie, ce qui peut impliquer un travail d'écriture important avec un nouveau verbe, que l'on peut raccourcir en recopiant tout simplement un verbe équivalent dont on va remplacer le radical et le lemme. Les mots-composés d'une nouvelle base doivent compléter MotComp.txt, reconnus et figés en fonction de leur trait Cmps.

En cas de lexiques multiples et distincts, il est possible de les inclure comme fichier :

- d’une part dans la procédure Parcour à la ligne 333, en le(s) insérant après la base Outil.txt, afin de tester si une forme est présente dans cette liste.




def Parcour(mot_min,m,n,mot):
    # Parcours les dictionnaires et lance la procédure de recherche.
    # Cherche dans le fichier Outil.txt
    marqueur="marqueur"
    dictio=O
    mot_etiqu=Cherch(mot_min,dictio,m,n)
    if mot_etiqu=="": # Si inconnu, cherche dans la base alphabétique à partir de l'amorce du mot_min
        dictio=OuvBase(mot)
        mot_etiqu=Cherch(mot_min,dictio,m,n)
    # Cherche dans la base des noms propres
    dictio=N
    mot_etiqu_n=Cherch(mot_min,dictio,m,n)
    mot_etiqu=mot_etiqu_n+" "+mot_etiqu

- par exemple une base des professions ;



# Cherche dans la base des professions
dictio=P
mot_etiqu_t=Cherch(mot_min,dictio,m,n)
mot_etiqu=mot_etiqu_t+" "+mot_etiqu

- d’autre part en lisant le fichier pour le transformer en variable, à la ligne 8671. Il faut veiller à mettre la première lettre en majuscule et qu'elle ne soit pas identique à un autre fichier, par exemple O est déjà occupé, il correspond à Outil.




list_gram=["a.txt","b.txt","c.txt","d.txt","e.txt","f.txt","g.txt","h.txt","i.txt","j.txt","k.txt","l.txt","m.txt",
      "n.txt","o.txt","p.txt","q.txt","r.txt","s.txt","t.txt","u.txt","v.txt","w.txt","x.txt","y.txt","z.txt",
      "Outil.txt","Speciaux.txt","NomCitPay.txt","MotComp.txt","TempsAuxi.txt","Abreviation.txt","Profession.txt"]

 5.  catégorisation d’un corpus

Pour catégoriser un texte entier, on peut l'ouvrir dans l'éditeur de texte Notule, ce qui est lent et porte à saturation. Le plus pratique est de l'enregistrer en textecatego.txt sous Notule, puis changer l'amorce du programme de "l'éditeur" vers le "bureau", tout à la fin du programme (l.8682). Il suffit d'enlever le dièse de Bureau() et d'en ajouter un à Editeur(). Le texte catégorisé sera enregistré dans te_catego texteacatego.txt toujours dans le répertoire Notule. La console Python n'affichera pas l'aiguillage.




#Bureau()
Editeur()

Si l'on veut catégoriser plusieurs textes d'affilé, il faut donc enregistrer vos fichiers .txt sous Notule, puis dans la procédure Bureau() (l.8643) changer la valeur corpus, avec simplement le titre du texte, sans extension. Le texte, une fois traité, sera sauvegardé en te_catego son titre.txt.




def Bureau():
    global fichcorpus, processus
    processus=0
    #corpus=['declaration des droits de l homme','la chevre de m seguin','j accuse','supplement au voyage de bougainville','la lettre volee','le grand meaulnes','candide','1984']
    corpus=["texteacatego"]

Pour une question de rapidité l'on peut ouvrir Notule Bureau() avec Python 2.5.1.     . Seul changement : après avoir collé le répertoire Notule sous la racine Python, puis avoir ouvert le programme, il faut l'enregistrer sous la racine Python (même nom, même extension).


 6.  résumé des marqueurs

Dans une étiquette, les marqueurs délimitent et identifient la nature du mot. Dans le code, ils identifient une chaîne s'il s'agit de l'ambiguïté à résoudre amb, ou aiguillent une chaîne pour l'ambiguïté résolue, amb_r, et dans une suite de séquences, sui. Certains sont l'équivalent des métacaractères des expressions régulières : ils indiquent un comportement, en bleu. Les autres représentent un élément ou une caractéristique, en vert. Associés aux catégories et traits, comme vu aux chapitres précédents, se compose une séquence. Les séquences composent une suite. Enfin, avec les informations sur les ambiguïtés se forme une règle, laquelle se verra traiter comme une requête.

Le tableau qui suit complète les résumés     des marqueurs d'une balise,     la terminologie du contenu d'une étiquette, et     les possibilités de la requête.


Marqueur
Comportement
Balise
Ambiguité à résoudre
Ambiguité résolue
Suite de séquences
* identifieur du lemme, inclu, chaîne complète ;
b
b
b
@ identifieur de la forme, incluse, chaîne complète ;
 
b
b
b
[ classe incluse en début de chaîne tronquée ;
 
b
b
b
] classe incluse en fin de chaîne tronquée ;
 
b
b
b
{ classe univoque en début de chaîne tronquée ;
 
b
 
b
- supprime la nature ;
 
 
b
  
+ ajoute une nature ;
  
  
b
 
( amplifie une suite pour créer une liste ;
 
 
 
b
(( amplifie une suite, et crée un élément vide ;
 
 
 
b
| découpe d'une séquence ;
 
 
 
b
? équivalent de l'ambiguïté à résoudre ;
 
 
 
v
_ équivalent d'une nature quelconque ;
 
 
 
v
# équivalent de l'apostrophe ;
v
v
v
: délimiteur entre catégorie et trait(s) ;
v
v
v
v
/ délimiteur entre traits ;
v
v
v
v

L'inclusion signifie que la chaîne est retenue parmi plusieurs natures dans une étiquette, elle s'oppose à l'univoque, lequel considère qu'une étiquette ne possède qu'une seule nature. Des séquences sont rédigées sans marqueur si une règle inclut une catégorie univoque, comme un verbe, "ver", (qui est l'équivalent de "{ver"), ou une suite ambiguë "adj nom ver".

La découpe d'une suite permet d'insérer des locutions ou des incises. L'amplification permet de créer une liste (ontologie, temps...). Chaque nouvelle paranthèse est une nouvelle séquence avec la permutation d'un élément de la liste. La double paranthèse permet aussi de créer celle vide, c'est-à-dire un élément supprimable, comme un adverbe ou un déterminant zéro.


 7.  correction des règles

Le principe de la correction des erreurs est exposé au chapitre III.1.4.4.. L'aiguillage se déroule dans la console Python     . Les paramètres d'une résolution sont :

- l'intitulé du bloc ;
- la règle concernée, correspondant à une séquence dans sui ;
- la forme ambiguë dans l'énoncé, avec l'étiquette correspondante lors du test ;
- l'ambiguïté dans la règle, correpondant à amb ;
- sa position dans l'énoncé (en nombre de mot) ;
- la séquence dans l'énoncé, avec les étiquettes ;
- la résolution, le choix effectué, correspondant à amb_r.

Il suffit de rechercher la forme avec la boîte de dialogue, ctrl/f, jusqu'à l'identifier dans une règle, puis de s'y reporter pour la réécrire, comme décrit au chapitre précédent.

La résolution de traits pour une même forme est délicate. Ici une règle, élémentaire, dit que la forme « nous » suivie d'un verbe à l'infinitif est forcément un pronom personnel complément : « et ainsi, nous rendre comme maîtres et possesseurs de la Nature » (Discours de la méthode, René Descartes, VIème partie). Si un énoncé vient infirmer cette règle, comme le possible : « Pour nous prendre le train est plus reposant. », il faudrait évaluer si l'absence d'une virgule après « nous » relève d'une négligence et d'amorcer une réflexion sur le rôle de la préposition, de la transitivité de l'infinitif, sur son statut propositionnel et de le traduire en une série de règles. La convention grammaticale de Notule en détaille tous les processus.

- il est conseillé de supprimer la console d'affichage à chaque nouvel essai de correction, de façon à ne pas cumuler les textes affichés, et donc les formes redondantes ;

- dans le cas d'un texte important, il est suggéré de répéter une phrase problématique à part, afin de retrouver plus facilement la source de l'erreur.


 8.  erreurs possibles

 8.1.  erreurs dans le programme

° UnicodeError: ASCII decoding error: ordinal not in range(128) : S’il s’agit d’un copier/collé, l’éditeur de texte ne reconnaît pas les caractères accentués. Reprenez-les un à un ou passez par un nouveau copié/collé du texte par l’intermédiaire d'un autre éditeur de texte, par exemple le Bloc-note de Windows, pour "nettoyer" les diacritiques. Si le message d’erreur persiste, enregistrez votre texte à partir du bloc-note puis ouvrez-le avec Notule.

° Au lancement du programme, Python ferme avec une erreur critique : Peut-être avez-vous lancé le programme par le menu Edit/Run script utilisez plutôt le raccourci de la touche F5.

° Vous avez fait une modification dans le programme, mais en l'enregistrant sous un nouveau nom, le code ne se colore plus, ou vous obtenez le message ImportError: No module named : Rajoutez l'extension .py en enregistrant le fichier à nouveau.

° Le code se colore n’importe comment : les commentaires (avec #) supportent parfois mal la redondance des caractères avec diacritiques.

° En ouvrant un fichier .txt les consoles se ferment : Veillez à ce que l'éditeur soit vide, à ce qu'il n'y ait aucun autre texte.

 8.2.  erreurs après la catégorisation

° Les apostrophes ne sont pas pris en compte. Votre signe était peut être « ' » plutôt que « ' ».



     La convention grammaticale, pour Notule 1.1   IV.  
     La description du logiciel  Notule 
     Le code de catégorisation grammaticale du français
     Le langage Python    II.3.2.  
     Télécharger Python 2.2a2


       Site       motte 0.5  
       Imprimer  
     Le récapitulatif des balises 
     La page d’accueil
     Le sommaire des pages
     Rédaction : 01.02.2007      Publication : 01.06.2007     Révision : 30.10.2007
      http://cadrat.saynete.net2003 - 2018