XSLT :

La première méthode afin d'extraire des patrons morpho-syntaxiques serait le recours a des feuilles de style XSLT. Notre fichier de sortie étant au format XML, cela semble être la méthode la plus simple à mettre en oeuvre. On a alors écrit une feuille de style XSLT comme suit :
(exemple pour la sortie TreeTagger)


On itère simplement sur les noeuds contenant les annotations morpho-syntaxiques, et pour chaque noeud, si le noeud actuel correspond à une position syntaxique et que le noeud frère suivant direct en correspond à une autre, on extrait les deux noeuds. Il suffit d'ajouter plusieurs noeuds frère afin d'allonger la longueur du patron à extraire. Les feuilles de style XSLT sont disponibles ici.
Voici également l'ensemble des patrons que nous avons extrait à l'aide de ces feuilles :


PERL :

On peut également extraire les patrons visés à l'aide d'un script. Il s'agit d'une méthode bien moins commode que la précédente mais nous en avons fait un en perl pour la sortie Talismane.

 
	

#!/usr/bin/perl
use strict;
#-------------------------------------------------
# Definition du patron
my @terme=("V","DET","NC");
#-------------------------------------------------
# Ouverture du fichier TALISMANE
open(FIC,"<:encoding(utf8)",$ARGV[0]);
#-------------------------------------------------
# Lecture du fichier TALISMANE
my @BIGLISTE=();
while (my $ligne = <FIC>) {
    $ligne =~s/\r//;
    if ($ligne !~ /^$/) {
        my @petite_liste = split(/\t/, $ligne);
        print "PL : @petite_liste\n";
        push (@BIGLISTE,\@petite_liste); 
        }
    else {
		
        print "ici je peux traiter BIGLISTE\n";
		print "return pour continuer....\n";
        #print "@BIGLISTE\n";
        #print "voici le prmemier mot de le phrases traitée\n";
        #print "$BIGLISTE[0]->[1]\t";
        #print "$BIGLISTE[0]->[3]\n";
        #print "$BIGLISTE[1]->[1]\t";
        #print "$BIGLISTE[1]->[3]\n";
        #print "$BIGLISTE[2]->[1]\t";
        #print "$BIGLISTE[2]->[3]\n";
        my $compteur=0;
        foreach my $element(@BIGLISTE) {
            $compteur++;
            my $countterme=0;
            if ($terme[$countterme] eq $element->[3]) {
                print "MATCH, de $element->[1] au rang $compteur\n";
                my $chaine="";
                my $extract="";
                for (my $k=$compteur-1;$k<$compteur+$#terme;$k++) {
                    print "$BIGLISTE[$k]->[3]\n";
                    if ($BIGLISTE[$k]->[3] eq $terme[$countterme++]) {
                        $chaine=$chaine.$BIGLISTE[$k]->[3];
                        $extract=$extract . " " . $BIGLISTE[$k]->[1];
                        #print "==>ICI CHAINE : $chaine\n";
                        }
                    
                    }
                if ($chaine eq join("",@terme)) { print "MATCH COMPLET a rang $element->[3]\n";
                print "$extract\n";
                    }
                
                
            }
        
        }
        my $pause=<STDIN>;
		#------- TRAITEMENT DE BIGLISTE A FAIRE
		
		#-------- FIN DE TRAITEMENT DE BIGLISTE
		#-------- On vide BIGLISTE
        @BIGLISTE=();
    }
}
#-------------------------------------------------
close(FIC);

Il s'agit pour chaque phrase, de split la sortie Talismane en plusieurs strings que l'on insère dans une liste, avec la fonction split() justement. On ajoute ensuite la liste dans une plus grande liste. Il ne reste plus qu'à comparer chaque liste de la grande liste avec une liste des positions syntaxiques que l'on veut prélever. Si la position syntaxique des deux listes correspond, on extrait le mot de la liste actuellement lue et on incrémente l'indice de la liste des positions syntaxiques.


XQuery :

La méthode la plus rapide et efficace reste tout de même XQuery. Avec une simple requête, on peut obtenir le même résultat qu'avec les deux précédentes. Il ne reste plus qu'à enregister le fichier :
(Exemple avec le patron Nom + Adjectif, TreeTagger)