KenLM training

KenLM

KenLM effectue un lissage Kneser Ney modifié interpolé pour estimer les probabilités n-grammes.

---

Guide étape par étape pour former un modèle de langage basé sur n-gram à l'aide de la boîte à outils KenLM

1) Installation des dépendances KenLM

Avant d'installer la boîte à outils KenLM, vous devez installer toutes les dépendances qui se trouvent dans kenlm-dependencies.

Pour la distribution Debian/Ubuntu :

Pour obtenir un compilateur fonctionnel, installez le package build-essential . Boost est connu sous le nom de libboost-all-dev . Les trois options de compression prises en charge ont chacune un package de développement distinct.

 $ sudo apt-get install build-essential libboost-all-dev cmake zlib1g-dev libbz2-dev liblzma-dev

2) Installation de la boîte à outils KenLM

Pour cela, il est suggéré d'utiliser un environnement virtuel conda ou virtualenv . Pour conda, vous pouvez en créer un en utilisant :

 $ conda create -n kenlm_deepspeech python=3.6 nltk

Activez ensuite l'environnement en utilisant :

 $ source activate kenlm_deepspeech

Nous sommes maintenant prêts à installer kenlm. Clonons d'abord le dépôt kenlm :

 $ git clone --recursive https://github.com/vchahun/kenlm.git

Et puis compilez le code d'estimation LM en utilisant :

 $ cd kenlm
$ ./bjam 

Comme dernière étape, installez éventuellement le module Python en utilisant :

 $ python setup.py install

3) Formation d'un modèle de langage

Commençons par obtenir quelques données d'entraînement. Ici, j'utiliserai la Bible :

 $ wget -c https://github.com/vchahun/notes/raw/data/bible/bible.en.txt.bz2

Ensuite, nous aurons besoin d’un simple script de prétraitement. La raison est que :

• le texte de formation doit être un seul fichier texte/compressé (par exemple .bz2 ) contenant une seule phrase par ligne.
• il doit être tokenisé et mis en minuscules avant de l'introduire dans kenlm

Alors, créez un simple script preprocess.py avec les lignes suivantes :

 import sys
import nltk

for line in sys . stdin :
    for sentence in nltk . sent_tokenize ( line ):
        print ( ' ' . join ( nltk . word_tokenize ( sentence )). lower ())

Pour vérifier l'intégrité, faites :

 $ bzcat bible.en.txt.bz2 | python preprocess.py | wc

Et voyez que cela fonctionne bien.

Nous pouvons maintenant entraîner le modèle. Pour entraîner un modèle de trigramme avec le lissage Kneser-Ney, utilisez :

 # -o means `order` which translates to the `n` in n-gram
$ bzcat bible.en.txt.bz2 |
  python preprocess.py |
  ./kenlm/bin/lmplz -o 3 > bible.arpa

La commande ci-dessus redirigera d'abord les données via le script de prétraitement qui effectue la tokenisation et la mise en minuscules. Ensuite, ce texte tokenisé et en minuscules est transmis au programme lmplz qui effectue le travail d'estimation.

Cela devrait se terminer dans quelques secondes, puis générer un fichier arpa bible.arpa . Vous pouvez inspecter le fichier arpa en utilisant quelque chose comme less ou more (c'est-à-dire $ less bible.arpa ). Au tout début, il devrait avoir une section de données avec les nombres d'unigrammes, de bigrammes et de trigrammes suivis des valeurs estimées.

Binariser le modèle

Les fichiers ARPA peuvent être lus directement. Mais le format binaire se charge beaucoup plus rapidement et offre plus de flexibilité. L'utilisation du format binaire réduit considérablement le temps de chargement et expose également davantage d'options de configuration. Pour ces raisons, nous binariserons le modèle en utilisant :

 $ ./kenlm/bin/build_binary bible.arpa bible.binary

Notez que, contrairement à l'IRSTLM, l'extension du fichier n'a pas d'importance ; le format binaire est reconnu à l'aide d'octets magiques.

On peut également utiliser trie lors de la binarisation. Pour cela, utilisez :

  $ ./kenlm/bin/build_binary trie bible.arpa bible.binary

---

Utiliser le modèle (c'est-à-dire noter des phrases)

Maintenant que nous avons un modèle linguistique, nous pouvons noter des phrases. C'est très simple de faire cela en utilisant l'interface Python. Ci-dessous un exemple :

 import kenlm
model = kenlm . LanguageModel ( 'bible.binary' )
model . score ( 'in the beginning was the word' )

Ensuite, vous pourriez obtenir un score tel que :

 -15.03003978729248

---

Références :

1. http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel
2. http://victor.chahuneau.fr/notes/2012/07/03/kenlm.html