extraction de patrons BAO3

Deuxième partie extraire les dépendances

Dans cette partie, nous allons utiliser les fichiers étiquetés par UDpipe puis transformés en XML. Pour extraire un gouverneur et un dépendant reliés par une relation, il faut utiliser le contenu à l'intérieur de la 7ème balise <a> dans les balises du dépendant qui indique l'index du gouverneur.

Le script perl et le script Python ne font pas l'extraction de dépendance de la même manière. En Perl, on découpe d'abord le contenu du fichier par phrase (séparer le texte grâce à la balise <p>), puis on parcourt chaque phrase, si on trouve un dépendant ayant une relation ciblée à la 8ème balise a, alors qu'on va parcourir chaque élément de la phrase jusqu'à ce que l'index d'élément corresponde à l'index du gouverneur indiqué dans les balises du dépendant.

Le bout de code ci-dessous explique le déroulement de script Perl.

                                    
# le texte découpé en phrase
while (my $phrase=<$IN>) {
    #-------------------------------------------------------------------------------------
    # on traite chaque "paragraphe" en le decoupant "items"
    my @LIGNES=split(/\n/,$phrase);
    for (my $i=0;$i<=$#LIGNES;$i++) {
        # si la ligne lue contient la relation, on ira chercher le dep puis le gouv
        if ($LIGNES[$i]=~/<item><a>([^]+)<\/a><a>[^<]+<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>([^<]+)<\/a><a>[^<]*$relation[^<]*<\/a><a>[^<]+<\/a><a>[^<]+<\/a><\/item>/i) {
            #récuoérer la position de dépendant
            my $posDep=$1;
            # récupérer la position de gouverneur
            my $posGouv=$3;
            # récupérer la dorme de dépendant
            my $formeDep=$2;
            # comparer la position de dépendant et de gouverneur, si me dépendant apprait après le gouverneur
            if ($posDep > $posGouv) {
                # déclencher une boucle qui parcourt tous les éléments avant l'index de dépendant
                for (my $k=0;$k<$i;$k++) {
                    if ($LIGNES[$k]=~/<item><a>$posGouv<\/a><a>[^<]+<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><\/item>/) {
                        my $formeGouv=$1;
                        # enregistrer les formes de gouverneur et de dépendant dans un dictionnaire
                        $dicoRelation{"$formeGouv --> $formeDep"}++;
                    }
                }
            }
            # le gouverneur apparait après le dépendant
            else {
                # déclencher un e boucle qui cherche à partir de l'index du dépendant jusqu'à la fin de ce paragraphe pour matcher le gouverneur
                for (my $k=$i+1;$k<=$#LIGNES;$k++) {
                    if ($LIGNES[$k]=~/<item><a>$posGouv<\/a><a>([^<]+)<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^<]+<\/a><a>[^ <]+<\/a><a>[^<]+<\/a><a[^<]+<\/a><a>[^<]+<\/a><\/item>/) {
                        my $formeGouv=$1;
                        # enregistrer les formes de gouverneur et de dépendant dans un dictionnaire
                        $dicoRelation{"$formeGouv --> $formeDep"}++;
                    }
                }
            }
        }
    }
}                                           
                                
                            

En python, nous avons utilisé une autre méthode. Pour chaque phrase, on crée deux variables importantes, la première est un dictionnaire qui enregistre pour chaque élément son index(clé) et son lemme(valeur), la deuxième variable est une liste de dépendants qui enregistre, pour chaque item ayant une relation ciblée, son lemme et l'index du gouverneur (lemme, head). A la fin de la phrase, on parcourt la liste de dépendants et trouve, pour chaque dépendant, le lemme de son gouverneur dans le dictionnaire grâce à l'index du gouverneur.

l'extrait de code explique le déroulement de script python

                                
# dictionnaire qui enregistre l'index et le lemme pour chaque item
sent_buf = {} 
# liste distincte qui enregistre pour chaque item ayant une indication de relation ciblés (8ème balise a ) et l'index de son gouverneur (7ème balise a)
obj_buf = []
couples = set()
dic_frequence = dict()
# parcourir chaque ligne du fichier
for line in Path(fic).read_text().split("\n"):
    # le début de phrase
    if line.startswith("<item>"):
        # matcher tous les balises a
        fields = re.findall("<a>([^<]+)</a>", line)
        # nommer les attributs avec les contenus des balises a matchés
        idx, word, lemma, tag, _, _, head, rel, _, _ = fields
        # pour chaque élément, le dictionnaire enregistre l'index comme clé, et le lemme comme valeur
        sent_buf[idx] = lemma
        # si un élément est un dépendant en ayant l'indication de la relation ciblée.
        if rel == 'obj':
            # on enregistre l'index de gouverneur et le lemme de ce dépendant dans la liste obj_buf
            obj_buf.append((lemma, head))
    # à la fin de phrase
    if line == "</p>":
        # on parcourt la liste obj_buf
        for obj_lemma, head in obj_buf:
            # trouver le lemme de gouverneur dans le dictionnaire, et mettre dans le variable couple le lemme de gouverneur et de dépendant 
            couples.add((f"{sent_buf[head]}", f"{obj_lemma}"))
            # enregistrer la fréquence de la dépendance pour un affichage plus clair
            cle = str(sent_buf[head] + '->' + obj_lemma)
            if cle not in dic_frequence :
                dic_frequence[cle] = 1
            else : 
                dic_frequence[cle] += 1
        # vider le dictionnaire et la liste buf pour la phrase prochaine
        obj_buf = []
        sent_buf = {}
                                        
                                    
                                

Pour extraire les éléments en dépendances, nous pouvons aussi utiliser XSLT et XQuery qu'on a réalisés dans le cadre du cours dfocument structuré.