Outils pour utilisateurs

Outils du site


public:specs_import_annotation_lexicale_auto

Spécification de l'annotation lexicale automatique

Objectif

Améliorer l'annotation lexicale automatique.

Cela concerne :

  • la tokenisation : composant de tokenisation (format des sources - dont TEI, interférence avec la segmentation en phrases orthographiques, mots simples ou composés, gestion des clitiques, des contractions “du” = “de le”, des segments disjoints “ne … pas”, des cas particuliers “parce que”, “aujourd'hui”…)
  • l'étiquetage morphosyntaxique
    • améliorer les performances
    • améliorer l'intégration des outils externes (eg TreeTagger)
      • pouvoir déléguer la tokenisation à l'outil externe (pour qu'il étiquette sur sa propre tokenisation)
      • catalogue de modèles linguistiques utilisés par ces outils associant langue et modèle
      • création d'extensions par outils externes (pouvoir choisir son étiqueteur et l'installer facilement)
      • gestion des dépendances entre outils d'annotation externes, jeux d'étiquettes et commandes TXM
    • améliorer l'intégration des systèmes d'étiquettes : interfacer les commandes avec un jeu uniforme
      • possibilité d'importer la description du jeu d'étiquettes utilisé par un corpus au moment de l'import (pour construire des interfaces adaptées : UI ou API). Voir par exemple la définition formelle très simple (plate) du jeu CATTEX http://bfm.ens-lyon.fr/IMG/xml/cattex2009.xml
      • possibilité de conversion d'étiquettes entre jeux importés et un jeu uniforme (comme Multext) (voir la table de conversion CATTEX→Multext par exemple)
      • possibilité d'interfaces entre commandes et jeux : par exemple expressions CQL des mots-outils par jeu d'étiquette
  • la lemmatisation : composant de lemmatisation
  • la relation à d'autres annotations (syntaxe, entités nommées…)
  • les stratégies de configuration de surfaces variables (absence de la ponctuation pour certains moteurs)
  • les possibilités de correction de tokenisation-étiquetage-lemmatisation
  • les possibilités de mutualisation d'outils externes, de lexiques ou de corpus d'apprentissage
    • pour les lexiques, TXM pourrait se comporter comme un client SVN de lexiques mutualisés (toute nouvelle forme graphique détectée par un import peut faire l'objet d'un ajout au lexique commun, possibilité d'associer forme+partie du discours pour décider de la nouveauté, etc.)
  • les langues concernées : Français, Arabe…

Solution

Architecture de TXM 0.8.1

Dans TXM 0.8.1, la tokenisation est réalisée par TXM et l'annotation des mots est réalisée par TreeTagger. Il n'y a pas de segmentation en phrases.

Autres architectures possibles

Deux approches en cours d'examen,

I) Annotation complètement externalisée + ré-injection par alignement de TXT [txt-zip]

(le zip est la fermeture éclair qui aligne deux séries de crochets pour se refermer)

  • a) production de TXT à partir d'éléments XML de grain de type p|ab|head (en prenant en compte les plans textuels)
  • b) segmentation en phrases + tokenisation + annotation des mots par outils externes (eg UDPipe)
  • c) ré-injection par alignement de TXT au sein du XML

II) Annotation complètement externalisée + ré-injection par alignement de tokens [token-zip]

  • a) production de tokens par TXM en prenant en compte les plans textuels (état TXM 0.8.1)
    • on peut voir le résultat comme une sérialisation composée d'événements (vue simplifiée de l'Infoset XML) :
      • début d'élément
      • fin d'élément
      • élément milestone
      • mot
      • processing instruction
      • commentaire
    • cette sérialisation correspond aux constituants du format .cqp
  • b) production de TXT à partir de séquences de <w> se trouvant dans des éléments XML englobants de grain <p|ab|head|foreign> (remarque : le balisage foreign est de niveau inférieur à celui du p)
    • la production du TXT est réalisée de façon similaire à ceci (utilisation des règles typographiques de gestion des espaces de la langue du passage ou du corpus) :
      def word = corpusEngine.cpos2Str("$corpusName.word", (start..end) as int[]).join(' ')
      def txt = LangFormater.format(word, corpus.getLang())
    • une version 1 ne prend pas en charge les balises inférieures aux mots
    • une version 2 peut restituer des cas comme la moitié d'un mot en italique (dans ce cas le balisage est repéré en amont de la génération du TXT et géré après la ré-injection)
  • c) segmentation en phrases + tokenisation + annotation des mots par outils externes (eg UDPipe) du TXT
    • l'élément englobant peut encoder une langue spécifique (code ISO à 3 caractères) pilotant les modèles à utiliser dans les outils de TAL (attribut @xml:lang)
      • sinon il faut utiliser le modèle de la langue du corpus
    • si l'absence de ponctuation forte empêche la reconnaissance de certaines phrases, comme cela arrive dans les <head> (titres), on peut être amené à ajouter des limites de phrases aux résultats des outils externes pour que tous les mots se trouvent dans une <s>
  • d) ré-injection par alignement 'tokens TXM' / 'tokens outils' externes au sein du XML
    • le réalignement permet de déterminer sur quels tokens TXM porte la synchronisation
      • les modifications de la séquence peuvent concerner : des fusions ou des segmentations de tokens (ou bien l'ajout ou la suppression)
    • une fois la synchronisation faite, on peut réinjecter les événements de la séquence aux bons endroits dans la séquence de tokens outils

L'alignement 'tokens TXM' / 'tokens outils' en d) consiste à calculer les différences entre deux séquences :

  • a) séquence des formes de tokens de TXM
  • b) séquence des formes de tokens des outils

Le calcul de leur 'Longest Common Subsequence' (1) correspond à l'établissement de la séquence des correspondances majoritaires, composée typiquement de mots simples (tokens TXM et tokens outils identiques).

Le calcul de leur diff (2), dont on peut trouver une implémentation Java en (3), et que j'ai utilisée pour écrire la macro prototype LCSMacro.groovy ci-dessous, permet d'établir les relations de fusion et de segmentation de tokens TXM.

Macro LCSMacro.groovy

// Copyright © 2021 ENS de Lyon
// Licensed under the terms of the GNU General Public License version 3 (http://www.gnu.org/licenses/gpl-3.0.html)
// @author sheiden
 
// STANDARD DECLARATIONS
package org.txm.macro
 
import org.kohsuke.args4j.*
import groovy.transform.Field
import org.txm.rcp.swt.widget.parameters.*
 
@Field @Option(name="A", usage="input string A", widget="String", required=true, def="ABCDE")
def A
 
@Field @Option(name="B", usage="input string B", widget="String", required=true, def="ACDC")
def B
 
if (!ParametersDialog.open(this)) return
 
input1  = A.toCharArray()
input2  = B.toCharArray()
M       = input1.length
N       = input2.length
 
def lcsLength(char[] input1, char[] input2) {
        opt = new int[M][N];
        for (int i = 1; i < input1.length; i++) {
            for (int j = 1; j < input2.length; j++) {
                if (input1[i] == input2[j]) {
                    opt[i][j] = opt[i - 1][j - 1] + 1;
                } else {
                    opt[i][j] = Math.max(opt[i][j - 1], opt[i - 1][j]);
                }
            }
        }
        return opt;
    }
 
strOut = ""
strOut1 = ""
strOut2 = ""
strLCS = ""
 
def printDiff(opt, input1, input2, i, j) {
        if ((i >= 0) && (j >= 0) && (input1[i] == input2[j])) {
            printDiff(opt, input1, input2, i - 1, j - 1);
            strOut += "  " + input1[i]
            strOut1 += "  " + input1[i]
            strOut2 += "  " + input1[i]
            strLCS += input1[i]
        } else if ((j > 0) && ((i == 0) || (opt[i][j - 1] >= opt[i - 1][j]))) {
            printDiff(opt, input1, input2, i, j - 1)
            strOut += " +" + input2[j]
            strOut1 += "   "
            strOut2 += " +" + input2[j]
        } else if ((i > 0) && ((j == 0) || (opt[i][j - 1] < opt[i - 1][j]))) {
            printDiff(opt, input1, input2, i - 1, j)
            strOut += " -" + input1[i]
            strOut1 += " -" + input1[i]
            strOut2 += "   "
        } else {
            strOut += ""
            strOut1 += ""
            strOut2 += ""
        }
    }
 
opt = lcsLength(input1, input2)
printDiff(opt, input1, input2, M - 1, N - 1)
 
println "A   = "+A+" ("+A.length()+")"
println "B   = "+B+" ("+B.length()+")"
println "LCS = "+strLCS+" ("+strLCS.length()+")"
println "op(A)      = "+strOut1
println "op(B)      = "+strOut2
println "diff(A, B) = "+strOut

qui produit le résultat :

A   = ABCDE (5)
B   = ACDC (4)
LCS = ACD (3)
op(A)      =   A -B  C  D -E   
op(B)      =   A     C  D    +C
diff(A, B) =   A -B  C  D -E +C

État de l'art général et pour le Français de logiciels externes mobilisables

Analyse de l'hétérographie (analyse morphologique)

Analyse morphologique et lemmatisation par apprentissage sur corpus

Analyse morphologique par projection de lexique

Analyse morphologique et étiquetage par projection de graphes/FST et lexiques

Étiquetage désambiguisé statistiquement reposant sur Unitex

Étiquetage désambiguisé statistiquement ou par règles

Liste supplémentaire de taggers

Exemples de scripts Perl de transformation d'étiquettes POS

de TreeTagger vers Multext et assistance à la correction de lemmes : https://www.ims.uni-stuttgart.de/en/research/resources/tools/lemma-correction [voir le lien “Ressourcen” / “Lemma-Korrektur”]

Transformation de jeux d'étiquettes morpho-syntaxiques

Lexiques morphologiques open-source

Corpus étiquetés libres pour l'apprentissage de modèles morpho-syntaxiques

jeux d'étiquette standard

État de l'art pour l'Arabe

Stanford Log-linear Part-Of-Speech Tagger

http://nlp.stanford.edu/downloads/tagger.shtml

Cette technologie est distribuée avec un modèle Arabe appelé 'arabic.tagger'. Il a été construit à partir de l'intégralité de l'Arabic TreeBank parties 1 à 3.

Performances : When trained on the train part of the ATB p1-3 split done for the 2005 JHU Summer Workshop (Diab split), using (augmented) Bies tags, it gets the following performance:

  • 96.26% on test portion according to Diab split
  • (80.14% on unknown words)

Corpus d'apprentissage : Arabic TreeBank parties 1 à 3 :

    • publié November 30, 2004
    • Arabe moderne standard
    • 734 dépêches de l'AFP de juillet à novembre 2000
    • 140 265 mots (168,123 tokens after clitic segmentation in the Treebank)
  • Penn Arabic Treebank partie 2 (Part 2 v 2.0 1/13/04)
    • publié 1/13/04
    • 501 articles d'Al-Hayat publiés par le site Ummah
    • 144 199 mots (counting non-Arabic tokens such as numbers and punctuation)
    • 125 698 Arabic-only word tokens (prior to the separation of clitics)
    • publié 2004
    • 600 dépêches de l'agence An Nahar
    • dated on the 15th day of each month ranging from Jan to Dec in 2002
    • 340 281 words/tokens
    • 400 213 (after clitics separation)

Tokenization

Le format précis du texte arabe en entrée n'est pas indiqué, mais j'ai trouvé ce mail de Christopher Manning dans java-nlp-user : “everything that appears on the Stanford Arabic Parser IAQ page also applies to the POS tagger (required tokenization, normalization, POS tag set used, etc.)”. Ce mail contient un fichier texte exemple en Arabe et le fichier résultat du tagger.

On trouve donc beaucoup plus de détails dans la documentation de l'autre outil apparenté, l'analyseur syntaxique de Stanford :

Résultat :

  • il faut tokenizer d'abord avec le Stanford Word Segmenter pour l'Arabe
  • puis le tagger peut prendre la tokenization calculée par l'outil amont avec l'option “-tokenize false”

Jeu d'étiquettes

Voir http://www.ircs.upenn.edu/arabic/Jan03release/arabic-POStags-collapse-to-PennPOStags.txt

Autres références à regarder

AraMorph

AraMorph est un implémentation Java open-source de l'algorithme Buckwalter.

Il tokenise et propose toutes les analyses de décomposition en préfixe-racine-suffixe.

Il gère l'UTF-8.

Il comprend des classes d'intégration dans Lucene pour l'analyse, l'indexation et l'interrogation.

MorphTagger

État de l'art pour l'Akkadien

Il y a un lemmatiseur en ligne http://oracc.museum.upenn.edu/util/atfproc.html.

Du projet http://oracc.museum.upenn.edu qui comprend les langues :

  • Sumérien
  • Akkadien
  • Proto-Cunéiforme
  • Proto-Élamite

Autres ressources à exploiter

État de l'art pour le Chinois

ZPar

Stanford Log-linear Part-Of-Speech Tagger

http://nlp.stanford.edu/downloads/tagger.shtml

Cette technologie est distribuée avec deux modèles pour le Chinois appelés 'chinese-distsim.tagger' et 'chinese-nodistsim.tagger'.

Ils utilisent le jeu d'étiquettes de la Penn Chinese Treebank.

Performances

  • chinese-nodistsim.tagger
    • Trained on a combination of CTB7 texts from Chinese and Hong Kong sources.
    • Performance:
      • 93.46% on a combination of Chinese and Hong Kong texts (79.40% on unknown words)
  • chinese-distsim.tagger
    • Trained on a combination of CTB7 texts from Chinese and Hong Kong sources with distributional similarity clusters.
    • Performance:
      • 93.99% on a combination of Chinese and Hong Kong texts (84.60% on unknown words)

Le segmenteur et le tagger pour le chinois sont téléchargeable ici.

Mecab

from Ministry of Education Institut of Applied Linguistics

Fudan University NLP

MMSEG

LTP-Cloud

Jieba, in Python

TreeTagger

Note: one bad report on this one.

État de l'art pour le Latin

Sans différentier le latin classique du néo-latin.

Lemmes désambiguisés

Toutes les analyses possibles

Corpus annotés

Littérature

Prototype d'intégration du segmenteur et tagger de Stanford pour l'Arabe

Sites

http://nlp.stanford.edu/software/segmenter.shtml#Download

http://nlp.stanford.edu/downloads/tagger.shtml

packages utiles :

  • edu.stanford.nlp.international.arabic.pipeline
  • edu.stanford.nlp.international.arabic.process

Pour l'instant

2 Macros :

  • StanfordSegmenter : segmente les mots de l'arabe (ou du chinois) des textes d'un dossier source
  • StanfordTagger : étiquete les textes d'un dossier source et les convertit au format XML/w

StanfordSegmenter

Il faut copier :

  • seg.jar dans $TXMHOME/scripts/lib
  • StanfordSegmenterMacro.groovy dans $TXMHOME/scripts/macro

Lien de téléchargement des modèles (250Mo) : http://nlp.stanford.edu/software/stanford-segmenter-2014-01-04.zip

Paramètres de la macro :

  • dossier d'entrée
  • dossier de sortie
  • fichier modèle (.ser.gz dans le dossier “data” de l'archive stanford-segmenter-2014-01-04.zip)
  • extension des fichiers à traiter

StanfordTagger

Il faut copier

  • stanford-postagger.jar dans $TXMHOME/scripts/lib
  • StanfordTaggerMacro.groovy dans $TXMHOME/scripts/macro

Lien de download des modèles (110Mo) : http://nlp.stanford.edu/downloads/stanford-postagger-full-2014-01-04.zip

Paramètres de la macro :

  • dossier d'entrée
  • dossier de sortie
  • fichier modèle (.tagger dans le dossier “models” de l'archive stanford-postagger-full-2014-01-04.zip)
  • extension des fichiers à traiter

Version courante

TreeTagger a été interfacé pour les modules d'import.

Une extension TreeTagger permet d'apprendre et de projeter sur un corpus TXM.

Recette

Protocole de test

Alpha

Beta

État courant

public/specs_import_annotation_lexicale_auto.txt · Dernière modification: 2021/10/22 11:45 par slh@ens-lyon.fr