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.

 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.

 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.

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é.

 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.

- par exemple une base des professions ;

- 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.

 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.

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.

M a r q u e u r s
/nul	forme non ambiguë
/amb	cas d'ambiguïté traité
/inc	forme inconnue traitée
*	lemme correspondant à la forme
S é p a r a t e u r s
< >	balise entre chaque forme
/	entre les traits
+	entre genre, nombre et personne
:	entre la catégorie et le trait

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).

- une catégorie sans trait, Dét ;
- une catégorie avec trait(s), Dét:Indé ;
- une combinaison de catégorie, Adj Nom Ver ;
- une catégorie incluse dans une combinaison, sans trait,
Ver dans Adj Nom Ver ;
- une catégorie incluse dans une combinaison, avec trait(s),
Ver:IPré dans Adj Nom Ver ;
- une fin de trait incluse dans une combinaison,
Mas+PL dans Adj Nom Ver ;
- un lemme, piloter ;
- une forme, pilotant ;
- une forme vide, servant à se déplacer ou à rendre supprimable ;
- une liste de lemmes, être sembler paraître ;
- une liste de formes vers sur dans.
 

 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.

- le mot	est le point de vue linguistique ;
- la forme	est le mot du point de vue informatique ;
- le syntagme	est une suite de mots ;
- la séquence	est une suite de formes, et leur représentation possible par une règle ;
- le lemme	est la réduction morphologique du mot ;
- la catégorie	est la dizaine de possibilités du classement grammatical de base ;
- le trait	est le détail grammatical complétant la catégorie, un aspect morphologique, syntaxique, sémantique et pragmatique ;
- le marqueur	est un renseignement annexe comme le type de traitement informatique ;
- la classe	(grammaticale) est l'ensemble catégorie + trait(s) ;
- la nature	(grammaticale) est l'ensemble lemme + catégorie + trait(s) ;
- une ambiguïté	(grammaticale) est une combinaison de classes ;
- un attribut	est la classe, le lemme ou le marqueur, et il pourrait représenter la correspondance phonétique ou toute autre indication, étymologique, contextuelle etc. ;
- une étiquette	est un groupe d’attributs, ici l'ensemble classe + lemme, éventuellement une autre information comme le marqueur ;
- la balise	comprend une ou plusieurs étiquettes, encadrées par des signes < > . C'est aussi un terme générique, comme l'étiquette, dans nombre d'études.

<

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 « ' ».