Tensorflow & deepspeech en français

 Objectif

  • Déployer tensorflow sur un système qui ne supporte pas AVX ni AVX2.
  • Déployer Deepspeech 2 sur la même machine
  • Compiler tous les modules nécessaires pour faire fonctionner la reconnaissance vocale.
  • Faire le traitement grâce au CPU seulement (Aucune carte vidéo n'est disponible)

Le matériel utilisé

  • Proxmox avec une VM Ubuntu 16.04
  • HP DL380 G7
    • 20Gb de ram
    • 10 cores (2 sockets, 5 cores, XEON X5650 2.67GHz)
    • 100Gb de disque dur

OS

J'ai utilisé Ubuntu 16.04.3 avec l'installation minimal

Installation de toutes les dépendances et préparation de l'environnement

Tensorflow et deepspeech ont besoins de pas mal de dépendance pour bien fonctionner.

Bazel 0.5.4

Il faut utiliser la version 0.5.4 sinon la compilation de Tensorflow et de Deepspeech s'effectue avec des erreurs.

sudo apt-get install -y pkg-config
sudo apt-get install openjdk-8-jdk unzip -y

Télécharger le script de bazel : Bazel 0.5.4 Script

2018-03-16

Bazel 0.5.4 ne fonctionne plus, maintenant il faut prendre la nouvelle version.

wget https://github.com/bazelbuild/bazel/releases/download/0.11.1/bazel-0.11.1-installer-linux-x86_64.sh
bash bazel-0.11.1-installer-linux-x86_64.sh

Dès que le script est téléchargé, lancer cette commande :

sudo bash bazel-0.5.4-installer-linux-x86_64.sh

 Python 2.7

sudo apt-get install python-numpy python-dev python-pip python-wheel -y

Kenlm

Il faut se logiciel pour créer le vocabulaire pour ensuite exécuter les scripts de reconnaissance vocale.

J'ai utilisé cette version : Kenlm 

sudo apt-get install -y build-essential libboost-all-dev cmake zlib1g-dev libbz2-dev liblzma-dev
wget -O - https://kheafield.com/code/kenlm.tar.gz |tar xz
mkdir kenlm/build
cd kenlm/build
cmake ..
make -j2

Sox

Il faut télécharger ce projet : https://sourceforge.net/projects/sox/files/sox/

Choisir le tar.gz

wget https://sourceforge.net/projects/sox/files/sox/14.4.2/sox-14.4.2.tar.gz/download 
tar -xvzf download
cd sox*
./configure
make -s && sudo make install
sudo apt-get install libsox-dev -y

Tensorflow

Il faut récupérer le repository de tensorflow, nous allons utilisé celui créé par Mozilla et non l'officiel.

cd ~
git clone https://github.com/mozilla/tensorflow
NOTE

Si la compilation échoue, voici le commit que j'ai utilisé pour mon setup. (Je n'ai pas testé de compiler avec la nouvelle version.)

https://github.com/mozilla/tensorflow/commit/1390dc180e25b5821be80b407ddc5fad73d4ef6a

Deepspeech

Comme tensorflow, il faut

récupérer le repository.

cd ~
wget https://github.com/git-lfs/git-lfs/releases/download/v2.4.0/git-lfs-linux-amd64-2.4.0.tar.gz
tar -xvzf git-lfs-linux-amd64-2.4.0.tar.gz
cd git-lfs-*
./install.sh
cd ~
git clone https://github.com/mozilla/DeepSpeech
NOTE

Dans le cas où ça ne fonctionne pas, vous pouvez essayer ce commit.

https://github.com/mozilla/DeepSpeech/commit/06467f460e38bc8aa4a186d8099473bd6b00dc4b

Préparation pour compiler Tensorflow

cd ~/tensorflow
ln -s ../DeepSpeech/native_client/ ./
./configure

le lien symbolique sert à compiler DeepSpeech pour le bon système et Tensorflow en même temps.

la commande ./configure, vous pouvez laisser tout par défaut ou choisir selon votre environnement.

Compilation de tensorflow

Pour compiler Tensorflow sans AVX, il faut utiliser ces paramètres.

depuis la racine de Tensorflow, lancer cette ligne:

bazel build -c opt --copt=-mno-avx //tensorflow:libtensorflow_cc.so //tensorflow:libtensorflow_framework.so //native_client:deepspeech //native_client:deepspeech_utils //native_client:libctc_decoder_with_kenlm.so //native_client:generate_trie //tensorflow/tools/pip_package:build_pip_package

cd ~/tensorflow
bazel-bin/tensorflow/tools/pip_package/build_pip_package /tmp/tensorflow_pkg
sudo pip install /tmp/tensorflow_pkg/tensorflow-1.6.0-py2-none-any.whl
2018-03-16 La commande a changée pour :
bazel build -c opt --copt=-mno-avx //tensorflow:libtensorflow_cc.so //tensorflow:libtensorflow_framework.so //native_client:libdeepspeech.so //native_client:deepspeech_utils //native_client:libctc_decoder_with_kenlm.so //native_client:generate_trie

Selon la puissance de la machine, le temps peut varier entre 30 minutes et des heures.

Terminer l'installation de DeepSpeech

cd ~/tensorflow/bazel-bin/native_client
cp -R ./* ~/DeepSpeech/native_client/
cd ../tensorflow
cp libtensorflow_* ~/DeepSpeech/native_client/
cd ~/DeepSpeech/native_client
LD_LIBRARY_PATH=/root/DeepSpeech/native_client/
export LD_LIBRARY_PATH
make deepspeech

cd ~/DeepSpeech
pip install -r requirements.txt

Générer les fichiers pour le LM, le vocabulaire et l'alphabet

Alors, deepspeech a besoin de plusieurs fichiers pour fonctionner.

N'oubliez pas de mettre les fichiers en UTF-8, sinon DeepSpeech ne fonctionnera pas.

  1. alphabet.txt
  2. vocabulary.txt
  3. voices.csv
  4. lm.binary
  5. word.arpa
  6. trie

Voici le script qui va créer la majorité des fichiers.

#/bin/bash
# Version : 1.0.0
# Date : 2018-01-25
# Mission : Create the required files for training
# Author : Tommy Gingras

## $1 vocabulary.txt
## $2 word.arpa
## $3 lm.binary
## $4 alphabet.txt
## $5 trie
## $6 generate_trie
 
if [ $# -ne 6 ]; then
        echo "## vocabulary.txt (eg. data/vocabulary.txt)"
        echo "## word.arpa (eg. data/words.arpa)"
        echo "## lm.binary (eg. data/lm.binary)"
        echo "## alphabet.txt (eg. data/alphabet.txt)"
        echo "## trie (eg. data/trie)"
        echo "## generate_trie (eg. /home/tgingras/vocal/tensorflow/bazel-bin/native_client/generate_trie)"
        exit
fi
 
echo "Step 1. clean the vocabulary"
sed 's/\xc2\xa0/ /' $1
 
echo "Step 2. Generate the arpa"
kenlm/build/bin/./lmplz --text $1 --arpa $2 --o 5
 
echo "Step 3. Generate the LM binary"
kenlm/build/bin/./build_binary -T -s $2 $3
 
echo "Step 4. Generate the trie"
$6 $4 $3 $1 $5
 
echo "Done!"

Vous pouvez creer un fichier : prepare_data.sh avec le script ci-dessus.

chmod +x prepare_data.sh

Alphabet.txt

Ce fichier est très important il contient toutes les possibilités de caractère que vous aller fournir dans le fichier voices et vocabulary.

Alors voici un exemple de ce fichier.

La première ligne est un ESPACE, très important de ne pas l'oublier.

  # NE PAS OUBLIER L'ESPACE & supprimer ce commentaire
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
x
y
z
1
2
3
4
5
6
7
8
9
0
ê
é
à
ç
ô
û
î
è
ù
â
'
-
ï
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
X
Y
Z
É
À
Ç
Ô
Û
Î
È
Ù
Â
Ï
Ê

Vocabulary.txt

Ce fichier contient toutes les phrases que vous allez lire. Donc, vous ne pouvez pas simplement ajouter un mot par ligne.

Voici un exemple.

Je m'appelle Tommy
Bonjour comment ça va aujourd'hui
Est-ce que tu as bien dormi

Donc, il faut simplement copier toutes les lignes lues dans ce fichier.

Voice.csv

Ce fichier contient 3 informations très importante,

  1. Le nom du fichier qui contient l'échantillon vocale.
  2. la taille du fichier.
  3. ce que contient l'enregistrement.

Alors, voici un exemple.

wav_filename,wav_filesize,transcript
/home/vocal/voices/wav_1.wav,67543,Bonjour comment ça va aujourd'hui
/home/vocal/voices/wav_2.wav,98876,Je m'appelle Tommy
/home/vocal/voices/wav_3.wav,67633,Est-ce que tu as bien dormi

Pour récupérer la taille du fichier il suffit de faire ls -al.

Il faut séparer chaque information par une virgule.

Le fichier doit commencer par la première ligne, c'est obligatoire. Elle sert à dire où ce trouve l'information.

Créer les fichiers finaux

Vous pouvez à présent lancer le script avec vos paramètres.

./prepare_data.sh vocabulary.txt word.arpa lm.binary alphabet.txt trie /home/tgingras/vocal/tensorflow/bazel-bin/native_client/generate_trie

Note: Il se peut que cela ne fonctionne pas, j'ai dû entrer plus de 500 entrées avant que cela fonctionne. Cependant vous pouvez faire le paramètre (Après tous les paramètres de l'étape 2 dans le script prepare_data.sh), --discount_fallback et cela va fonctionner. (Je ne le recommande pas, vous devriez simplement faire plus d'enregistrement et de toute manière il est fortement recommander d'envoyer des heures d'enregistrement.)

le fichier generate_trie ce trouve où vous avez compilé tensorflow dans le dossier bazel-bin/native_client

Enregistrement audio

Vous pouvez sans problème utiliser audacity. Il est simple à utiliser et il permet rapidement de faire les enregistrements.
Il est recommandé d'avoir des fichiers d'une longueur moyenne de 5 secondes.

Le fichier doit être un wav 16bit, 16000 Hz et doit être Mono. (Aucune métadonnées ne doit être mises dans le fichier .wav). Simplement garder le fichier le plus simple possible.

Enfin prêt pour le training

Maintenant il faut ce déplacer à la racine de DeepSpeech

cd ~/DeepSpeech

Le fichier DeepSpeech.py et le dossier native_client sont nos outils.

Le script pour lancer le training,

#!/bin/sh
set -xe
if [ ! -f DeepSpeech.py ]; then
    echo "Please make sure you run this from DeepSpeech's top level directory."
    exit 1
fi;

python -u DeepSpeech.py \
  --train_files /home/tgingras/vocal/data/voice.csv \
  --dev_files /home/tgingras/vocal/data/voice.csv \
  --test_files /home/tgingras/vocal/data/voice.csv \
  --train_batch_size 80 \
  --dev_batch_size 80 \
  --test_batch_size 40 \
  --n_hidden 1024 \
  --epoch 50 \
  --use_seq_length False \
  --report_count 100 \
  --remove_export True \
  --checkpoint_dir /home/tgingras/vocal/results/v1.0.0/checkpoints/ \
  --export_dir /home/tgingras/vocal/results/v1.0.0/model_export/ \
  --decoder_library_path /home/tgingras/vocal/tfv1/tensorflow/bazel-bin/native_client/libctc_decoder_with_kenlm.so \
  --alphabet_config_path /home/tgingras/vocal/data/alphabet.txt \
  --lm_binary_path /home/tgingras/vocal/data/lm.binary \
  --lm_trie_path /home/tgingras/vocal/data/trie

modifier le pour adapter vos chemins.

nommer le launch.sh

chmod +x launch.sh
./launch.sh

maintenant, tout devrait se faire tout seul. Dépendant la quantité d'enregistrement envoyé, ça prend quelques heures.

Par exemple, 11 Minutes d'enregistrement prend environ 1H15 à être traité, incluant le temps de générer le output_graph.pb. Sinon 47 Minutes pour seulement le training.

À la fin du training, un fichier */results/model_export/output_graph.pb est généré, il sert pour décortiquer les phrases à partir d'un enregistrement.

Tester le model

cd ~/DeepSpeech/native_client/
./deepspeech /home/tgingras/vocal/results/v0.2.0/model_export/output_graph.pb ../data/test_audio/test-4.wav ../data/alphabet.txt -t

Ça prend du temps avant que le tout soit parfait.

1 commentaire sur “Tensorflow & deepspeech en français”

Laisser un commentaire