Journal Lecture de texte avec Coqui TTS

Sommaire

• Le besoin
• La quête
  • L'installation
  • Utilisation de base
  • Améliorations
    • Éviter de re-télécharger le modèle à chaque fois
    • Utilisation d'un modèle plus qualitatif :
    • Accepter un PDF en entrée
    • Produire directement un MP3
• Le résultat
• Bilan

Cher Nal,

Je prends bien rarement ma plume, mais j'ai fait une petite expérimentation qui pourrait t'intéresser.

Le besoin

J'aimerais pouvoir écouter des documents que je possède à l'écrit, quand je suis dans les transports. Jusque là rien de bien compliqué, c'est du TTS (text-to-speech), mais j'aimerais surtout :

• obtenir une lecture de bonne qualité : fluide, naturelle, avec un minimum d'intonations
• que ce soit opensource
• local : ne pas avoir besoin d'aller téléverser un document dans le cloud
• pouvoir directement passer un fichier PDF

Par contre, je n'ai pas besoin :

• que ce soit en temps réel (i.e. je peux préparer à l'avance)

La quête

J'ai commencé par regarder les solutions classiques espeak-ng, festival, puisqu'ils sont pas mal utilisé : le niveau de qualité n'était pas celui que je recherchais (même si on peut améliorer un peu les choses avec de la configuration). J'ai donc recherché des options côté IA générative, et il y en a… mais surtout dans le cloud.

Et puis je suis tombé sur CoquiTTS : un TTS opensource créé par Coqui AI, une boite hélas fermée depuis 2024, fondée par d'anciens de Mozilla.

L'installation

Je regarde la doc, ça semble relativement simple, avec 2 options :

• pip et de l'install manuelle
• utiliser une image docker pré-construite

J'aime bien l'idée de pouvoir partir d'un truc propre facilement transposable sur d'autres machines, je choisis donc l'option docker (c'est aussi l'occasion de découvrir docker, que je n'ai jamais vraiment utilisé).

Après une brève lecture de la doc des images docker, je choisis l'image docker pour un traitement sur CPU (il y en a un autre pour GPU NVidia, mais mon hardware n'en a pas). 10 Go de téléchargement plus tard, me voici avec la bête.

Utilisation de base

Après lecture de la doc je parviens à générer un premier fichier audio:

docker run -it --rm \
  -v "$(pwd):/output" \
  ghcr.io/coqui-ai/tts-cpu \
  --text "Hello world" \
  --out_path "/output/plop.wav"

Explication (désolé si vous connaissez déjà docker, mais moi je ne connaissais pas, alors je détaille pour celles ou ceux qui seraient dans mon cas) :

• docker run : lance une image docker
• -it : mode interactif pour docker
• --rm : repart de l'image à chaque fois (ne garde pas les modifications)
• -v "/local/path:/image/path" : permet de créer un volume, un truc qui mappe un chemin dans l'image sur un chemin en local
• ghcr.io/coqui-ai/tts-cpu : le nom de l'image docker à lancer
• --text "Blabla" : le texte à lire
• --out_path "/image/path": le fichier WAV à produire

Résultat :

• qualité pas encore terrible, mais je sais qu'il y a d'autres modèles potentiellement meilleurs d'après la doc
• ça marche uniquement pour de l'anglais : le rendu en français est incompréhensible, le modèle par défaut n'est pas entrainé pour
• à chaque fois qu'on lance la commande avec une phrase, on se retape les 104 Mo de chargement du (petit) modèle par défaut

Améliorations

Éviter de re-télécharger le modèle à chaque fois

Pour ça, on va stocker les modèles hors de l'image.

docker run -it --rm \
  -v tts_models:/root/.local/share/tts \
  -v "$(pwd):/output" \
  ghcr.io/coqui-ai/tts-cpu \
  --text "Hello world" \
  --out_path "/output/plop.wav"

• -v tts_models:/root/.local/share/tts : crée un volume pour stocker les modèles hors de l'image

Résultat:

• plus besoin de re-télécharger le modèle 😊

Utilisation d'un modèle plus qualitatif :

Celui par défaut est d'une taille "raisonnable", mais mono-lingue et mono-locuteur. Je me tourne donc vers celui mis en avant sur le github : XTTSv2. Il est multi-lingue, multi-locuteur, et permet même de faire du voice-cloning (ce n'est pas dans mes besoins de base, mais je trouve l'idée cool).

docker run -it --rm \
  -v tts_models:/root/.local/share/tts \
  -v "$(pwd):/output" \
  ghcr.io/coqui-ai/tts-cpu \
  --text "Salut le monde." \
  --model_name tts_models/multilingual/multi-dataset/xtts_v2 \
  --language_idx "fr" \
  --speaker_idx "Filip Traverse" \
  --out_path "/output/plop.wav"

• --model_name tts_models/multilingual/multi-dataset/xtts_v2 : le modèle XTTSv2
• --language_idx "fr" : on indique la langue (le français ici, mais il y a pas mal d'autres langues supportées)
• --speaker_idx "Filip Traverse" : on indique le locuteur (il y a pas mal de locuteurs inclus. L'autre alternative est d'utiliser l'argument --speaker_wav pour passer une voix à cloner)

Résultat:

fichier audio et un autre un peu plus long.

• la qualité est enfin au rendez-vous !
• on peut enfin avoir du français
• ça prend beaucoup de temps à télécharger (plus de 5 Go à télécharger la première fois, heureusement qu'on stocke le modèle) et à traiter

Accepter un PDF en entrée

J'ai utilisé pdftotext:

pdftotext -nopgbrk -layout "$pdf_file" -

À noter qu'en plus j'ai utilisé quelques filtres pour améliorer le texte d'entrée (ce qui améliore la diction), on pourrait sûrement aller plus loin :

• remplacer les retours de chariots par des espaces (sauf quand il y a une ligne blanche)
• dédoublonner les lignes blanches
• dédoublonner les espaces

Je ne détaille pas, parceque là c'est particulièrement lié au type de documents qui m'intéresse.

Produire directement un MP3

J'ai utilisé ffmpeg:

ffmpeg -y -hide_banner -nostats -loglevel warning -i "$wav_file" -vn -ar 44100 -ac 2 -b:a 192k "$mp3_file"

Le résultat

Je me suis créé des wrappers pour faire tout ça facilement : https://github.com/mrlem/easy-tts

Si vous voulez l'utiliser, vous en servir comme base, ou bien juste farfouiner, n'hésitez pas.
Disclaimer : je ne suis pas expert en bash, ni en IA générative, du coup il y a sûrement des choses perfectibles, faisables différemment. Je suis donc ouvert aux remarques et suggestions.

Bilan

Très chouette ! Plus précisément :

Dans les + :

• j'ai appris plein de choses
• mon besoin est plutôt bien rempli, je peux avoir des fichiers audio vraiment très bons
• la qualité est vraiment chouette, c'est vraiment un outil très chouette que Coqui AI a créé (il peut faire bien plus que ce pour quoi je l'ai utilisé)

Dans les - :

• Coqui AI qui n'a pas tenu : je trouve ça très dommage pour eux, même s'ils laissent un outil que je trouve génial en opensource
• le modèle XTTSv2 a une licence particulière, en bref c'est totalement gratuit pour un usage qui ne génère pas de revenu (c'est mon cas, donc ça me va)
• c'est gourmand en ressources, et pas super rapide (3-5 minutes pour lire une lettre d'une page, pas très longue, sur mon laptop), mais pour moi c'est acceptable
• suivant les PDFs, il peut y avoir pas mal de caractères parasites (ça dépend de la conversion en texte)
• c'est inhérent à l'IA générative, mais le résultat varie d'un lancement à l'autre, et il y a parfois des hallucinations (sous forme d'ajouts compréhensibles ou non à la fin de l'audio)
• des difficultés pour ce qui est des sigles / acronymes qu'il essaie de prononcer (genre dans "linuxFR", ou bien "GNU/Linux")
• j'ai dû pas mal tâtonner pour obtenir ce que je voulais (le journal représente la version épurée du parcours 😉)