---

Le reconnaissance et l'extraction d'entités nommées (NER) d'un texte écrit en langage naturel se fait souvent en langage Python avec Nltk ou avec Spacy.

Elle doit s'appuyer sur un modèle préentraîné ou sur un modèle qu'il faudra avoir entraîné préalablement à partir d'un fichier texte contenant des entités reconnues.

Ce fichier contenant les données pour l'entraînement sera formaté par exemple sur deux colonnes (ici séparées par un simple espace) :

En O
2019 DAT
, O
Aurorae B-ORG
Solutions I-ORG
a O
mis O
à O
jour O
son O
site O
internet O
. O
Hébergé O
en O
France I-LOC 
, O
ce O
site O
web O
fonctionne O
désormais O
avec O
la O
dernière O
version O
de O
chora O
. O
Ce O
logiciel O
a O
été O
écrit O
par O
Fabrice B-PER
Philibert I-PER
- I-PER
Caillat I-PER
. O

Un tel format de présentation des données est nommé IOB (Ramshaw & Marcus, 1995).

Dans l'exemple ci-dessus, les entités sont étiquetées comme suit :

DAT (date),

PER (personne),

LOC (lieu)

ORG (organisation)...

Pour délimiter les entités nommées qui s'étendent sur plusieurs termes, les étiquettes sont éventuellement préfixées par B- (début de l'entité) ou I- (interne à l'entité). Enfin les autres termes sont étiquetés O (hors de l'entité).

Entraînement d'un modèle

La tache qui consiste à entraîner un modèle à partir de telles données est grandement simplifiée par l'utilisation de l'étiquetteur pour l'extraction d'entités nommées de Stanford (ou Stanford NER Tagger), qui est écrit en langage Java.

Pour pouvoir fonctionner, celui-ci nécessite donc :

-un environnement Java (java JRE version 8+),

-le fichier du moteur de l'étiquetteur au format jar (ner-tagger.jar),

-le fichier de données pour l'entraînement (contenant les entités idéntifiées par des étiquettes, ici dataset.tsv)

-et enfin un fichier de propriétés qui précise les paramètres de l'entraînement (properties.txt) :

trainFile = dataset.tsv
serializeTo = fr-model.ser.gz
map = word=0,answer=1

useClassFeature=true
useWord=true
useNGrams=true
noMidNGrams=true
maxNGramLeng=6
usePrev=true
useNext=true
useSequences=true
usePrevSequences=true
maxLeft=1
useTypeSeqs=true
useTypeSeqs2=true
useTypeySequences=true
wordShape=chris2useLC
useDisjunctive=true

saveFeatureIndexToDisk = true

Par commodité, ces fichiers sont placés dans le même dossier stanford-ner-tagger/ : celui dans lequel le fichier du modèle entraîné sera généré.

cd stanford-ner-tagger/
java -cp "stanford-ner.jar:lib/*" -mx4g edu.stanford.nlp.ie.crf.CRFClassifier -prop properties.txt

Après un temps variable selon la taille des données et les paramètres définis, le résultat est un modèle entraîné, enregistré dans le fichier spécifié (fr-model.ser.gz)

Considération sur l'utilisation de la mémoire

Entraîner un modèle consomme une quantité de mémoire importante (pouvant aller jusqu'à plusieurs Gigaoctes). En général, vous aurez besoin de pouvoir disposer de mémoire virtuelle sur l'hôte qui effectue l'entraînement (fichier d'échange ou swap). Notez que le swap n'est pas disponible par défaut sur un système Nvidia Jetson Nano.

Test du modèle

Pour tester l'extraction d'entités avec notre modèle, nous utilisons Nltk (Spacy ne se compile pas sur architectures ARM 64)..

# coding: utf-8

import nltk

from nltk.tag.stanford import StanfordNERTagger

# Set path to java (optional)

import os

java_path = "/usr/bin/java"

os.environ['JAVA_HOME'] = java_path

jar = './stanford-ner-tagger/stanford-ner.jar'

model = './stanford-ner-tagger/fr-model.ser.gz'

ner_tagger = StanfordNERTagger(model, jar, encoding='utf8')

# Extract named entities

text = u"En 2017, une intelligence artificielle est en mesure de développer par elle-même Super Mario Bros. "

"Sans avoir eu accès au code du jeu, elle a récrée ce hit des consoles Nintendo. Des chercheurs de l'Institut "

"de Technologie de Géorgie, aux Etats-Unis, viennent de la mettre à l'épreuve."

words = nltk.word_tokenize(text)

print(ner_tagger.tag(words))

 

Référence

Article de référence sur le blog de Sicara (en Anglais)

How can I train my own NER model? sur la page FAQ de Stanford NER Tagger

Jeux de données dans différentes langues

Complete guide to build your own Named Entity Recognizer with Python