Outils pour utilisateurs

Outils du site


public:annotation:specs_annotation_analec:exploitation

Exploitation d'annotations URS (Analec)

L'exploitation des annotations justifie le travail d'annotation et peut l'aider, non seulement en vérifiant sa cohérence mais également en permettant d'ajouter des annotations supplémentaires.

Dans les commandes de TXM

V1

Pouvoir faire des sélections de mots à l'aide de requêtes URSQL (TYPE@PROPERTY=VALUE) :

  • concordances
  • index
  • cooccurrences
  • progressions

Dans les outils utilisants un champ de requête CQP, si le corpus est équipé d'annotations URS, l'utilisateur peut choisir le type de requête “URSQL” et rentrer des requêtes du type “MENTION@REF=L'auteur”. L'état actuel de URSQL ne permet pas de définir si l'on souhaite filtrer sur des Unités, Relations ou Schémas. Dans tous les cas, le résultat de la sélection est la liste des limites des unités sous-jacentes des annotations URS sélectionnées.

Exemple avec l'interface pour TIGERSearch intégrée dans la fenêtre de concordance :

V2

Ajouter aux propriétés disponibles dans les outils, les propriétés des annotations URS.

Utilisation de macros

Pour exécuter les macros il faut :

  • ouvrir la vue Macro avec la commande 'Affichage > Vues > Macro'
  • éventuellement glisser-déposer cette vue par son onglet à un endroit pratique, par exemple dans la moitié inférieure de la vue Corpus
  • ouvrir le répertoire “analec”
  • double-cliquer sur le nom d'une macro pour la lancer

En général, il faut sélectionner le corpus sur lequel on veut travailler dans la vue Corpus avant de lancer la macro.

Pour modifier le code Groovy d'une macro :

  • clic droit sur le nom de la macro dans la vue Macro
  • lancer la commande 'Éditer' du menu contextuel
    → un éditeur de texte s'ouvre avec le code de la macro
  • quand on clique dans la vue de l'éditeur de texte (pour y placer le curseur de saisie) la barre d'outils d'édition remplace celle des corpus
  • ne pas oublier de sauver les modifications (avec le bouton “disquette”/sauver de la barre d'outils) avant de relancer la macro

Macros de Mesures 1

Étape 1

Un premier jeu de macros a été réalisé pour calculer différentes mesures à l'occasion de l'écriture d'un article (CG, JG, VO).

  • NombreDeChaines : nombre de chaînes de référence d'un texte
  • LongueurMoyenne : longueur moyenne des chaînes de référence et index hiérarchique des longueurs de chaînes
  • NatureDuPremierMaillon : index des valeurs d'une propriété donnée de la première unité de chaque chaîne
  • CoefficientStabilite : coefficient de stabilité
  • DensiteReferentielle : densité référentielle
  • DistanceInterMaillonnaire : distance inter-unités moyenne
  • AllMesures : application groupée des 6 mesures précédentes

Étape 2

Les mesures sont étendues au croisement avec les structures des textes et à la gestion d'un corpus et d'une partition.

Macros de vérification de Cohérence

Ces macros sont accompagnées de macros préliminaires de contrôle de la cohérence des annotations (proto-validation des annotations d'un texte par rapport à la structure d'annotation utilisée). Elles ont été développées pour vérifier la cohérence des annotations entre plusieurs annotateurs (les mesures supposent une cohérence parfaite).

  • UnitTypes : index des types d'unités
  • CategorieGrammaticale : index des valeurs d'une propriété des unités
  • SchemaTypes : index des types de schémas
  • UnitTypesNotInSchema : index des unités non associées à un schéma

Macro d'affichage des propriétés des éléments d'une chaîne

  • Chaines : affichage des valeurs d'une propriété des unités d'une chaîne. Son option buildCQL en particulier permet d'exploiter les autres outils de TXM comme les concordanciers, index, etc.

Cette macro liste pour chaque chaine d'un corpus la valeur de sa propriété 'Nom du référent' (par défaut) suivie des formes (par défaut) de ses unités successives.

Par exemple pour DESPERIERS ça donne ça pour la propriété 'word' (forme graphique) des mots :

Caillette: à Caillette, le povre Caillette, disoit, il, qu’il, sa, le, le, l’ha, l’ha, l’ha, Caillette, son, tu, Caillette, je, de ce sage homme Caillette, Caillette, qui, moy, luy, Caillette, Caillette, le, luy, luy, son, il, luy, il, Je, va
auteur: LES pages, les pages, les pages, tous ses gens de bien de pages, leur, à tous l’un apres l’autre, vous, qu’ilz, tous, qu’ilz, les, n’en, tant d’honnestes jeunes gens, qui, tous, les autres, avec les pages, je
un Seigneur de cour: un des Seigneurs de court, qui, qui, du Seigneur, ses
lecteur: vous, vous, vous, vous
un page (2): moy, qu’un, lequel, il, je
auteur: mon, je, Moy, m’escouter, je, Mon
Triboulet: Triboulet, Qui, ses, sa, Il, il, il, Il, luy, le, le, luy, vous, vous, vous, Triboulet, qui, son, luy, son, Triboulet, il, il, vous, son, Triboulet, il, je, je
maitre de Triboulet: un maistre, povre maistre, tu, Ce maistre, je, son maistre, son maistre
le cheval: son cheval, le cheval, qu’il, le, luy, luy, cheval, ce meschant cheval, le, il
les hommes: d’hommes, lesquelz, ilz, savent, qu’ilz
Polite: un autre fol nommé Polite, qui, Polite, mit, il, il, qu’il, il, tenoit, il, Polite, tu, Po lite, il
Abbé de Bourgueil: à un abbé de Bourgueil, Monsieur l’abbé, luy, le, l’abbé, Moyne, moy, l’abbé, moy, moy, l’abbé, l’abbé, moy, le moyne, il, il
le chantre: un chantre, qui, lequel, qu’il, qu’il, l’appelloyent, luy, luy, son, il, je, je, Je, je, Je, Sa, luy, te, luy, t’en, il, luy, t’oubliera, tu, luy, qu’il, ce Bassecontre, servoit, il, sa, qu’il, le povre chantre, luy, le Bassecontre, qu’il, qu’il, son, son, sa, il, il, qu’il, il, qu’il, il, il, pria, luy, sa, qu’il, il, qu’il, luy, luy, ce Bassecontre, sa, sa, le chantre, lequel, me, il, il, qu’il, Le chantre, Mon chantre, qui, venoit, luy, il, il, tu, tes, ce fol, le Bassecontre, il, Je, me, je, t’ha, tu, il, il, je, qu’il, tu, tu, il, apporta, qu’il, qu’il, son, luy, ses
les chanoines: les chanoines, qui, qu’ilz, d’eux, tes chanoines, nous
partie des chanoines: Monsieur, vous, vous, vous autres, d’eux, ilz, messieurs, ilz, des messieurs, qu’ilz, leur, ilz
messieurs tel et tel: messieurs tel et tel, ceux, qu’il, leur, ilz, leur, d’eux, messieurs, eux
principaux chanoines: aux principaux d’entre eux, les, l’un apres l’autre, qu’ilz, leur, leur, leur, les, leur, Ilz, ilz, qu’ilz, leur, messieurs, qui, tous, leurs, leur, ilz, ilz, ilz, ilz, chacun, leur, qu’ilz, leur, ilz, nous, nous, les nostres, les vostres, Les nostres, ilz, chacun, leurs, ilz, avons, les, Messieurs, voz, ilz, vous, vous autres messieurs, vous, chacun, soy, vous, vous, vous, vous, vostre, vous, voz, ilz, ilz, nous, nous, vous, leur, leur, ilz, allerent, conclurent, qu’ilz
un chanoine: monsieur vostre maistre, il, il, il
un chanoine2: je, l’un, j’avois, je
un autre chanoine: l’autre, j’avois, je, moy
valets chanoines: aux valetz, qui, qu’ilz
on: on, qu’on, qu’on, qu’on

Si on coche l'option buildCQL de cette macro, on génère à la place une requête par chaine qui cherche tous les mots de ses unités.

Par exemple pour la chaine Caillette ça donne ça :

Caillette: ([id="w_Desperiers_17"] [id="w_Desperiers_18"])|([id="w_Desperiers_27"] [id="w_Desperiers_28"] [id="w_Desperiers_29"])|([id="w_Desperiers_35"])|([id="w_Desperiers_39"])|([id="w_Desperiers_46"])|([id="w_Desperiers_53"])|([id="w_Desperiers_65"])|([id="w_Desperiers_75"])|([id="w_Desperiers_92"])|([id="w_Desperiers_102"])|([id="w_Desperiers_108"])|([id="w_Desperiers_122"])|([id="w_Desperiers_126"])|([id="w_Desperiers_139"])|([id="w_Desperiers_150"])|([id="w_Desperiers_152"])|([id="w_Desperiers_177"] [id="w_Desperiers_178"] [id="w_Desperiers_179"] [id="w_Desperiers_180"] [id="w_Desperiers_181"])|([id="w_Desperiers_250"])|([id="w_Desperiers_255"])|([id="w_Desperiers_264"])|([id="w_Desperiers_276"])|([id="w_Desperiers_288"])|([id="w_Desperiers_349"])|([id="w_Desperiers_356"])|([id="w_Desperiers_363"])|([id="w_Desperiers_368"])|([id="w_Desperiers_374"])|([id="w_Desperiers_381"])|([id="w_Desperiers_388"])|([id="w_Desperiers_390"])|([id="w_Desperiers_394"])|([id="w_Desperiers_402"])

C'est un peu indigeste mais ça permet de commencer à exploiter les outils habituels de TXM avec les chaines.

Par exemple la concordance de la chaine Caillette donne ça (j'ai copié/collé la requête de Caillette dans le champ “Requête” d'une concordance) :

Concordance de la chaine Caillette

Du coup la concordance permet également de naviguer dans la chaîne par retour au texte :

Retour au texte de la chaine Caillette

Pour obtenir cet affichage :

  • j'ai double-cliqué sur la ligne de 'le povre Caillette'
  • dans l'édition qui s'est ouverte j'ai cliqué sur le bouton 'Annoter' pour faire apparaitre les unités dans l'édition ainsi que la fenêtre en bas 'Maillon' qui donne le détail des valeurs des propriétés du maillon 'le povre Caillette'
  • en double-cliquant sur chaque ligne de concordance, on visualise l'unité correspondante dans le contexte de l'édition ainsi que la valeur de ses propriétés.

On peut par ailleurs tester par exemple la Progression de plusieurs chaines, l'index des mots des unités d'une chaine, etc.

Macros de Mesures 2

Exploitation par le biais de CQP 1

Projection d'URS vers CQP

Le modèle URS de DEMOCRAT :

  • unités :
    • type : MENTION
      • REF
      • CATEGORIE (grammaticale)
      • ACCESSIBILITE
      • définitude
  • relation :
    • type : ANAPHORE
      • co-référentiel ou pas
      • si co-référentiel : fidèle ou infidèle
  • schéma :
    • type : CHAINE
      • GENRE : féminin…
      • NB MAILLONS
      • NOMBRE : GROUPE_FLOU,GROUPE_STRICT,SINGULIER
      • REF : depuis MENTION@REF
      • TYPE REFERENT : animé humain, animaux, lieux… (catégorie ontologique)

Premier prototype pour le modèle DEMOCRAT

On limite une première version prototype au modèle DEMOCRAT :

  • un seul type d'unité = MENTION
  • un seul type de relation = ANAPHORE
  • un seul type de schéma = CHAINE

On augmente le modèle DEMOCRAT pour préparer les interrogations :

  • la macro RangMention (évolution/remplacement de PremierMaillon) ajoute la propriété rangMention (le numéro d'ordre de la mention dans sa chaine : 1, 2, 3…)

Solution

On projette les propriétés de mentions / unités et de chaines / schémas :

<w u_mention_ref=",Pierre,Paul," u_mention_accessibilite=",Faible,Faible," u_mention_categorie=",GN.NAM,DET.POS," s_chaine_genre=",MASCULIN,MASCULIN," ... w_debut_u_mention=",Paul,">

La virgule sépare les valeurs de propriétés.

Les virgules se trouvant dans les valeurs de propriétés sont :

  • soit retirées
  • soit remplacées par '_'

Après le traitement, il faut vérifier s'il n'y a pas d'ENS clachant, auquel cas message console détaillé (identifiant unités concernées, propriété, valeurs, etc.) et on demande de recoder les propriétés avant de relancer la demande de projection.

Note : la question se pose pour les tokens qui ne reçoivent pas d'information :

  • soit de ne pas mettre de propriété
  • soit de mettre une propriété à une certaine valeur ou vide

Solution TXM - Democrat 4.0

Nouvelle commande “URS2CQP” :

  • un corpus (sélectionné dans la vue corpus)
  • une liste de types d'unités
    • une liste de propriétés à projeter
      • valeur directe → liste de URSQL (type+propriété) d'unités ; la propriété de mot créée est u-<nom type>-<nom propriété>
      • valeur conditionnée → liste de URSQL de condition+propriété d'unités+nom propriété de mot à créer
        • exemple : si “MENTION@rangMention=1” alors “u-mention-debut” recoit “REF”
  • une liste de types de schémas qui contiennent les unités
    • une liste de propriétés à projeter → liste de URSQL de schémas
  • une liste de types de relations liées aux unités
    • une liste de propriétés à projeter → liste de URSQL de relations
  • caractère séparateur de valeurs : “,”, “;”, “|” (pour profiter de l'opérateur 'contains' de CQL) …
    • Rq. [BP] : le caractère “|” ne semble généralement pas approprié car l'ordre des valeurs énumérées est censé donner la correspondance de ces valeurs entre différentes propriétés, or l'opérateur 'contains' de CQL ne permet pas de considérer l'ordre des valeurs. Il ne serait donc intéressant que lorsque l'on ne projette qu'une seule propriété (pas de correspondances à faire avec d'autres propriétés), ou bien que l'on sait n'avoir aucun besoin de considérer simultanément les valeurs de plusieurs propriétés (ce n'est pas le cas dans Democrat).

Formulaire des paramètres :

  • Liste des unités
    #URSQL de projection(	nom propriété)(	URSQL de condition)
    #type@propriété		nom-propriete	type@propriété=valeur
    MENTION@REF
    MENTION@ACCESSIBILITE
    MENTION@CATEGORIE
    MENTION@rangMention=1	u-mention-debut			REF
  • Liste des schémas
    CHAINE@GENRE
  • Liste des relations
    
    
  • caractère séparateur de valeurs

Extensions possibles

Relations

Pour coder/interroger aussi les identifiants de mentions pour les relations :

<w u_mention_identifiant=",M2,M3," u_mention_accessibilite=",Faible,Faible," u_mention_categorie=",GN.NAM,DET.POS," u_mention_ref=",Pierre,Paul,">

Ergonomie

Pour améliorer l'ergonomie, on peut recoder :

  • Pierre = REF42 (voir l'interprétation REF42 plus bas)
  • Paul = REF64
  • Jacques = REF3

Ce qui donnerait :

<w chaine=",REF42," debutmention=",REF42,">
<w chaine=",REF42,REF64,REF3," debutmention=",REF42,REF3,">

Interprétation :

  • chaine :
    • je fais partie de la chaine ID
  • debutmention :
    • je suis le premier mot d'un maillon de cette chaine
  • REF42 :
    • on transcode les valeurs de REF avec un identifiant simple de valeur de REF
    • on fournit la table de correspondance valeurs de REF/identifiant simple de valeur de REF
    • on aide à transcrire une requête en <identifiants simple de valeur de REF> en requête en <valeurs de REF>
    • on aide à transcrire une requête en <valeurs de REF> en requête en <identifiants simple de valeur de REF>

Archive

Analyse initiale

On projette des informations de chaines et mentions :

On projette sur tous les tokens :

<w chaine=",Pierre," debutmention=",Pierre,">
<w chaine=",Pierre,Paul,Jacques," debutmention=",Pierre,Jacques,">

Un peu de généralisation indicative :

<w schema_de_type_A=",REF42," debut_d_unite_de_type_AA=",REF42,">
<w schema_de_type_A=",REF42,REF64,REF3," debut_d_unite_de_type_AA=",REF42,REF3,">

Liste des cas d'usages visés

  • exemples d'applications CORLI de FL
  • synthèse exploitation CS

Exemples concrets de requêtes CQL utilisant le modèle de projection pour répondre à différents cas d'usage

On teste ce modèle de projection : au niveau des mots, en supposant qu'un même mot peut appartenir à plusieurs mentions, et alors c'est l'ordre des valeurs dans chaque propriété qui permet d'associer les valeurs pour différentes propriétés.

Dès les premiers cas pratiques on s'aperçoit que cette projection est en fait très lourde à utiliser :

  • Comment les chaînes de coréférence sont-elles constituées ? (Corli, diapo 7)
    • Mettons qu'on veuille répondre en faisant un INDEX des séquences de POS des maillons (en sélectionnant éventuellement une chaîne ou une catégorie de maillons) : on s'aperçoit qu'il est compliqué d'exprimer que deux mots successifs appartiennent à une même chaîne (si on ne précise pas laquelle) et qu'il est difficile de faire le lien avec la catégorie du maillon (énumération indéfinie de tous les cas de figure : si la valeur est en première position en 2e position, en 3e position, etc.)
  • à quel rang dans une chaîne un démonstratif apparaît-il ? (Corli, diapo 7)
    • il faut faire le lien entre l'information de chaîne et l'information de rang…
  • Quelle est la fréquence d'apparition des noms propres ? (Corli, diapo 7)
    • Là on peut mieux répondre, en tout cas si on s'en tient à de simples décomptes
      • Toutes chaînes confondues : [u_mention_ref=“.+” & frpos=“NAM”]
      • Pour la chaîne de référent “Caillette” : [u_mention_ref=“.*,Caillette,.*” & frpos=“NAM”]
  • quelles sont les expansions des expressions référentielles ? (Corli, diapo 7)
    • Difficulté à exprimer une requête CQL qui attrape une mention ! Il s'agirait d'une séquence de mots qui contiennent une même valeur (non précisée) dans leur propriété u_mention_ref…

Bref, sur les quatre premiers cas on est mis en difficulté, et du coup on voit très vite qu'une projection qui travaillerait non pas au niveau du mot mais de la mention (en en faisant une structure) serait beaucoup plus approprié par rapport aux interrogations (même si évidemment on rencontrera davantage de limites en cas de chevauchements avec les autres structures du corpus). On teste alors ce nouveau cas de figure ci-après (§ macro URSUnits2CQPStruct).

Exploitation par le biais de CQP 2

Test des outils "Projection URS vers XML-TXM / CQP générique" dans le contexte de Democrat

Le modèle URS de DEMOCRAT :

  • unités :
    • type : MENTION
      • REF
      • CATEGORIE (grammaticale)
      • ACCESSIBILITE
      • définitude
  • relation :
    • type : ANAPHORE
      • co-référentiel ou pas
      • si co-référentiel : fidèle ou infidèle
  • schéma :
    • type : CHAINE
      • GENRE : féminin…
      • NB MAILLONS
      • NOMBRE : GROUPE_FLOU,GROUPE_STRICT,SINGULIER
      • REF : depuis MENTION@REF
      • TYPE REFERENT : animé humain, animaux, lieux… (catégorie ontologique)

Exemple de projection :

<mention ref="Pierre" categorie="DET.DEF" accessibilite="Faible" chaine-type="humain" chaine-genre="masculin" rang="3" debutmention="oui">Le jeune homme</mention>
<mention ref="Pierre et Paul"...><mention ref="Pierre"...>Pierre</mention> et <mention ref="Paul" ...>Paul</mention></mention>
  • Rq.1 : dans le manuel d'annotation, on ne prévoit aucun cas de chevauchement. La propriété “debutmention” sert alors en cas de chevauchement avec d'autres structures dans le corpus.
  • Rq.2 : si on a un intérêt pour le n-ième maillon, alors ce serait une propriété à rajouter (plutôt que d'essayer de la retrouver par requête).

Exemples d'utilisation dans des questionnements

FRÉDÉRIC - DIAPORAMA CORLI - 25 OCTOBRE 2017

Comment les chaînes de coréférence sont-elles constituées ? (diapo 7)

On peut par exemple faire un INDEX des séquences de POS des maillons d'une ou toutes les chaînes, pour une ou toutes les catégories de maillons :

INDEX de <mention>[]+</mention> en frpos

(cette requête ne gère cependant pas des discontinuités de mentions)

Requêtes pour d'autres cas évoqués :

<mention>[_.mention_ref="Caillette"]+</mention>
<mention>[_.mention_ref="Caillette" & _.mention_categorie="DET.DEF"]+</mention>

À quel rang dans une chaîne un démonstratif apparaît-il ? (diapo 7)

On peut faire le décompte pour les rangs qu'on veut (un à un ou en paquet) :

[mention & frpos=".*DEM" & _.mention_rang="1"]
[mention & frpos=".*DEM" & _.mention_rang="([1-9]|10)"]

Quelle est la fréquence d'apparition des noms propres ? (diapo 7)

Toutes chaînes confondues :

[mention & frpos="NAM"]

Pour la chaîne de référent “Caillette” :

[_.mention_ref="Caillette" & frpos="NAM"]

Quelles sont les expansions des expressions référentielles ? (diapo 7)

On peut chercher les effectifs pour chaque longueur :

<mention>[]{1,1}</mention>
<mention>[]{2,2}</mention>
<mention>[]{3,3}</mention>
etc.

ou classe de longueur :

<mention>[]{1,2}</mention>
<mention>[]{3,4}</mention>
<mention>[]{5,}</mention>

Quels sont les rôles thématiques privilégiés en début de chaîne ? (diapo 7)

On attrape un début de chaîne par :

<mention_rang="1">[]+</mention>

Mais comment identifie-t-on le rôle thématique ? On peut observer les réalisations en INDEX (est-il utile de choisir une certaine propriété d'analyse ?), en CONCORDANCE. On peut calculer les SPÉCIFICITÉS des réalisation au rang 1 par rapport aux réalisations quelque soit le rang (qu'on a regroupées et isolées en sous-corpus).

Peut-on prévoir des motifs dans la manière dont les chaînes se croisent ? (diapo 7)

On attrape les mentions d'une chaîne par une requête du type :

<mention_ref="Pierre">[]
ou
<mention_ref="Pierre">[]+</mention>

L'observation globale peut se faire en PROGRESSION, et locale en CONCORDANCE (et retour au texte en ÉDITION) en mettant mention:ref dans les localisations.

Ce serait intéressant pour ce genre de questions de réfléchir aussi à une projection qui crée une sorte de corpus réduits au débuts de mentions, avec word = REF de la mention et une propriété qui donne la forme de réalisation de la mention entière et sa localisation dans le corpus d'origine (soit deux formes de retour au texte)

Y a-t-il corrélation entre un genre textuel et un type de chaîne ?

Pour un genre donné (ex. roman) et un type de chaîne donné (ex. humain), on calcule la spécificité du type de chaîne pour le genre avec la macro PlotSpecif :

T = nombre d'occurrences de <mention>[]
t = nombre d'occurrences de <mention>[_.text_genre="roman"]
F = nombre d'occurrences de <mention_chaine-type="humain">[]
f = nombre d'occurrences de <mention_chaine-type="humain">[_.text_genre="roman"]
  • Rq. : on aurait sans doute préféré calculer directement un tableau de spécificités complet (pour tous genres et tous types de chaînes) mais on est bloqués par le fait qu'il faudrait pouvoir considérer comme propriété d'analyse une propriété d'une structure contenante (+ gestion des cas de multiplicité de structures contenantes). La projection évoquée au cas précédent pourrait à nouveau être un intermédiaire intéressant.

CATHERINE - GRILLE D'ANALYSE (document passé par Céline en 2015) et OUTILS DE MESURE (document envoyé par Catherine en 2018)

Il s'agit essentiellement de mesures, donc actuellement plutôt implémentées par des macros spécifiques.

Néanmoins on peut vérifier ici qu'on arrive, avec la projection CQP, à réaliser facilement la plupart des décomptes utilisés dans les mesures.

  • nombre d'expressions référentielles :
    <mention>[]
  • nombre de chaînes de référence :
<mention_rang="1">[]
ou encore, si on veut ne compter que les chaînes comportant au moins 3 mentions par exemple :
<mention_rang="3">[]
  • nombre de mots dans des mentions :
    [mention]
  • nombre de mentions pour une chaîne donnée :
    <mention_ref="Caillette">[]
    • si on veut un tableau global pour toutes les chaînes, il faudrait utiliser plutôt la deuxième projection indiquée ci-dessus : corpus formé de la séquence des mentions des différentes chaînes, word = REF de la chaîne, realisation = forme que prend la mention dans le texte, localisation dans le corpus initial pour un retour au texte plus complet.
  • catégories grammaticales des mentions :
INDEX de <mention>[]+</mention> en frpos
ou bien, si c'est la catégorie attribuée globalement à la mention qui nous intéresse, alors travailler sur la deuxième projection.
  • Longueurs des mentions : cf. questions de frédéric ci-dessus “Quelles sont les expansions des expressions référentielles ?”
  • Nombre d'enchâssements dans une mention : il me semble qu'on peut explorer cela ainsi (à vérifier) :
mentions avec au moins 1 enchâssement : <mention>[]*<mention>[]+</mention>[]*</mention>
mentions avec au moins 2 enchâssements : <mention>[]*<mention>[]*<mention>[]+</mention>[]*</mention>[]*</mention>
etc.
  • Réitération lexicale : pour une chaîne donnée, on peut peut-être faire des recherches de ce type :
<mention>[]* a:[_.mention_ref="Caillette" & frpos="NOM|NAM"] []*</mention> []{0,100} <mention>[]* [_.mention_ref="Caillette" & word=a.word] []*</mention>

Analyse spécifique chaines / structures

Spécifications

  • corpus =
    • corpus = DIDEROTESSAIS
      • chapitres
        • les (n = 3) paragraphes les plus longs
  • analyse 1 : chaines les plus longues par structure
    • pour chaque corpus =
      • texte = DIDEROTESSAIS
        • chapitres
          • paragraphes
    • calcul : pour les (n = 5) chaines les plus longues (longueur = nombre d'unités apparaissant au sein du sous-corpus)
      • afficher : nom du référent, longueur
    • spécifications
      • augmenter SchemaLengths
        • paramètre 'sort_column' : 'len' (par défaut), 'freq'
        • paramètre 'max_lines' : 0 (par défaut)
  • analyse 2 : chaines de plus fort taux d'accessibilité
    • taux d'accessibilité = ratio(MENTION@ACCESSIBILITÉ=Forte, MENTION@ACCESSIBILITÉ=Forte|Faible)
    • calcul : pour chaque chaine sélectionnée, afficher nom du référent, le calcul et le ratio. Afficher les chaines avec les meilleurs ratios.
  • analyse 3 : chaines ayant des mentions au début et à la fin du paragraphe
    • début =
      • a- les (p = 5%) premiers mots
      • b- les (n = 5) premiers mots
      • c- les (n = 1 ou 2) premières structures = <s>
    • fin = à partir de la fin
    • attention l'analyse doit pouvoir faire la part entre la sélection des CHAINES et la sélection d'une partie des unités de ces chaines :
      • ex : on sélectionne les chaines qui ont des mentions en début et fin de paragraphe PUIS on ne s'intéressera qu'aux mentions en début de paragraphe
    • calcul : pour chaque chaine sélectionnée, afficher nom du référent, unités de début et de fin (start, end, propriétés, word@*)
    • Dans l'idéal l'analyse fait la synthèse des unités par position :
      CHAINE    debut    milieu    fin
      CHAINE-1    5    10    2
      CHAINE-2    0    5    10
      ...
  • évolutions des macros existantes :
    • Vérifier et augmenter les macros SchemaXYZ pour travailler sur des sous-corpus
    • paramètres confronter la taille schémas en unités sélectionnées au pa minimum_schema_size et minimum_schema_size
    • Vérifier le bon fonctionneemnt du paramètre “position_in_schema” pour les valeurs négatives
  • Création de la structure CQP “s”
    • Sélectionner le corpus DIDEROTESSAIS
    • Faire la concordance [word="\.|\!|\?"] [word!="\.|\!|\?"]+ [word="\.|\!|\?"]
    • Sélectionner le corpus DIDEROTESSAIS
    • Lancer la macro urs/edit/ConcordanceToUnits avec les paramètres :
      • unit_type = s
      • move_start = 1 nouveau paramètre
      • move_end = 0 nouveau paramètre
      • create_if_new = true
      • property_name = type
      • property_value = s
    • Sélectionner le corpus DIDEROTESSAIS
    • Lancer la macro urs/cqp/URSUnit2CQPStruct (à récupérer dans les macros prototypes URS du jar “TXMINSTALLDIRECTORY/plugins/org.txm.annotation.urs.rcp_0123456.jar”, répertoire org/txm/macroprototypes ; il faut rectifier les packages des fichiers Groovy en remplacant “macroprototype” par “macro”)
    • Sélectionner le corpus DIDEROTESSAIS
    • Mettre à jour le corpus depuis le menu principal “Corpus > Re-import corpus”
    • Éventuellement supprimer toutes les unités “s”

Recettes

Récupérer la dernière version dans sharedocs (répertoire de travail Democrat de lyon)

  • analyse 1 : macro SchemaLengths avec les paramètres
    • sort_column = len
    • max_lines = 5
  • analyse 2 : macro SchemaRatio avec les paramètres
    • schema_ursql = (vide)
    • schema_property_display = REF
    • units_ursql = MENTION@ACCESSIBILITE=Forte
    • units_margin_ursql = MENTION@ACCESSIBILITE=Forte|Faible
    • max_lines = 5
    • affiche les N premiers schemas et leur score
      REF    u/f     ratio
      Dieu    5/10    0.5
      Auteur    1/10    0.1
      La moutarde    0/10    0.1
      ...
  • analyse 3 : macro UnitsIndex ou UnitsList
    • cql_limit = <p> []{5}
  • analyse 3 : macro UnitsIndex ou UnitsList
    • cql_limit = []{5} </p>
  • analyse 3 : macro UnitsIndex ou UnitsList (dépend de la présence des structures s)
    • cql_limit = <p> <s> []+ </s> <s>[]+</s>

Projection URS vers XML-TXM / CQP générique

Plusieurs résultats peuvent être obtenus par des transferts “génériques” :

  • profiter des structures d'annotation et de leurs interfaces pour organiser des annotations de type XML/CQP
  • profiter de l'interface plein texte URS pour annoter du XML/CQP
    • dans ce cas on se rapproche d'une interface d' “encodage” XML/CQP en mode auteur (à la Oxygen XML editor)
      • dans ce cas on peut se spécialiser dans les types d'annotations les plus utilisées et pas forcément gérer du 'tout TEI'
      • par exemple :
        • annotation d'entités nommées (eg <persName>) = span de quelques mots
        • annotation de notes/commentaires (eg <note type=“commentaire du lecteur”> ou <note type=“commentaire de l'auteur du texte”>) = span de quelques mots à un peu plus + interface de saisie des valeurs de propriétés multilignes et large
        • annotation de paragraphes ou sections (eg <p> ou <div>) = grand span de mots voire très grand
          • dans ce cas une stratégie de saisie d'unité de début et d'unité de fin peut être plus appropriée que celle d'une seule unité (avec construction d'une structure unique lors du transfert)
        • annotation de milestones (eg <pb/>) = span d'un seul mot avec choix de la position du milestone 'avant' ou 'après' le mot
        • annotation de mots = span d'un seul mot (avec projection sur des propriétés de mots plutôt que création de structure)
          • dans ce cas on peut aussi aider à annoter la forme du mot (par exemple 'lean' devient '[J]ean' → on crée les sous-éléments TEI au <w> nécessaires pour que l'édition présente correctement la régularisation du mot, tout en gérant la forme correcte 'Jean' dans les index
      • Remarque : le rendu des éditions de texte a des traitements spécifiques pour chacune de ces grandes catégories d'annotations. Il serait intéressant que l'infrastructure de saisie ou de transfert tienne compte de ces relations. Par exemple, il serait intéressant d'aider à visualiser, à la demande, dans l'édition d'un texte n'importe quelle structure de section (div) et ses propriétés pour faciliter le travail d'annotation de ces structures ou de sous-structures.
  • si on se met à utiliser l'interface d'annotation par Concordances pour annoter des Unités URS, ça peut ressembler à une alternative plus structurée et plus souple à l'infrastructure 'annotation par KR'
  • si on complète les interfaces d'annotation URS à Index+Concordance+Édition, avec le transfert générique on a une solution complète pour “éditer” le modèle CQP en s'appuyant sur des structures d'annotation URS dédiées (TEI, sous-éléments TEI fréquents et utiles, etc.). Cette solution permet également de développer différentes solutions pour gérer le chevauchement de structures quand c'est nécessaire. Les annotations primaires sont stand-off donc n'ont pas de contraintes de ce type. Ce n'est qu'au moment du transfert qu'on cherche à gérer la situation.

Solution

macro URSUnits2CQPStruct

(cette macro peut être appelée depuis le menu URS/Analec avec l'entrée “Créer des structures à partir des Unités” ou “Convertir Unités en Structures”)

Usage de la macro

On projette des informations XML encodées dans les unités URS pour construire des structures dans le XML-TXM, puis (potentiellement déformées : minusculisées, récursion limitée, pas de milestone) dans CQP. Par exemple, des informations d'encodage TEI pour obtenir des éléments TEI dans le XML-TXM.

Remarque : on peut créer une structure d'annotation prédéfinie dédiée à la TEI P5, avec ses éléments et leurs attributs (si les noms des éléments TEI sont encodés dans une propriété d'unité 'type', on ne pourra malgré tout pas contraindre les autres propriétés de l'unité à correspondre aux attributs de cet élément particulier). Les fonctionnalités de navigation dans les valeurs de propriétés aideront à accélérer l'annotation.

Algorithme
  • pour chaque u = une unité URS où u@type != 'mot'
    • si u@milestone = yes
      • créer un élément milestone dans le XML-TXM
        • de nom u@type (exemple 'pb')
        • située avant le u#start si u@position == 'before'
        • située après le u#end si u@position == 'after'
        • prenant pour attributs et valeurs toutes les autres propriétés de l'unité :
          • exemple, propriétéA à la valeur X → attribut 'propriétéA=“X”' (exemple n=“1”)
          • exemple, propriétéB à la valeur Y → attribut 'propriétéB=“Y”'
      • sinon créer une structure dans le XML-TXM
        • de nom u@type (exemple 'placeName')
        • commençant avant le u#start
        • terminant après le u#end
          • si la structure chevauche une structure pré-existante, on rabote sa fin jusqu'à ce qu'elle ne chevauche plus, et on explicite le rabotage dans la console
          • si d'autres structures commencent ou terminent aux mêmes mots, on place le début de la structure après ceux des structures et sa fin avant celles des structures
        • prenant pour attributs et valeurs toutes les autres propriétés de l'unité :
          • exemple, propriétéA à la valeur X → attribut 'propriétéA=“X”' (exemple n=“1”)
          • exemple, propriétéB à la valeur Y → attribut 'propriétéB=“Y”'

Extensions/Variantes possibles :

  • plutôt que de “Créer des structures à partir des Unités”, on peut “Projeter les propriétés d'Unités sur des structures existantes”
    • dans ce cas on peut cibler les structures à enrichir de différentes façons :
      • a) la structure la plus “proche” ou “basse” du premier mot de l'unité reçoit les propriétés : qui commence le plus proche du premier mot de l'unité + qui a le span le plus petit. Si plusieurs structures restent en compétition, il faudrait choisir ou trouver un autre algo plus complet
      • b) on désigne les structures par une XPath : pour chaque élément matchant la XPath, calculer le span de <w> correspondant, puis calculer les unités URS concernées par ce span de mots. Si plusieurs unités restent en compétition, il faudrait choisir ou trouver un autre algo plus complet
        Remarque : il peut être intéressant pour ce type de traitements de profiter des performances des services d'une toolkit comme LT XML 2 qui peut traiter la résolution d'XPath en streaming équivalent à du SAX pour la vitesse (on peut switcher de DOM à SAX et dans l'autre sens à n'importe quel moment du traitement).
  • [BP, 26 février 2019, interprétation dans le contexte du projet DEMOCRAT]
    • La stratégie en cas de chevauchement ne serait pas de raboter (raccourcir) la structure, mais de la fermer puis de rouvrir une structure analogue au mot suivant. Une propriété dédiée permettrait de savoir si la structure est au début de la mention ou est un bout qui prolonge la mention précédente (utile notamment pour un décompte de mentions). L'intérêt de ne pas raboter est de conserver davantage d'informations, notamment de pouvoir identifier tous les mots concernés par une mention ou une chaîne.
    • Il serait utile de disposer au niveau des unités d'informations du niveau des schémas (les schémas portent sur l'ensemble du texte et n'ont pas trop d'intérêt en tant que structures CQP).

macro URSUnits2CQPWords

(cette macro peut être appelée depuis le menu URS/Analec avec l'entrée “Projeter les propriétés des Unités sur des mots” ou “Projeter les propriétés des Unités sur leur premier mot”)

Usage de la macro

On projette des informations de mots encodées dans les unités URS pour construire des propriétés de mots dans le XML-TXM, puis dans CQP (déformées).

Algorithme
  • pour chaque u = une unité URS où u@type = 'mot'
    • ajouter au mot situé au u#start dans le XML-TXM des attributs/propriétés correspondants à toutes les propriétés de l'unité :
      • exemple, propriétéA à la valeur X → attribut 'propriétéA=“X”' (exemple pos=“N”)
      • exemple, propriétéB à la valeur Y → attribut 'propriétéB=“Y”'

Extensions/Variantes possibles :

  1. option “encoder la séquence” :
    • on crée un identifiant d'unité unique, type 'unit1', 'unit2'…
    • on encode le début du span dans le mot situé au u@start avec une propriété startOfUnit=<identifiant de l'unité>
    • on encode la fin du span dans le mot situé au u@end avec une propriété endOfUnit=<identifiant de l'unité>
  2. on peut aider à encoder des régularisation de la forme des mots (information qui a un encodage spécifique dans le XML-TXM), type 'lean' → '[J]ean'
  3. on peut aider à segmenter [la forme d']un mot en plusieurs [formes de] mots
  4. on peut aider à fusionner une séquence de mots en un seul mot

Recette

V1

Création de balises TEI “persName” à partir d'unités :

  • Déclarer le type d'unité “TEI” dans la structure :
    • ajouter la propriété “type” avec la valeur par défaut “persName” (cliquer sur la valeur pour la mettre par défaut)
    • ajouter la propriété “written” sans valeur
  • annoter 3 segments
  • lancer la macro “urs > cqp > URSUnit2CQPStructure (pas de paramètres)
  • ouvrir le fichier XML éditer et constater la présence de balises “persName”
  • mettre à jour le corpus CQP avec l'entrée “Corpus > Re-import corpus” du menu principal (il faut activer le mode expert si l'entrée n'est pas affichée)
  • faire la concordance de <persname> []+ </persname>

Création de paragraphes TEI p à partir d'unités :

  • Déclarer “p” dans la structure …

Insertion de sauts de page TEI pb à partir d'unités :

  • Déclarer “pb” dans la structure …
public/annotation/specs_annotation_analec/exploitation.txt · Dernière modification: 2019/10/28 17:40 par matthieu.decorde@ens-lyon.fr