Les Verbes Français (LVF) en format JSON-lines

JSON est un langage de balisage souvent utilisé dans le domaine du TAL, pour lequel plusieurs outils de manipulation très efficaces ont été développés. Ce document présente l'organisation du LVF ainsi que des exemples simples d'utilisation de cette version.

Elle est en format JSON lines: chaque entrée du lexique est une ligne du fichier et chaque ligne est une expression JSON qui peut être traitée facilement avec toute librairie manipulant ce type de données. Le fait que chaque entrée soit une seule ligne facilite les extractions par des outils tels que jq ou même grep. Ces extractions peuvent ensuite être manipulées facilement avec d'autres outils bien connus des informaticiens-linguistes.

Les prochaines sections décrivent le format JSON pour LVF et donnent quelques exemples d'utilisation avec l'outil jq. Vous pourriez consulter cette excellente introduction à jq.

Les descriptions se limitent à donner les noms de champs qui sont identiques à ceux des documents originaux. Ces descriptions sont formalisées sous la forme d'un JSON-RNC, un formalisme inspiré de la forme compacte de Relax-NG, mais qui devrait être familière à quiconque connaît JSON. Ceci sert non seulement de documentation, mais aussi d'outil de validation des entrées ce qui en garantit le format attendu.

Une description d'un enregistrement JSON-RNC est une liste de champs, chacun suivi du type de la donnée attendue. À priori, un champ est obligatoire à moins d'être suivi par un point d'interrogation (?). Certaines contraintes supplémentaires peuvent être ajoutées: par exemple, les valeurs minimum ou maximum, la longueur d'une liste ou une expression régulière qui correspond aux valeurs acceptables pour ce champ. Ces contraintes apparaissent entre parenthèses précédées de @ après le nom du type de la valeur. Comme les contraintes d'expression régulière sont très fréquentes, il est possible d'indiquer cette expression régulière entre deux obliques (/.../) au lieu d'indiquer string@(pattern="...").

Description d'une entrée

Une entrée du LVF est composée des champs suivants, calqués sur la version LVF+1 publiée par Paul Sabatier avec quelques regroupements:

Voici un exemple de la première entrée pour le verbe abaisser. L'indentation qui permet de faire ressortir la structure n'est évidemment pas présente dans le format JSON lines, où toute l'entrée est placée sur une seule ligne.

{"ID":1,
 "MOT":{"code":"abaisser 01",
        "no":1,
        "verbe":"abaisser"},
 "DOMAINE":{"clair":"locatif, lieu",
            "code":"LOC"},
 "OPERATEUR":"(#) [r/d] bas qc",
 "CLASSE":"T3c",
 "SENS":"baisser",
 "PHRASE":["On a~ le rideau de fer, le store.","Le rideau du magasin s'a~."],
 "CONJUGAISON":"1bZ",
 "CONSTRUCTION":["T1308","P3008"],
 "DERIVATION":{"adjectifs":["abaissable"],
               "code":"1-- -1 --RA --",
               "noms":["abaissement","abaisseur"]},
 "LEXIQUE":2,
 "NOM":{"code":"-I"},
 "DEM":true}

Les dérivations adjectivales, nominales ainsi que le déverbal sont explicités plutôt que d'être signalés sous forme d'indicateurs comme dans la version originale.

Schéma

Le fichier LVF.jsonl contient 25 609 entrées correspondant à 12 308 verbes français différents. Voici le schéma qui décrit une entrée JSON du LVF. 


start = LVF-entree
LVF-entree = {
    ID: integer@(exclusiveMinimum=0),
    MOT: {
        code:string,
        verbe:string,
        no:integer@(exclusiveMinimum=0)
        forme-etre?:string,
        pronominal?:string,
        autre-forme?:string,
        negative?:string,
        complement?:string
    },
    DOMAINE: {
        code:string,
        clair:string,
        niveau?:string,
        region?:string
    },
    OPERATEUR: string,
    CLASSE: string,
    SENS: string,
    PHRASE: [string],
    CONJUGAISON: string,
    CONSTRUCTION: [string],
    DERIVATION: {
        code:string,
        adjectifs?:[string],
        noms?:[string]
    },
    LEXIQUE: integer@(minimum=1,maximum=6),
    NOM: {
        code: string,
        nom?: string
    }
    DEM:boolean
}

Exemples d'utilisation avec jq

Le format jsonl est très pratique pour les extractions et les combinaisons avec d'autres outils Linux. Par exemple, pour obtenir les verbes du 2e groupe, il suffit d'écrire

jq 'select(.CONJUGAISON|startswith("2"))' < LVF.jsonl

qui sortira une version indentée de toutes les entrées des verbes du deuxième groupe. Mais si on ne veut que les compter, il suffit de demander à jq de produire une sortie compacte avec -c c'est à dire une valeur JSON par ligne et utiliser un outil Linux pour manipuler la sortie. Ainsi 

jq -c 'select(.conjugaison.groupe=="2")' < LVF.jsonl | wc -l

retournera 1236 qui correspond au nombre d'entrées de verbes du deuxième groupe. Mais si on ne veut avoir que les verbes eux-mêmes sans doublon, on peut compléter la requête en se limitant à sortir le mot. Comme les mots sont déjà triés, on peut utiliser la commande uniq de Linux pour ne garder qu'une seule occurence de chaque verbe. Ainsi

jq -c 'select(.conjugaison.groupe=="2")| .MOT.verbe' < LVF.jsonl | uniq | wc -l

retournera 515.

Ces quelques exemples montrent la facilité avec laquelle on peut combiner les informations avec d'autres outils de Linux pour manipuler le format JSON de LVF. Évidemment, il est possible d'effectuer des traitements plus complexes, mais ces quelques exemples devraient permettre d'imaginer d'autres utilisations.

Accès aux ressources