Transformers documentation

Texte en parole

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Texte en parole

La synthèse vocale (TTS) consiste à générer une parole naturelle à partir de texte, cette parole pouvant être produite dans plusieurs langues et pour plusieurs locuteurs. Plusieurs modèles de synthèse vocale sont actuellement disponibles dans 🤗 Transformers, notamment Dia, CSM, Bark, MMS, VITS et SpeechT5.

Vous pouvez facilement générer de l’audio à l’aide du pipeline "text-to-audio" (ou de son alias - "text-to-speech"). Voici un exemple d’utilisation du pipeline "text-to-speech" avec CSM :

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-audio", model="sesame/csm-1b")
>>> output = pipe("Hello from Sesame.")

Voici un extrait de code que vous pouvez utiliser pour écouter l’audio résultant dans un notebook :

>>> from IPython.display import Audio
>>> Audio(output["audio"], rate=output["sampling_rate"])

Par défaut, CSM utilise une voix aléatoire. Vous pouvez effectuer un clonage de voix en fournissant un audio de référence dans le dictionnaire de modèle de chat :

>>> import soundfile as sf
>>> import torch
>>> from datasets import Audio, load_dataset
>>> from transformers import pipeline

>>> pipe = pipeline("text-to-audio", model="sesame/csm-1b")

>>> ds = load_dataset("hf-internal-testing/dailytalk-dummy", split="train")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=24000))
>>> conversation = [
...     {
...         "role": "0",
...         "content": [
...             {"type": "text", "text": "What are you working on?"},
...             {"type": "audio", "path": ds[0]["audio"]["array"]},
...         ],
...     },
...     {"role": "0", "content": [{"type": "text", "text": "How much money can you spend?"}]},
... ]
>>> output = pipe(conversation)

Certains modèles, comme Dia, peuvent également être conditionnés pour générer des communications non verbales telles que des rires, des soupirs ou des pleurs, voire ajouter de la musique. Voici un exemple de ce type :

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-speech", model="nari-labs/Dia-1.6B-0626")
>>> text = "[S1] (clears throat) Hello! How are you? [S2] I'm good, thanks! How about you?"
>>> output = pipe(text)

Notez que Dia accepte également des balises de locuteur telles que [S1] et [S2] pour générer une conversation entre des voix distinctes.

Pour plus d'exemples sur ce que CSM et d'autres modèles TTS pré-entraînés peuvent faire, consultez notre cours sur l'audio.

Si vous souhaitez effectuer un fine-tuning d’un modèle TTS, les seuls modèles de synthèse vocale actuellement disponibles dans 🤗 Transformers sont SpeechT5, FastSpeech2Conformer, Dia et CSM, bien que d’autres seront ajoutés à l’avenir. SpeechT5 est pré-entraîné sur une combinaison de données de transcription vocale et de synthèse vocale, ce qui lui permet d’apprendre un espace unifié de représentations cachées partagé par le texte et la parole. Cela signifie que le même modèle pré-entraîné peut être affiné pour différentes tâches. De plus, SpeechT5 prend en charge plusieurs locuteurs grâce aux embeddings de locuteur x-vector.

Le reste de ce guide illustre comment :

  1. Effectuer le fine-tuning de SpeechT5, initialement entraîné sur la parole anglaise, sur le sous-ensemble néerlandais (nl) du jeu de données VoxPopuli.
  2. Utilisez votre modèle affiné pour l’inférence de l’une des deux manières suivantes : à l’aide d’un pipeline ou directement.

Avant de commencer, assurez-vous d'avoir installé toutes les bibliothèques nécessaires :

pip install transformers datasets soundfile torchcodec speechbrain accelerate

Installez 🤗Transformers depuis le code source, car toutes les fonctionnalités de SpeechT5 n’ont pas encore été intégrées à une version officielle :

pip install git+https://github.com/huggingface/transformers.git

Pour suivre ce guide, vous aurez besoin d'un GPU. Si vous travaillez dans un notebook, exécutez la ligne suivante pour vérifier qu'un GPU est disponible :

!nvidia-smi

ou, en alternative, pour les GPU AMD :

!rocm-smi

Nous vous encourage à vous connecter à votre compte Hugging Face pour téléverser et partager votre modèle avec la communauté. Lorsque le système vous le demande, saisissez votre jeton pour vous connecter :

>>> from huggingface_hub import notebook_login

>>> notebook_login()

Charger le jeu de données

VoxPopuli est un corpus vocal multilingue à grande échelle, composé de données issues d'enregistrements d'événements du Parlement européen entre 2009 et 2020. Il contient des données audio-transcription étiquetées pour 15 langues européennes. Dans ce guide, nous utilisons le sous-ensemble néerlandais, mais vous êtes libre de choisir un autre sous-ensemble.

Notez que VoxPopuli ou tout autre jeu de données de reconnaissance vocale automatique (ASR) peut ne pas être l’option la plus adaptée à l’entraînement de modèles TTS. Les caractéristiques qui le rendent utile pour l’ASR, comme un bruit de fond excessif, sont généralement indésirables en TTS. Toutefois, trouver des jeux de données TTS de haute qualité, multilingues et multi-locuteurs peut s’avérer assez difficile.

Chargons les données :

>>> from datasets import load_dataset, Audio

>>> dataset = load_dataset("qmeeus/voxpopuli", "nl", split="train")
>>> len(dataset)
20968

20968 exemples devraient être suffisants pour l'ajustement fin. SpeechT5 s'attend à ce que les données audio aient une fréquence d'échantillonnage de 16 kHz, il est donc important de s'assurer que les exemples du jeu de données respectent cette exigence :

dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))

Prétraiter les données

Commençons par définir le point de contrôle du modèle à utiliser et charger le processeur approprié :

>>> from transformers import SpeechT5Processor

>>> checkpoint = "microsoft/speecht5_tts"
>>> processor = SpeechT5Processor.from_pretrained(checkpoint)

Nettoyage du texte pour la tokenisation de SpeechT5

Commencez par nettoyer les données textuelles. Vous aurez besoin de la partie tokenizer du processeur pour traiter le texte :

>>> tokenizer = processor.tokenizer

Les exemples du jeu de données contiennent une fonction text avec la transcription. Notez que le tokenizer SpeechT5 ne possède aucun jeton pour les chiffres, de sorte que tout chiffre présent dans le texte sera converti en jetons <unk>. Si votre jeu de données contient des chiffres, envisagez de les normaliser sous leur forme écrite.

Comme SpeechT5 a été entraîné sur la langue anglaise, il est possible qu’il ne reconnaisse pas certains caractères du jeu de données néerlandais. S’ils sont laissés tels quels, ces caractères seront convertis en jetons <unk>. Cependant, en néerlandais, certains caractères comme à sont utilisés pour marquer l’accentuation des syllabes. Afin de préserver le sens du texte, nous pouvons remplacer ce caractère par un a ordinaire.

Pour identifier les jetons non pris en charge, extrayez tous les caractères uniques du jeu de données à l’aide de SpeechT5Tokenizer, qui fonctionne avec des caractères en tant que jetons. Pour ce faire, écrivez la fonction de mapping extract_all_chars qui concatène les transcriptions de tous les exemples en une seule chaîne et la convertit en un ensemble de caractères. Assurez-vous de définir batched=True et batch_size=-1 dans dataset.map() afin que toutes les transcriptions soient disponibles d’un coup pour la fonction de mapping.

>>> def extract_all_chars(batch):
...     all_text = " ".join(batch["text"])
...     vocab = list(set(all_text))
...     return {"vocab": [vocab], "all_text": [all_text]}


>>> vocabs = dataset.map(
...     extract_all_chars,
...     batched=True,
...     batch_size=-1,
...     keep_in_memory=True,
...     remove_columns=dataset.column_names,
... )

>>> dataset_vocab = set(vocabs["vocab"][0])
>>> tokenizer_vocab = {k for k, _ in tokenizer.get_vocab().items()}

Vous disposez désormais de deux ensembles de caractères : l'un avec le vocabulaire du jeu de données et l'autre avec le vocabulaire du tokenizer. Pour identifier les caractères non pris en charge dans le jeu de données, vous pouvez calculer la différence entre ces deux ensembles. L'ensemble résultant contiendra les caractères présents dans le jeu de données mais absents du tokenizer.

>>> dataset_vocab - tokenizer_vocab
{' ', 'à', 'ç', 'è', 'ë', 'í', 'ï', 'ö', 'ü'}

Pour gérer les caractères non pris en charge identifiés à l'étape précédente, définissez une fonction qui associe ces caractères à des jetons valides. Notez que les espaces ont déjà été remplacés par ▁ dans le tokeniseur et n'ont pas besoin d'être traités séparément.

>>> replacements = [
...     ("à", "a"),
...     ("ç", "c"),
...     ("è", "e"),
...     ("ë", "e"),
...     ("í", "i"),
...     ("ï", "i"),
...     ("ö", "o"),
...     ("ü", "u"),
... ]


>>> def cleanup_text(inputs):
...     for src, dst in replacements:
...         inputs["text"] = inputs["text"].replace(src, dst)
...     return inputs


>>> dataset = dataset.map(cleanup_text)

Maintenant que vous avez traité les caractères spéciaux dans le texte, il est temps de se concentrer sur les données audio.

Intervenants

Le jeu de données VoxPopuli contient des enregistrements vocaux de plusieurs locuteurs, mais combien de locuteurs sont représentés dans le jeu de données ? Pour le déterminer, nous pouvons compter le nombre de locuteurs uniques et le nombre d’exemples que chaque locuteur contribue au jeu de données. Avec un total de 20 968 exemples dans le jeu de données, ces informations nous donneront une meilleure compréhension de la répartition des locuteurs et des exemples dans les données.

>>> from collections import defaultdict

>>> speaker_counts = defaultdict(int)

>>> for speaker_id in dataset["speaker_id"]:
...     speaker_counts[speaker_id] += 1

En traçant un histogramme, vous pouvez avoir une idée de la quantité de données disponible pour chaque locuteur.

>>> import matplotlib.pyplot as plt

>>> plt.figure()
>>> plt.hist(speaker_counts.values(), bins=20)
>>> plt.ylabel("Speakers")
>>> plt.xlabel("Examples")
>>> plt.show()
Speakers histogram

L’histogramme révèle qu’environ un tiers des locuteurs du jeu de données ont moins de 100 exemples, tandis que dix locuteurs environ en ont plus de 500. Pour améliorer l’efficacité de l’entraînement et équilibrer le jeu de données, nous pouvons limiter les données aux locuteurs ayant entre 100 et 400 exemples.

>>> def select_speaker(speaker_id):
...     return 100 <= speaker_counts[speaker_id] <= 400


>>> dataset = dataset.filter(select_speaker, input_columns=["speaker_id"])

Vérifions combien de locuteurs restent :

>>> len(set(dataset["speaker_id"]))
42

Voyons combien d'exemples restent :

>>> len(dataset)
9973

Il vous reste un peu moins de 10 000 exemples issus d’environ 40 locuteurs uniques, ce qui devrait être suffisant.

Notez que certains locuteurs disposant de peu d'exemples peuvent en réalité avoir plus d'audio disponible si les exemples sont longs. Cependant, déterminer la quantité totale d'audio pour chaque locuteur nécessite de parcourir l'ensemble du jeu de données, ce qui est un processus chronophage impliquant le chargement et le décodage de chaque fichier audio. Nous avons donc choisi de passer cette étape ici.

Embeddings de locuteur

Pour permettre au modèle TTS de distinguer plusieurs locuteurs, vous devez créer un embedding de locuteur pour chaque exemple. L’embedding de locuteur est une entrée supplémentaire du modèle qui capture les caractéristiques vocales d’un locuteur donné. Pour générer ces embeddings de locuteur, utilisez le modèle pré-entraîné spkrec-xvect-voxceleb de SpeechBrain.

Créez une fonction create_speaker_embedding() qui prend en entrée une forme d’onde audio et renvoie un vecteur de 512 éléments contenant l’embedding du locuteur correspondant.

>>> import os
>>> import torch
>>> from speechbrain.inference.classifiers import EncoderClassifier
>>> from accelerate import Accelerator

>>> spk_model_name = "speechbrain/spkrec-xvect-voxceleb"
>>> device = Accelerator().device
>>> speaker_model = EncoderClassifier.from_hparams(
...     source=spk_model_name,
...     run_opts={"device": device},
...     savedir=os.path.join("/tmp", spk_model_name),
... )


>>> def create_speaker_embedding(waveform):
...     with torch.no_grad():
...         speaker_embeddings = speaker_model.encode_batch(torch.tensor(waveform))
...         speaker_embeddings = torch.nn.functional.normalize(speaker_embeddings, dim=2)
...         speaker_embeddings = speaker_embeddings.squeeze().cpu().numpy()
...     return speaker_embeddings

Il est important de noter que le modèle speechbrain/spkrec-xvect-voxceleb a été entraîné sur des données vocales en anglais issues du jeu de données VoxCeleb, tandis que les exemples d’entraînement de ce guide sont en néerlandais. Bien que nous estimions que ce modèle produira toujours des embeddings de locuteur raisonnables pour notre jeu de données néerlandais, cette hypothèse ne se vérifie pas dans tous les cas.

Pour des résultats optimaux, nous recommandons d'entraîner d'abord un modèle X-vector sur la voix cible. Cela permettra au modèle de mieux capturer les caractéristiques vocales uniques présentes dans la langue néerlandaise.

Traitement du jeu de données

Enfin, traitons les données dans le format attendu par le modèle. Créez une fonction prepare_dataset qui prend un exemple unique et utilise l'objet SpeechT5Processor pour tokeniser le texte d'entrée et charger l'audio cible dans un spectrogramme log-mel. Elle doit également ajouter les embeddings de locuteur en tant qu'entrée supplémentaire.

>>> def prepare_dataset(example):
...     audio = example["audio"]

...     example = processor(
...         text=example["text"],
...         audio_target=audio["array"],
...         sampling_rate=audio["sampling_rate"],
...         return_attention_mask=False,
...     )

...     # strip off the batch dimension
...     example["labels"] = example["labels"][0]

...     # use SpeechBrain to obtain x-vector
...     example["speaker_embeddings"] = create_speaker_embedding(audio["array"])

...     return example

Vérifiez que le traitement est correct en examinant un exemple unique :

>>> processed_example = prepare_dataset(dataset[0])
>>> list(processed_example.keys())
['input_ids', 'labels', 'stop_labels', 'speaker_embeddings']

Les embeddings de locuteur doivent être un vecteur de 512 éléments :

>>> processed_example["speaker_embeddings"].shape
(512,)

Les étiquettes doivent être un spectrogramme log-mel avec 80 bandes mel.

>>> import matplotlib.pyplot as plt

>>> plt.figure()
>>> plt.imshow(processed_example["labels"].T)
>>> plt.show()
Log-mel spectrogram with 80 mel bins

Remarque : si ce spectrogramme vous semble déroutant, cela peut s’expliquer par votre habitude de placer les basses fréquences en bas et les hautes fréquences en haut d’un graphique. Toutefois, lorsqu’on trace un spectrogramme sous forme d’image à l’aide de la bibliothèque matplotlib, l’axe des y est inversé et les spectrogrammes apparaissent à l’envers.

Appliquez maintenant la fonction de traitement à l'ensemble du jeu de données. Cette opération prendra entre 5 et 10 minutes.

>>> dataset = dataset.map(prepare_dataset, remove_columns=dataset.column_names)

Vous verrez un avertissement indiquant que certains exemples du jeu de données sont plus longs que la longueur d’entrée maximale que le modèle peut traiter (600 jetons). Supprimez ces exemples du jeu de données. Ici, nous allons encore plus loin et, afin de permettre des tailles de lot plus importantes, nous supprimons tout ce qui dépasse 200 jetons.

>>> def is_not_too_long(input_ids):
...     input_length = len(input_ids)
...     return input_length < 200


>>> dataset = dataset.filter(is_not_too_long, input_columns=["input_ids"])
>>> len(dataset)
8259

Ensuite, créez une division de base en ensembles d'entraînement et de test :

>>> dataset = dataset.train_test_split(test_size=0.1)

Collateur de données

Afin de combiner plusieurs exemples en un lot, vous devez définir un collateur de données personnalisé. Ce collateur remplit les séquences plus courtes avec des jetons de bourrage, garantissant ainsi que tous les exemples ont la même longueur. Pour les étiquettes des spectrogrammes, les portions bourrées sont remplacées par la valeur spéciale -100. Cette valeur spéciale indique au modèle d'ignorer cette partie du spectrogramme lors du calcul de la perte du spectrogramme.

>>> from dataclasses import dataclass
>>> from typing import Any, Dict, List, Union


>>> @dataclass
... class TTSDataCollatorWithPadding:
...     processor: Any

...     def __call__(self, features: list[dict[str, Union[list[int], torch.Tensor]]]) -> dict[str, torch.Tensor]:
...         input_ids = [{"input_ids": feature["input_ids"]} for feature in features]
...         label_features = [{"input_values": feature["labels"]} for feature in features]
...         speaker_features = [feature["speaker_embeddings"] for feature in features]

...         # collate the inputs and targets into a batch
...         batch = processor.pad(input_ids=input_ids, labels=label_features, return_tensors="pt")

...         # replace padding with -100 to ignore loss correctly
...         batch["labels"] = batch["labels"].masked_fill(batch.decoder_attention_mask.unsqueeze(-1).ne(1), -100)

...         # not used during fine-tuning
...         del batch["decoder_attention_mask"]

...         # round down target lengths to multiple of reduction factor
...         if model.config.reduction_factor > 1:
...             target_lengths = torch.tensor([len(feature["input_values"]) for feature in label_features])
...             target_lengths = target_lengths.new(
...                 [length - length % model.config.reduction_factor for length in target_lengths]
...             )
...             max_length = max(target_lengths)
...             batch["labels"] = batch["labels"][:, :max_length]

...         # also add in the speaker embeddings
...         batch["speaker_embeddings"] = torch.tensor(speaker_features)

...         return batch

Dans SpeechT5, l’entrée de la partie décodeur du modèle est réduite par un facteur 2. Autrement dit, elle supprime un pas de temps sur deux de la séquence cible. Le décodeur prédit ensuite une séquence deux fois plus longue. Comme la longueur de la séquence cible d’origine peut être impaire, le collateur de données s’assure d’arrondir la longueur maximale du lot vers le bas pour qu’elle soit un multiple de 2.

>>> data_collator = TTSDataCollatorWithPadding(processor=processor)

Entraîner le modèle

Chargez le modèle pré-entraîné à partir du même point de contrôle que celui utilisé pour charger le processeur :

>>> from transformers import SpeechT5ForTextToSpeech

>>> model = SpeechT5ForTextToSpeech.from_pretrained(checkpoint)

L'option use_cache=True est incompatible avec le gradient checkpointing. Désactivez-la pour l'entraînement.

>>> model.config.use_cache = False

Définissez les arguments d’entraînement. Ici, nous ne calculons aucune métrique d’évaluation pendant le processus d’entraînement. Nous nous contentons d’examiner la perte :

>>> from transformers import Seq2SeqTrainingArguments

>>> training_args = Seq2SeqTrainingArguments(
...     output_dir="speecht5_finetuned_voxpopuli_nl",  # change to a repo name of your choice
...     per_device_train_batch_size=4,
...     gradient_accumulation_steps=8,
...     learning_rate=1e-5,
...     warmup_steps=500,
...     max_steps=4000,
...     gradient_checkpointing=True,
...     fp16=True,
...     eval_strategy="steps",
...     per_device_eval_batch_size=2,
...     save_steps=1000,
...     eval_steps=1000,
...     logging_steps=25,
...     report_to="trackio",
...     load_best_model_at_end=True,
...     greater_is_better=False,
...     label_names=["labels"],
...     push_to_hub=True,
... )

Instanciez l'objet Trainer et transmettez-lui le modèle, le jeu de données et le data collator.

>>> from transformers import Seq2SeqTrainer

>>> trainer = Seq2SeqTrainer(
...     args=training_args,
...     model=model,
...     train_dataset=dataset["train"],
...     eval_dataset=dataset["test"],
...     data_collator=data_collator,
...     processing_class=processor,
... )

Et avec cela, vous êtes prêt à démarrer l’entraînement ! L’entraînement prendra plusieurs heures. Selon votre GPU, il est possible que vous rencontriez une erreur CUDA « out-of-memory » au démarrage de l’entraînement. Dans ce cas, vous pouvez réduire per_device_train_batch_size de manière incrémentale par facteurs de 2 et augmenter gradient_accumulation_steps de 2x pour compenser.

>>> trainer.train()

Pour pouvoir utiliser votre point de contrôle avec un pipeline, assurez-vous d'enregistrer le processeur avec le point de contrôle :

>>> processor.save_pretrained("YOUR_ACCOUNT_NAME/speecht5_finetuned_voxpopuli_nl")

Poussez le modèle final vers le 🤗 Hub :

>>> trainer.push_to_hub()

Inférence

Inférence avec un pipeline

Parfait, maintenant que vous avez affiné un modèle, vous pouvez l’utiliser pour l’inférence ! Commençons par voir comment l’utiliser avec un pipeline correspondant. Créons un pipeline "text-to-speech" avec votre point de contrôle :

>>> from transformers import pipeline

>>> pipe = pipeline("text-to-speech", model="YOUR_ACCOUNT_NAME/speecht5_finetuned_voxpopuli_nl")

Choisissez un extrait de texte en néerlandais que vous souhaitez faire narrer, par exemple :

>>> text = "hallo allemaal, ik praat nederlands. groetjes aan iedereen!"

Pour utiliser SpeechT5 avec le pipeline, vous aurez besoin d'un embedding de locuteur. Récupérons-en un à partir d'un exemple du jeu de données de test :

>>> example = dataset["test"][304]
>>> speaker_embeddings = torch.tensor(example["speaker_embeddings"]).unsqueeze(0)

Vous pouvez maintenant passer les embeddings de texte et de locuteur au pipeline, et il s’occupera du reste :

>>> forward_params = {"speaker_embeddings": speaker_embeddings}
>>> output = pipe(text, forward_params=forward_params)
>>> output
{'audio': array([-6.82714235e-05, -4.26525949e-04,  1.06134125e-04, ...,
        -1.22392643e-03, -7.76011671e-04,  3.29112721e-04], dtype=float32),
 'sampling_rate': 16000}

Vous pouvez ensuite écouter le résultat :

>>> from IPython.display import Audio
>>> Audio(output['audio'], rate=output['sampling_rate'])

Exécuter l'inférence manuellement

Vous pouvez obtenir les mêmes résultats d’inférence sans utiliser le pipeline, mais cela nécessitera davantage d’étapes.

Chargez le modèle depuis le 🤗 Hub :

>>> model = SpeechT5ForTextToSpeech.from_pretrained("YOUR_ACCOUNT/speecht5_finetuned_voxpopuli_nl")

Choisissez un exemple dans le jeu de données de test et obtenez un embedding de locuteur.

>>> example = dataset["test"][304]
>>> speaker_embeddings = torch.tensor(example["speaker_embeddings"]).unsqueeze(0)

Définissez le texte d'entrée et tokenisez-le.

>>> text = "hallo allemaal, ik praat nederlands. groetjes aan iedereen!"
>>> inputs = processor(text=text, return_tensors="pt")

Créer un spectrogramme avec votre modèle :

>>> spectrogram = model.generate_speech(inputs["input_ids"], speaker_embeddings)

Visualisez le spectrogramme, si vous le souhaitez :

>>> plt.figure()
>>> plt.imshow(spectrogram.T)
>>> plt.show()
Generated log-mel spectrogram

Enfin, utilisez le vocoder pour convertir le spectrogramme en son.

>>> with torch.no_grad():
...     speech = vocoder(spectrogram)

>>> from IPython.display import Audio

>>> Audio(speech.numpy(), rate=16000)

D'après notre expérience, il peut être difficile d'obtenir des résultats satisfaisants avec ce modèle. La qualité des embeddings de locuteur semble être un facteur déterminant. Étant donné que SpeechT5 a été pré-entraîné avec des x-vectors en anglais, il offre les meilleures performances lorsqu'on utilise des embeddings de locuteur en anglais. Si la voix synthétisée est de mauvaise qualité, essayez d'utiliser un autre embedding de locuteur.

Allonger la durée de l’entraînement est également susceptible d’améliorer la qualité des résultats. Néanmoins, la voix est clairement néerlandaise et non anglaise, et elle reprend bien les caractéristiques vocales de l’orateur (à comparer avec l’audio d’origine dans l’exemple). Un autre paramètre à explorer est la configuration du modèle. Par exemple, essayez d’utiliser config.reduction_factor = 1 pour voir si cela améliore les résultats.

Enfin, il est essentiel de prendre en compte les considérations éthiques. Bien que la technologie TTS présente de nombreuses applications utiles, elle peut également être utilisée à des fins malveillantes, par exemple pour imiter la voix d’une personne sans son consentement ni son accord. Veuillez utiliser la TTS de manière judicieuse et responsable.

Update on GitHub