Nativement, l'analyseur FRMG produit des forêts partagées de dérivations TAG, indiquant l'ensemble des opérations TAG (substitution, adjonction, ...) effectuées, sur quel noeud et avec quel arbre. Ces forêts de dérivation sont ensuite converties en des forêts de dépendances. Intuitivement, l'idée (classique) est qu'une opération TAG consistant à appliquer un certain arbre β sur le noeud N d'un arbre α se traduit par une dépendance étiquetée N allant du mot ancre de α vers le mot ancre de β. Le principe est étendu pour matérialiser les opérations sur les noeuds lexicaux et sur les noeuds co-ancre. Néanmoins, ce schéma de conversion assume que tous les arbres élémentaires possèdent une ancre lexicale, ce qui n'est pas toujours le cas pour les arbres de FRMG. Dans ce cas, une pseudo-ancre lexicalement vide est utilisée comme tête ou cible des dépendances [1].

En pratique, les forêts partagées de dépendances sont représentées en XML pour le schéma DepXML. Ce même schéma est aussi utilisé après désambiguisation de la forêt. Il existe une visualisation graphique de ce format, utilisée par défaut sur ce wiki et également par le serveur de parseurs (parserd) et le nouveau shell pour FRMG (frmg_shell).

La forme graphique de DepXML permet essentiellement de visualiser

1. des clusters (<cluster>) associés aux formes d'une phrase;
2. des noeuds ( (<node>)) inclus dans les clusters précisant un lemme, une partie du discours (comme nc pour un nom ou v pour un verbe) et un arbre de la grammaire en cas d'ancrage par le mot en question. Les pseudo-ancres donne des noeuds lexicalement vides, mais possédant néanmoins comme catégorie syntaxique celle de la racine de l'arbre élémentaire associé;
3. des arcs (<edge>) liant un noeud gouverneur à un noeud gouverné, associé par la couleur à un type d'opération TAG (substitution en bleu clair, adjonction en rouge avec ligne pointillée, co-ancrage ou lexical en violet, skip en vert), et portant un label. Ce label dénote en général une fonction syntaxique (comme sujet) dans le cas des opérations de substitution et de co-ancrage, et la catégorie syntaxique du gouverneur dans le cas des adjonctions.

La forme graphique de DepXML ne présente qu'une petite partie des informations fournies par ce format. En sus des éléments précédemment évoqués, le schéma DepXML fournit des informations:

• sur les constituants maximaux couverts par les arbres élémentaires, représentés par des balises <op>. Ainsi, le listing 1 fournit les informations sur le constituant nominal (catégorie N2) une pomme, à savoir féminin singulier 3ème personne non humain non temporel ...
• sur des hypertags (<hypertag>) fournissant, sous forme de structures de traits, les informations ayant permis d'ancrer un arbre de la grammaire par un mot de la phrase. Ces informations sont essentiellement pertinentes pour les verbes et fournissent la valence verbale de ceux-ci (pour les arguments arg0, arg1 et arg2), ainsi que sur la diathèse (diathesis), le contrôle (ctrsubj), .... Pour chaque argument est fourni la fonction grammaticale (function), le type (kind), la réalisation syntaxique (real), l'introducteur éventuel (pcas), l'extraction éventuelle (extracted). Le listing 2 montre ainsi l'hypertag associé au verbe ditransitif donner dans la phrase «il donne une pomme à Marie».
• sur des dérivations, non explicitement représentées mais en fait présentes au coeur des autres éléments, mais essentiellement importantes avant désambiguisation. Une dérivation groupe en effet un ensemble d'arcs pour un noeud gouverneur, définit un certain constituant (comme un Groupe Nominal N2), et est attaché à un hypertag (si l'arbre sous-jacent est ancré). Dualement, avant désambiguisation, un noeud peut être gouverneur pour plusieurs dérivations, un arc peut être utilisé pour plusieurs dérivations, et un constituant ou un hypertag peuvent être associés à plusieurs dérivations.

Il est évident que le schéma DepXML pourrait être grandement simplifié dans le cas de la représentation d'une seule analyse (au lieu d'une forêt partagée d'analyse). En particulier, les informations présentes dans <node>, <op> et <hypertag> pourraient être regroupées au sein de <node>. Les balises <deriv> pourraient aussi être éliminées ainsi que toute mention aux dérivations.

<op cat="N2" deriv="d3" id="E1o5" span="2 4">                  
    <narg type="top">                  
      <fs>                  
        <f name="wh"><minus></minus></f>                  
        <f name="time"><minus></minus></f>                  
        <f name="sat"><plus></plus></f>                  
        <f name="person"><val>3</val></f>                  
        <f name="number"><val>sg</val></f>                  
        <f name="hum"><minus></minus></f>                  
        <f name="gender"><val>fem</val></f>                  
        <f name="enum"><minus></minus></f>                  
        <f name="countable"><plus></plus></f>                  
      </fs>                  
    </narg>                  
  </op>

Listing 1 : <op> pour une pomme dans il donne une pomme à Marie

<hypertag derivs="d4" id="E1ht0001">                  
    <fs>                  
      <f name="anchor"><val>donne</val></f>                  
      <f name="refl"><minus></minus></f>                  
      <f name="imp"><minus></minus></f>                  
      <f name="diathesis"><val>active</val></f>                  
      <f name="cat"><val>v</val></f>                  
      <f name="arg0">                  
        <fs>                  
          <f name="function"><val>suj</val></f>                  
          <f name="kind"><val>subj</val></f>                  
          <f name="real"><val>cln</val></f>                  
          <f name="pcas"><minus></minus></f>                  
          <f name="extracted"><minus></minus></f>                  
        </fs>                  
      </f>                  
      <f name="arg1">                  
        <fs>                  
          <f name="function"><val>obj</val></f>                  
          <f name="kind"><val>obj</val></f>                  
          <f name="real"><val>N2</val></f>                  
          <f name="pcas"><minus></minus></f>                  
          <f name="extracted"><minus></minus></f></fs>                  
      </f>                  
      <f name="arg2">                  
         <fs>                  
          <f name="function"><val>objà</val></f>                  
          <f name="kind"><val>prepobj</val></f>                  
          <f name="real"><val>PP</val></f>                  
          <f name="pcas"><val>à</val></f>                  
          <f name="extracted"><minus></minus></f>                  
        </fs>                  
      </f>                  
    </fs>                  
  </hypertag>

Listing 2 : <hypertag> pour donne dans il donne une pomme à Marie

Références

L'analyseur FRMG produit par défaut des sorties en dépendances suivant le schéma DepXML, avec des dépendances reflétant directement les structures de la grammaire sous-jacente. Les sorties peuvent être affichées sous forme graphique, mais correspondent en fait à un format XML assez riche [1].

Néanmoins, les sorties peuvent aussi être converties vers d'autres schémas et formats, incluant:

• le schéma DepXML en format DepCONLL, un format tabulaire à la CONLL, légèrement étendu pour pouvoir représenter les deux niveaux des tokens et formes

Ce schéma DepConll peut bénéficier des simplifications apportées par l'option transform de l'analyseur qui cherche à faire disparaître les noeuds vides (non lexicalisés). Cette option est cependant encore instable !

• le schéma EASy/Passage (associé à un format XML), utilisé lors des campagnes d'évaluation EASy et Passage. Ce schéma s'appuie sur un mélange de 6 types de chunks et de 14 types de relations entre formes ou chunks (voir le manuel d'annotation utilisé dans le cadre du projet PASSAGE)

• le schéma Dépendance FTB, utilisé pour la représentation en dépendances du French Tree Bank (FTB), et représenté par le format tabulaire CONLL (plus d'information sur la page BONSAI d'ALPAGE)

• le schéma Dépendance Sequoia, une variante du schéma précédent, un peu plus précis dans les types de dépendances
• (nouveau) le schéma Universal Dependency, un format tabulaire (comme CONLL), sous sa forme instanciée pour le français. La conversion vers ce schéma est encore très expérimentale, en particulier du fait que la variante française n'est pas totalement spécifiée.

Références

Pour essayer de rendre plus homogènes les configurations et les simplifier, un mécanisme de réécriture de graphe est en cours de développement. Les points principaux concernent:

• la suppression de la plupart des pseudo-noeuds lexicalement vides, en sélectionnant une tête plausible parmi les noeuds gouvernés par le pseudo-noeud. Par ordre de priorité décroissant, on choisit une tête accessible par un arc de substitution, ou un arc de co-ancrage, ou enfin un arc lexical.
• la re-routage de certains arcs pour mieux correspondre à des dépendances profondes. Par exemple, le transfert des sujets post-clitiques de l'auxiliaire vers le verbe principal, ou les cas d'extraction de génitif profond dans «il lui coupe les cheveux».
• le renommage de certains labels, en particulier pour les adjonctions. On peut ainsi envisager de renommer des fonctions syntaxiques en rôles thématiques (par exemple pour le passif).
• éventuellement, on peut envisager de passer d'arbres de dépendances en graphes de dépendances, en matérialisant, par exemple, des arcs pour le contrôle. Néanmoins, cette évolution amènerait à sortir du cadre du format DepXML.

Pour l'instant, les transformations entraînent des problèmes avec l'interprétation DepXML, en particulier avec l'idée qu'une dérivation groupe des arcs partant d'un même gouverneur. Pour cette raison, la transformation n'est pas activée par défaut. Elle peut néanmoins être testé en cochant l'option 'transform' dans l'interface de visualisation.

Nous donnons ici quelques éléments d'information sur les performances de FRMG, en terme de qualité sur divers corpus de test et métriques. Nous fournissons également des informations sur le taux de couverture par analyses complètes, sur divers styles de corpus. Enfin, même si ce n'est qu'indicatif, des informations sur les vitesses d'analyse, désambiguisation, et conversion

• [1] FRMG: évolutions d'un analyseur syntaxique TAG du français
• [2] Improving a symbolic parser through partially supervised learning
• [3] premiers résultats pour FRMG sur le corpus EASy

Améliorations grâce à l'utilisation de techniques de fouilles d'erreurs [4] sur les échecs d'analyse de gros corpus.

Le tableau suivant, issu de [2], donne, pour quelques corpus, quelques éléments d'information sur le taux de couverture par analyse complète (les autres phrases étant couverte par des analyses robustes). Le tableau fournit aussi les temps d'analyse moyens et médians.

Le tableau suivant, issu de [2], donne des éléments d'évaluation de FRMG sur divers treebanks (FrenchTreeBank, Sequoia, EasyDev), pour divers schéma d'annotation (schéma FTB pour FTB et Sequoia; schéma Easy/Passage pour EasyDev) et avec 2 métriques (LAS pour le schéma FTB sans prise en compte des poncuations; F1-mesure sur les relations pour EasyDev). Les résultats, au moins sur le FTB, peuvent être comparés avec les ceux obtenus par des analyseurs syntaxiques (Berkeley, MALT, et MST) entraînés sur la partie FTB train (voir cette page pour plus d'information).

DYALOG-SR est un analyseur statistique par transitions (type MALT) s'appuyant sur des techniques de programmation dynamique et des faisceaux (beam). Comme FRMG, Il est lui-aussi implémenté au dessus du système DyALog. Une expérience récente a consisté à utiliser les sorties de FRMG comme traits de guidage pour DYALOG-SR [5], donnant d'excellents résultats sur le FTB, mais également sur le corpus SEQUOIA.

Toujours dans [5], nous avons quelques résultats plus précis qui tendent à confirmer la stabilité de FRMG (et d'analyseurs couplés avec FRMG) sur des domaines autres que journalistiques (l'augmentation du taux d'erreurs est plus faible en absolu [delta(err)] et relatif [%delta(err)] pour FRMG). Après correction d'une mauvaise utilisation des traits morphosyntaxiques produits par FRMG sur Sequoia, nous fournissons également des résultats mis à jour (Sept. 2014).

Références

FRMG s'inscrit dans la chaine de traitement alpc développée par ALPAGE et installable via l'installeur alpi (Note: il est préférable d'utiliser la version d'alpi dockerisée). L'ensemble des logiciels de cette chaîne sont disponibles sous licence libre.

Alpc fonctionne sous les environnements Linux et MacOS. Elle est installable de deux façon, via gitlab en local, ou via docker dans un containeur

1) Installation via Docker - construction locale (voie recommandée)

Ce type d'installation nécessite d'avoir sur sa machine le logiciel docker qui fonctionne, et le daemon docker qui tourne en arrière plan. (Suivre les étapes d'installation de la documentation officielle selon votre OS).

Un docker est un containeur, qui (de façon très synthétique) permet de faire de la virtualisation légère, en se comportant comme une VM qui partage des ressources avec son hôte.

En construisant l'image docker, vous installez un containeur sous linux sur votre machine, et vous pourrez ensuite acceder à la chaine de traitement depuis ce containeur en ligne de commande.

Pour construire l'image Docker, suivez les instructions du Readme qui se trouve ici: https://gitlab.inria.fr/almanach/docker_webservices/, sur les informations d'installation de alpi.

2) Installation via Docker - récupération d'image sur le dockerhub (voie recommandée)

Ce type d'installation nécessite d'avoir sur sa machine le logiciel docker qui fonctionne, et le daemon docker qui tourne en arrière plan. (Suivre les étapes d'installation de la documentation officielle selon votre OS).

Les images Docker (attention, lourdes, environ 10Ga) sont directement récupérables sur le dockerhub de almanach, à l'adresse suivante: https://hub.docker.com/r/almanach/alpi/

La commande à effectuer est docker pull almanach/alpi:v01.

Sous Windows 10:

• Si l'installation ne démarre pas simplement avec "docker run almanach/alpi:v01", il est possible de la démarrer manuellement en effectuant la commande "docker run -it almanach/alpi:v01 sh" dans Windows Powershell. Ensuite, dans le container Docker, on doit exécuter les commandes "bash" suivi de "./alpi.pl". Note: la commande suivante "source /root/exportbuild/sbin/setenv.sh" ne fonctionne pas si on n'opère pas dans une console bash.
• Il est possible que le frmg_shell ne trouve pas le fichier CGI.pm. Un message d'erreur plutot long et contenant "Can't locate CGI.pm" apparait. Pour remédier à cette erreur, il faut trouver le fichier CGI.pm et le copier dans l'un des dossier mentionnés dans la liste @INC. La commande "cp ~/usr/local/share/perl/5.22.1/AppConfig/CGI.pm ~/usr/local/share.perl.5.22.1/" devrait résoudre le problème.

3) Installation locale

Pour obtenir la dernière version d'alpi sous gitlab, utiliser

git clone https://gitlab.inria.fr/almanach/alpi

la commande alpi se trouve ensuite dans le répertoire alpi/.

L'installation de Alpc à partir des sources (sous gitlab) est possible, mais la compilation des composants nécessite une machine relativement puissante, de la mémoire (2 à 4 Go), et de l'espace disque (au moins 10Go). L'utilisation de la chaîne requiert cependant moins de mémoire (en général).

Pour installer la chaîne avec alpi, depuis le dossier alpi:

perl ./alpi

Plus d'info, avec

perldoc ./alpi/alpi

ou

perl ./alpi/alpi --help

En cas de problème d'installation, ne pas hésiter à nous contacter, en joignant le fichier 'alpi.log' produit par alpi, et en fournissant des indications sur votre environnement (distribution, architecture, ...).

Certains packages peuvent être longs à installer (comme sxpipe, aleda et frmg). Pour éviter certaines recompilations en cas de problème ou de mise à jour, il est possible d'ignorer des packages avec skippkg

perl ./alpi/alpi --prefix=<where to install> --skippkg sxpipe --skippkg aleda

Une fois installée la chaîne de traitement Alpc, quatre modes d'utilisation sont disponibles, à savoir:

• utilisation directe en ligne de commande
• utilisation via le shell FRMG (frmg_shell)
• utilisation d'un serveur de parseur (parserd)
• utilisation d'un service Web (frmg_server.pl)

Mode ligne de commande

Ce mode est seulement présenté pour des raisons historiques et pour aider à l'intégration de FRMG.

Il s'appuie sur les commandes frmg_lexer et frmg_parser.

> echo "il mange une pomme." | frmg_lexer | frmg_parser -loop -disamb -conll           
<latency_time> 102ms           
<token> E1F5 .           
<token> E1F4 pomme           
<token> E1F3 une           
<token> E1F2 mange           
<token> E1F1 il           
Answer:           
    L = [-disamb,-conll]           
    SId = E1           
    N = 5           
    A = 0           
## sentence=E1 mode=full best=yes           
1    il    il  CL  CLS n=s|p=3|s=suj   2  suj _   _   R_subjectsubject    5           
2    mange   manger  V   V   m=ind|n=s|p=3|t=pst    0  root    _   _   R_root  -1           
3   une un  D   DET n=s    4  det _   _   R_detdet    2           
4    pomme   pomme   N   NC  n=s|s=c   2  obj _   _   R_objectobject  4           
5    .   .   PONCT   PONCT   _   2  ponct   _   _   R_ponctvoid 1

L'option '-loop' pour frmg_parser permet en fait de traiter un séquence de phrases. Il est donc possible de traiter le contenu d'un fichier

> cat myfile.txt | frmg_lexer | frmg_parser -loop -disamb -conll -multi

Par ailleurs, le lexer frmg_lexer accepte une chaîne de caractères en entrée et appelle le segmenteur sxpipe dessus. Mais il est également possible de passer au lexer le résultat d'une telle segmentation sous forme d'un DAG (ou treillis de mots).

> echo "il mange une pomme." | sxpipe | dag2udag | frmg_lexer | frmg_parser -loop -disamb -conll

Mode Shell

Le mode shell, avec la commande frmg_shell, est conseillé pour une première utilisation de l'analyseur FRMG.

> frmg_shell                 
Welcome on FRMG shell [type help for more information]                 
(default: sentence 1)> help                 
 
FRMG shell commands                 
    quit : exit this shell                 
        (alias: q | bye )                 
        ....                 
(default: sentence 1)>:conll il mange une pomme                 
...                 
## sentence=E1 mode=full best=yes                 
1    il   il  CL  CLS n=s|p=3|s=suj   2  suj _   _   R_subjectsubject    5                 
2  mange   manger  V   V   m=ind|n=s|p=3|t=pst    0  root    _   _   R_root  -1                 
3 une un  D   DET n=s    4  det _   _   R_detdet    2                 
4  pomme   pomme   N   NC  n=s|s=c   2  obj _   _   R_objectobject  4                 
[1] il mange une pomme                 
(default: sentence 1)>1:xml:|                 
...                 
(default: sentence 1)> quit                 
Goodbye ! à bientôt

La commande peut être aussi utilisée en mode batch

> echo ":xml:passage il mange une pomme." | ./frmg_shell --quiet > foo.xml

Elle peut également être utilisée pour traiter des corpus jouets. Par exemple, la commande suivante traite les phrases de mycorpus.txt pour produire des sorties en format CONLL (schéma FTB), stockées sous mycorpus/ à raison d'une phrase par fichier.

> echo "corpus mycorpus.txt mycorpus :conll" | frmg_shell --batch

ou (pour des sorties en format Passage/XML et mode robust) :

> echo "corpus mycorpus.txt mycorpus :passage:xml:robust" | frmg_shell --batch

Voici l'aide (à peu près à jour) des options de FRMG Shell

Mode Serveur

Ce mode, un peu plus compliqué à mettre en oeuvre, permet cependant le traitement de gros corpus sur des clusters de machines. Il repose sur l'utilisation du serveur parserd (qui devra tourner sur chaque noeud du cluster) et sur le contrôleur dispatch.pl qui a la charge d'envoyer les phrases du corpus aux noeuds, récupérer les résultats, et gérer les problèmes éventuels.

Le serveur parserd peut être lancé à l'aide de parserd_service, installé par alpi.

> parserd_service status           
parserd is stopped           
> parserd_service start           
Starting parserd: Running the server user=clerger group=alpage  [  OK  ]

Le traitement d'un corpus peut alors être lancé, en précisant un certain nombre d'options dans un fichier de configuration (ou directement sur la ligne de commande)

> cat mycorpus.conf           
## path to dags (word lattices) for mycorpus built with SxPipe 
# using something along: cat mycorpus/file.txt | sxpipe -u -l=fr | dag2udag > mycorpus.dag/file.udag           
dagdir mycorpus.dag/ 
# specify that that dag files use suffixes .udag or .udag.bz2 (compressed)         
dagext udag           
 
## where and how to save the results  
## the following will save everything under mycorpus.results with archives of the form <file>.tar.gz for each 
## file of the corpus, and a file per sentence in the archive. 
results mycorpus.results           
collsave           
compress           
tar           
 
## emits some statistics in <file>.log.bz2 where <file> is one of the corpus files         
time           
date           
stats           
 
## output schema for the sentences 
#dis_xmldep           
#passage 
#udep 
conll           
 
# Control of the parser 
# partial analysis           
robust 
# timeout of 300s to kill parses that takes too long           
timeout 300           
 
# Specif of the hosts and of the number of workers per host 
# two instances on nodeA 
host nodeA_1@nodeA 
host nodeA_2@nodeA 
# alternatively, the following lines use a shortcut notation for 8 instances on nodeA and 8 on nodeB 
host nodeA_%i@nodeA^i=1..8           
host nodeB_%i@nodeB^i=1..12

Et finalement,         
 
> dispatch.pl --config mycorpus.conf           
....

Mode Service Web

Le package FRMG inclut le script frmg_server.pl qui permet de lancer un service Web sous Mojolicious, par exemple en lançant

morbo ./frmg_server.pl

Des réglages de configuration peuvent être fournis dans frmg_server.conf, (voir le modèle d'exemple frmg_server.conf.sample).

Il suffit ensuite d'ouvrir une fenêtre de navigateur sur l'adresse et port retourné lors du démarrage du service (par défaut: http://127.0.0.1:3000/process) . C'est ce genre de service WEB qui est utilisé par le visualisateur de sorties syntaxiques de ce site. Il est directement accessible ici. Dans l'interface WEB, le champ 'Options' peut être rempli par les mêmes options disponible pour le shell FRMG (mais séparées par des espaces plutôt que par ':').

NOTES: pour l'instant (Mars 2018), alpi m'installe pas de base tous les éléments nécessaires au service WEB. En particulier, il faut installer le module Perl DepXML

alpi --prefix=<prefix> --pkg=DepXML

La compilation de DepXML va requérir d'autres modules Perl (Devel::Declare, B::Hooks::EndOfScope), pouvant être installés via cpanm

Cette page recense quelques exemples d'utilisation de FRMG.

• Utilisation dans le cadre de l'ANR Rhapsodie pour préparer l'annotation syntaxique de corpus oraux, ainsi que dans le cadre de l'ANR ORFEO sur des corpus écrits et oraux.
• Utilisation dans le cadre d'une tâche d'extraction de citations dans des dépêches AFP [1]. Démo Sapiens, réalisée en 2010 sur des dépêches concernant la présidentielle de 2007 et ensuite complétée par des dépêches sur la réforme des retraites en 2010. L'idée est de pouvoir chercher qui a dit quoi sur diverses thématiques, en s'appuyant sur une analyse syntaxique avec FRMG de dépêches AFP, puis l'extraction avec DPath de verbes de communications avec ses divers arguments (le sujet/agent, l'objet/thème, l'audience, ...)
• Utilisation pour le traitement de toutes sortes de corpus, plus ou moins volumineux (comme Wikipedia ou Wikisource), et exploitation des sorties d'analyse syntaxique (en format Passage essentiellement) pour l'extraction de terminologies et la constitution de réseaux de mots (en s'appuyant sur l'hypothèse distributionnelle de Harris) [2] [3] (voir des exemples sur http://alpage.inria.fr/~clerger/wnet/wnet.html et sous l'interface Libellex). Pour l'interface Libellex, on peut se connecter avec l'identifiant guest et passe guest pour ensuite choisir un réseau (par exemple allsement). Pour voir l'ensemble des arcs, cochez "related" dans la tuiles "Options ...".

• (Sept 2016) Dans la continuité des travaux précédents autour de l'hypothèse distributionnelles, les sorties de FRMG sur gros corpus ont été utilisées pour associer aux mots des vecteurs denses (word embeddings) de dimension entre 100 et 200. L'algorithme utilisé baptisé DepGlove est une variante maison de Glove, lui-même un concurrent du désormais célèbre Word2Vec. La particularité de DepGlove est de s'appuyer sur des chemins syntaxiques issus des formats DepXML ou Passage plutôt que la simple proximité dans la phrase (approche sac-de-mot). Une interface très basique permet de tester ces vecteurs et aussi de les récupérer (au format word2vec). Les vecteurs peuvent aussi être récupérés directement ici.

Capture d'écran de l'interface depglove

Références