Utiliser Coqui TTS en Python (avancé)

Dans cet article, nous allons explorer comment utiliser Coqui TTS de manière avancée avec Python. L’objectif principal de cette approche est de vous offrir la flexibilité nécessaire pour modifier le répertoire d’utilisation des modèles de synthèse vocale. Cette capacité de personnalisation est cruciale, car elle vous permet de stocker les modèles où vous le souhaitez, optimisant ainsi la gestion de l’espace disque et l’organisation des ressources dans vos projets de développement.

Au-delà de la gestion des emplacements des modèles, l’utilisation avancée de Coqui TTS ouvre la porte à une gamme plus large de paramètres et de configurations. Cela signifie que vous aurez la possibilité d’affiner davantage le processus de génération de la parole, en ajustant des aspects tels que la tonalité, la vitesse, et l’expressivité de la voix synthétique. Cette personnalisation approfondie peut s’avérer particulièrement utile pour des applications spécifiques où le ton et le style de la voix jouent un rôle important dans l’expérience utilisateur finale.

Si vous êtes à la recherche d’une introduction plus accessible ou d’une utilisation plus standard de Coqui AI TTS, je vous invite à consulter également un autre article que j’ai rédigé, qui couvre les bases de l’utilisation de cette technologie de synthèse vocale.

coderocks.fr/datarocks/ia-app-coquiai/utiliser-coqui-tts-en-python-1371/

Cet article complémentaire est conçu pour ceux qui préfèrent commencer par une approche plus simple avant de plonger dans les configurations et utilisations avancées.

Le code

Ce code illustre une utilisation avancée de Coqui TTS pour la synthèse vocale, en permettant une personnalisation approfondie grâce à la modification directe du chemin des modèles et à l’utilisation de configurations spécifiques.

# Importation des modules nécessaires
import torch
import torchaudio
from TTS.api import TTS
from TTS.tts.configs.xtts_config import XttsConfig
from TTS.tts.models.xtts import Xtts

# paramètres nécessaires
# à partir de là, vous pouvez déplacer 
# votre dossier de modèle et définir le nouveau
# chemin vers le fichier.json et le dossier racine du modèle
path_model = "chemin-du-model"
path_config_model = "chemin-du-model\\config.json"
speaker_w = "chemin-de-la-voix-de-référence"
tts_text = "le texte à faire lire"

# Instantiation de la configuration
config = XttsConfig()

# Chargement du fichier de configuration JSON du modèle choisi
config.load_json(path_config_model)

# Chargement du model à partir de l'objet de configuration instancié
model = Xtts.init_from_config(config)
model.load_checkpoint(config, checkpoint_dir=path_model, eval=True)

# si cuda disponible, sinon, commentez ou supprimez cette ligne
model.cuda() 

# Assistant ? si tu as une explication je suis preneur ;)
outputs = model.synthesize(
    tts_text,
    config,
    speaker_wav=speaker_w,
    gpt_cond_len=3,
    language="fr",
)

# Enregistrement du fichier audio généré par inférence (excecution) du modèle.
torchaudio.save("output.wav", torch.tensor(outputs["wav"]).unsqueeze(0), 24000)

Explication du Code

Importation des Modules

Les importations de modules tels que torch, torchaudio, et divers éléments de TTS (notamment XttsConfig et Xtts) sont essentielles pour accéder aux fonctionnalités de base et avancées de traitement audio et de synthèse vocale.

Instantiation et Chargement de la Configuration

XttsConfig()

crée une instance de la configuration pour le modèle XTTS, et load_json charge la configuration spécifique du modèle à partir d’un fichier JSON. Cela permet une personnalisation fine en ajustant les paramètres définis dans ce fichier. Ce fichier est disponible par défaut, dans le dossier du modèle.

Chargement du Modèle

Xtts.init_from_config(config)

initialise le modèle avec la configuration chargée, et model.load_checkpoint charge le modèle spécifié, prêt à être utilisé pour la synthèse.

Utilisation de CUDA

model.cuda()

déplace le modèle vers le GPU pour accélérer les calculs, si CUDA est disponible. C’est une étape optionnelle mais recommandée pour améliorer les performances de synthèse.

Synthèse de la Parole

model.synthesize

Cette méthode est la clé pour transformer le texte en audio. Elle permet une grande flexibilité en acceptant divers paramètres qui influencent la synthèse.

Torchaudio.save

torchaudio.save("output.wav", torch.tensor(outputs["wav"]).unsqueeze(0), 24000)

sauvegarde le fichier audio généré, utilisant le tenseur audio et la fréquence d’échantillonnage spécifiée (ici, 24000 Hz). Cette étape transforme les données numériques en un fichier audio réel que vous pouvez écouter.

torch.tensor(outputs["wav"]).unsqueeze(0)

Un tenseur est une structure de données utilisée dans PyTorch pour représenter les données. Il est très similaire à un tableau dans d’autres langages de programmation, mais avec des fonctionnalités supplémentaires qui le rendent particulièrement adapté au calcul scientifique et au machine learning. Les tenseurs peuvent être manipulés efficacement sur des processeurs graphiques (GPU), ce qui accélère considérablement les calculs.

La conversion des données d’inférence en tenseurs signifie prendre les valeurs numériques générées par le modèle (les données d’inférence) et les organiser dans une structure de tenseur PyTorch. Cette conversion est nécessaire car les outils et fonctions de PyTorch (y compris torchaudio pour l’enregistrement audio) travaillent avec des tenseurs.

Enregistrement de l’Audio

torchaudio.save