Dans cette partie nous nous servons des étiquettes morpho-syntaxiques pour extraire une liste de termes à partir du corpus précedemment constitué.
Nous nous intéressons maintenant aux termes contenus dans le corpus, en recherchant les couples nom-adjectif. Ce patron morpho-syntaxique est parmi les plus employés en extraction terminologique française. On aurait aussi pu considérer le patron nom-préposition-nom.
La méthode d'extraction dépend bien évidemment du format du texte à analyser. Suite aux deux techniques employées pour l'étiquetage dans l'étape précedente, nous disposons de deux corpus aux formats différents.
Le texte étiqueté par TreeTagger a été structuré par le script de parcours d'arborescence en un seul grand fichier XML, où les étiquettes, les lemmes et les formes sont distingués respectivement par les valeurs type, lemma et string de l'attribut type du noeud element.
Un extrait du fichier:
<article> <element> <data type="type">NOM</data> <data type="lemma">démonstration </data> <data type="string">Démonstration</data> </element> <element> <data type="type">PRP</data> <data type="lemma">de </data> <data type="string">de</data> </element> <element> <data type="type">NOM</data> <data type="lemma">force </data> <data type="string">force</data> </element>
Cette structure nous permet d'extraire des patrons morpho-syntaxique par le biais d'une feuille de transformation d'arbres XML. A travers le langage XSL (Extensible Stylesheet Language) nous pouvons en effet choisir les chemins qui nous intéressent et vérifier que les valeurs des éléments selectionnés repondent aux critères souhaités. Ici, nous voulons récuperer les couples de noeuds element se côtoyant et dont les catégories sont NOM et ADJ.
Voilà à quoi ressemble l'instruction XSL: le premier xsl:when sert à selectionner les NOM suivis d'un ADJ et à les afficher en rouge, le second est pour les ADJ précédés d'un NOM qui seront affichés en bleu.
<xsl:template match="element"> <xsl:choose> <xsl:when test="(./data[@type='type'][contains(text(),'NOM')]) and (following-sibling::element[1][./data[@type='type'][contains(text(),'ADJ')]])"> <font color="red"><xsl:value-of select="./data[3]"/></font><xsl:text> </xsl:text> </xsl:when> <xsl:when test="(./data[@type='type'][contains(text(),'ADJ')]) and (preceding-sibling::element[1][./data[@type='type'][contains(text(),'NOM')]])"> <font color="blue"><xsl:value-of select="./data[3]"/></font><br/> </xsl:when> </xsl:choose> </xsl:template>
Le texte étiqueté par Cordial n'est pas aussi facilement exploitable. Le format est tout de même assez régulier pour être traité automatiquement. Sur chaque ligne nous trouvons la forme, le lemme et la catégorie du mot, les trois éléménts étant séparés par des tabulations.
Nous utilisons un script Perl écrit par Benoît Habert, qui prend en paramètre un fichier issu de Cordial et un fichier de patrons morphosyntaxiques recherchés (un par ligne) et extrait les suites de tokens correspondant aux patrons.
Le programme parcourt le fichier et créé d'abord trois tableaux de scalaires:
Un extrait du script: la création des trois tableaux.
while (<FIC>) # Lecture ligne par ligne. Aucun nom de variable n'est explicité (cf. while ($ligne=<FIC>) ) { # Chaque ligne est donc stockée dans une variable par défaut qui s'appelle: $_ my $ligne=$_; chomp $ligne; # Efface l'éventuel retour à la ligne my @liste=split(/\t/,$ligne);# Création d'un tableau à partir du fichier étiqueté par Cordial # (dans lesquels les champs sont séparés par des tab) # exemple: les Le DETMP # résultat: $liste[0]== les $liste[1]== Le $liste[2]== DETMP push(@token, $liste[$i++]." "); # push : insère ( par concaténation) dans le tableau donné en 1er arg. les objets donnés en 2ème, 3ème etc. arguments # $i++ : POST-INCREMENTATION : i est incrémenté APRèS l'exécution de l'instruction push(@lemme, "$liste[$i++]" ." "); push(@patron, "$liste[$i++]" ." "); $i=0; } #on a 3 listes @token, @lemme, @patron
Après une longue et difficile interprétation du script Perl, nous avons considéré une solution alternative beaucoup plus simple. Au lieu d'extraire les patrons directement à partir de la sortie de Cordial, nous passons par le format XML, exactement comme nous avons fait pour la sortie de TreeTagger.
Pour ce faire, il faut adapter le script ttagger2xml.pl au format de l'étiquetage Cordial...
Bonne nouvelle! c'est pratiquement le même format (un mot par ligne, avec lemme et étiquette, séparés par des tabulations). A une différence près: l'ordre des trois éléments.
Un extrait du script cordial2xml.pl: l'ordre des éléments a été modifié.
$Ligne=~/([^\t]*)\t([^\t]*)\t(.*)$/; $mot=$1; $lemme=$2; $cat=$3; chomp($mot); chomp($lemme); chomp($lemme); chomp($cat); $Ligne="<element>\n <data type=\"type\">$cat<\/data>\n <data type=\"lemma\">$lemme<\/data>\n <data type=\"string\">$mot<\/data>\n<\/element>\n"; print Sortie $Ligne;
Le fichier ainsi obtenu a la même structure que celui contenant la sortie de TreeTagger. Nous pouvons donc appliquer la même feuille XSLT, sans oublier de modifier le nom des étiquettes recherchées (NC au lieu de NOM).
Maintenant quoi faire des données extraites?
Le langage XSL gère aussi le format de sortie des données récupérées. Les patrons ainsi extraits peuvent être imprimés dans un autre fichier XML, insérés dans un tableau html, ou encore simplement imprimés, un par ligne, dans un fichier de texte simple. Tout dépénd de l'usage auquel la liste est destinée.
Pour l'affichage nous pouvons par exemple générer un tableau html à une seule colonne où les noms s'affichent en rouge et les adjectifs en bleu (tableau html des patrons NOM-ADJ).
Voici la partie de la feuille qui genère le tableau html à partir de l'étiquetage de Cordial (feuille XSL des patrons NOM-ADJ):
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="2.0">
<xsl:output method="html"/> # génération d'un document html
<xsl:template match="/">
<html>
<body bgcolor="#81808E">
<table align="center" width="50%" bgcolor="white" bordercolor="#3300FF" border="1">
<tr bgcolor="black">
<td width="90%" valign="top"><font color="white"><h1>Extraction de patron <font color="red"><b>NOM</b></font> <font color="blue"><b>ADJ</b></font></h1></font></td>
</tr>
<tr><td>
<blockquote><xsl:apply-templates select="./PARCOURS/ETIQUETAGE/document/article"/></blockquote></td></tr>
</table>
</body>
</html>
</xsl:template>
...Et celle qui selectionne les éléments à afficher:
<xsl:template match="element"> # règle à appliquer à chaque noeud ELEMENT
<xsl:choose>
<xsl:when test="(./data[@type='type'][contains(text(),'NC')]) and (following-sibling::element[1][./data[@type='type'][contains(text(),'ADJ')]])">
<font color="red"><xsl:value-of select="./data[3]"/></font><xsl:text> </xsl:text>
</xsl:when>
<xsl:when test="(./data[@type='type'][contains(text(),'ADJ')]) and (preceding-sibling::element[1][./data[@type='type'][contains(text(),'NC')]])">
<font color="blue"><xsl:value-of select="./data[3]"/></font><br/>
</xsl:when>
</xsl:choose>
</xsl:template>
Pour des traitements textuels automatiques, une simple liste de patrons en format txt suffit. Le blanc séparant les NOM des ADJ, comme tout autre caractère d'espacement à imprimer dans la sortie, peut être inclus dans la balise <xsl:text> (feuille XSL des patrons NOM-ADJ, format txt).