Cet outil permet d'extraire des groupes nominaux.
La présente page est un guide d'utilisation qui est complété par le manuel de référence de l'API.
Retour au tableau des prestations
Introduction
TagExtract est un logiciel d'extraction des groupes nominaux à partir de textes. L'objectif est de faire ressortir des mots simples ou composés que l'on va appeler des termes. TagExtract est destiné à être utilisé exclusivement via une API (Application Programing Interface) Java. TagExtract ne fournit pour l'instant aucune interface interactive (IHM). Cette API est décrite en anglais dans le manuel de référence de l'API.
Exemple
Sur le texte suivant: "Il emmène une grande bouteille d'eau potable. Et il rapporte ses bouteilles de vin."
Il s'agit d'extraire par exemple, "bouteille", "grande bouteille", "eau", "eau potable", "grande bouteille de eau potable", "vin" et/ou "bouteille de vin", selon les paramètres transmis à l'API.
Notons que la plupart du temps, la totalité des combinaisons n'est pas nécessaire. Cela dépend de ce que l'on veut faire ensuite. Dans cette optique, TagExtract autorise un nombre important de paramètres afin de couvrir la plupart des usages.
Principes
On distingue schématiquement quatre méthodes pour proposer des termes :
- celles qui se fondent sur les comptages d'occurrences (méthode des comptages),
- celles qui calculent à partir de la structure interne des termes (méthode structurelle),
- celles qui reposent sur les contextes d'emploi et les distributions des termes (méthode distributionnelle),
- celles qui testent la présence ou absence de chaînes de caractères (méthode textuelle).
TagExtract implémente ces quatre méthodes qui sont combinables entre elles. Il s'agit par exemple de ne retenir que les mots qui ont une structure "adjectif + nom" et qui apparaissent au moins 50 fois.
Méthode des comptages
La méthode consiste à fixer un seuil d'occurrence du terme avec une valeur minimum et/ou une valeur maximum. Le comptage s'effectue sur la totalité du corpus. Il s'agit par exemple, de ne retenir que les termes qui apparaissent plus de 20 fois, ou bien ceux qui n'apparaissent pas plus de 2 fois.
Méthode structurelle
L'approche structurelle repose sur les relations internes entre termes complexes. Les termes proposés doivent obéir à un ou plusieurs patrons. C'est principalement la syntaxe qui est exploitée, cette approche est donc fortement dépendante de la langue choisie. La conformité à un patron syntaxique ne présume aucunement d'une proximité sémantique des mots composés qui partagent le même patron, comme par exemple dans 'attentat à la bombe' vis-à-vis de 'attentat à la DDE'.
C'est la méthode la plus fréquemment employée.
Méthode distributionnelle
L'approche distributionnelle rapproche deux à deux des termes qui partagent
les mêmes contextes. De manière symétrique, deux contextes
qui partagent les mêmes termes peuvent être liés entre eux.
Dans les phrases : "les agents bénéficient de la formation
professionnelle" et "les agents bénéficient de la formation
continue", les mots composés "formation professionnelle"
et "formation continue" (qui ne sont pas synonymes) partagent le même
contexte : "les agents bénéficient". Dans la mesure
où le traitement porte sur un résultat d'analyse, le système
est capable de s'abstraire de la présence de la suite "de la".
On définit le coefficient de partage SHARE entre deux contextes comme
étant le nombre de termes partagés par les deux contextes. On
définit le coefficient de proximité PROXI pour tenir compte de
la productivité des contextes partagés. Avec ce coefficient, nous
visons à quantifier le fait que si un contexte partagé par deux
termes est très productif , sa contribution au rapprochement de deux
termes est a priori plus faible que celle d'un contexte peu productif. Le coefficient
PROXI pour deux termes T1 et T2 est calculé par la formule :
PROXI = Somme de CONTEXTE par 1 / prod(CONTEXTE) ½
où CONTEXTE est un contexte partagé par les termes T1 et T2 et
prod(CONTEXTE) la productivité de ce contexte.
Les valeurs SHARE et PROXI sont des valeurs paramétrables par l'utilisateur
et agissent comme un seuil. Par exemple, on pourra ne retenir que les contextes
dont SHARE est supérieur ou égal à 3 et PROXI supérieur
à 0,50.
Méthode textuelle
Il s'agit simplement de faire ressortir les termes qui possèdent une certaine chaîne de caractères.
Principe d'utilisation
TagExtract est destiné à être utilisé en deux grandes phases :
1) l'extraction qui comporte deux étapes internes qui sont l'analyse et la constitution d'un index.
2) le filtrage sur cet index.
L'analyse est réalisée par le logiciel TagParser. Cela signifie que tous les aspects concernant la lecture des formats de fichiers et la segmentation sont pris en charge par TagParser. L'extraction peut comporter une détection de langues afin de ne considérer que les phrases d'une certaine langue. TagExtract ne traite qu'une seule langue à la fois. Un appel à l'extraction peut s'appliquer à un texte ou bien à plusieurs textes à la fois. Les analyses linguistiques sont indépendantes les unes des autres. Après l'analyse, les groupes nominaux et prépositionnels sont rassemblés dans un index commun à toutes les phrases.
Puis le filtrage va opérer sur l'index afin de ne retenir qu'un sous-ensemble des termes rencontrés. Le filtrage est une opération qui est déclenchée de manière distincte de l'extraction afin de permettre d'appliquer plusieurs filtrages sur un même résultat d'extraction.
Exemple d'utilisation de l'extraction
En prenant comme hypothèse que la liste des fichiers figure dans la variable "corpus", il faudra effectuer les appels suivants:
ExtractAPI e= new Extract();
//Supposons que l'on désire traiter
le français
String language= "fr";
//Supposons que les textes soient multilingues
boolean multilingual= true;
//Supposons que nous connaissions le périmètre de variation
des langues
//et que cela soit anglais et français
ArrayList<String> perimeter= new ArrayList<String>();
perimeter.add("en");
perimeter.add("fr");
//Supposons que nous sachions que les textes ne sont pas en typographie
pauvre
//(typo pauvre = majuscules sans accents)
boolean weakTypo= false;
/////////////////////////////////////appel de l'extraction
e.apply(language,multilingual,perimeter,corpus,weakTypo);
Exemple d'utilisation du filtrage
Une fois l'extraction effectuée, il faut filtrer.
FilteringAPI f= new Filtering();
//Supposons que l'on ne désire que les regroupements maximums
ArrayList<FilteringPattern> lp= new ArrayList<FilteringPattern>();
FilteringPattern fp= new FilteringPattern("MaximalNounPhrases");
fp.setTakeIt(true);
lp.add(fp);
//Supposons que l'on désire exclure tous les termes qui possèdent
//la graphie "Page"
HashSet<String> exclusion= new HashSet<String>();
exclusion.add("Page");
///////////////////////////////////////////appel du filtrage
//On utilise le filtrage structural avec une liste d'exclusion.
//On ne se préoccupe pas de la présence d'un thésaurus.
//Et on factorise les termes qui ont la même typographie pauvre.
String cr= f.apply(e,0,0,lp,0,0,"","only S",null,null,null,true,exclusion);
//On peut exploiter le résultat via l'API
mais on peut aussi
//demander l'écriture du résultat dans un fichier XML
f.writeResult("Documentation/resultatExempleDocTagExtract.xml");
Résultat de l'exemple
Le fichier comportera les balises suivantes:
<?xml version="1.0"?>
<DOCUMENT fichier="Documentation/resultatExempleDocTagExtract.xml">
<Candidate id="C1" acceptReject="0">
<lemmatised>bouteille de vin</lemmatised>
<inflected>bouteilles de vin</inflected>
</Candidate>
<Candidate id="C2" acceptReject="0">
<lemmatised>grand bouteille de eau potable</lemmatised>
<inflected>grande bouteille d' eau potable</inflected>
</Candidate>
</DOCUMENT>