Update app.py

app.py

@@ -1,201 +1,161 @@
 
 
-import gradio as gr
-import torch
-import soundfile as sf
-import spaces
-import os
 import numpy as np
+from scipy.io import wavfile
+import torch
+from parler_tts import ParlerTTSForConditionalGeneration
+from transformers import AutoTokenizer
+import gradio as gr
 import re
-from transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan
-from speechbrain.pretrained import EncoderClassifier
-from datasets import load_dataset
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-def load_models_and_data():
-    model_name = "Moustapha91/TTS_WOLOF_FINAL"
-    processor = SpeechT5Processor.from_pretrained(model_name)
-    model = SpeechT5ForTextToSpeech.from_pretrained("model_name").to(device)
-    vocoder = SpeechT5HifiGan.from_pretrained("model_name").to(device)
-
-    spk_model_name = "speechbrain/spkrec-xvect-voxceleb"
-    speaker_model = EncoderClassifier.from_hparams(
-        source=spk_model_name,
-        run_opts={"device": device},
-        savedir=os.path.join("/tmp", spk_model_name),
-    )
-
-    # Load a sample from a dataset for default embedding
-    dataset = load_dataset("Alwaly/Wolof_TTS", split="train")
-    dataset = dataset.select(range(12003))
-    dataset = dataset.train_test_split(test_size=0.1)
-    example = dataset['test'][8]
-
-    return model, processor, vocoder, speaker_model, example
-
-model, processor, vocoder, speaker_model, default_example = load_models_and_data()
-
-def create_speaker_embedding(waveform):
-    with torch.no_grad():
-        speaker_embeddings = speaker_model.encode_batch(torch.tensor(waveform).unsqueeze(0).to(device))
-        speaker_embeddings = torch.nn.functional.normalize(speaker_embeddings, dim=2)
-        speaker_embeddings = speaker_embeddings.squeeze()
-    return speaker_embeddings
-
-def prepare_default_embedding(example):
-    audio = example["audio"]
-    return create_speaker_embedding(audio["array"])
-
-default_embedding = prepare_default_embedding(default_example)
-
-replacements = [
-    ("а", "a"),
-    ("à", "a"),
-    ('á', "a"),
-    ('ã', "a"),
-    ('ä', "a"),
-    ('α', "a"),
-    ("ă", "a"),
-    ("â", "a"),
-    ('ā', "a"),
-    ('ą', "a"),
-    ('ɓ', "b"),
-    ('β', "b"),
-    ("ç", "c"),
-    ('с', "c"),
-    ('ɗ', "d"),
-    ('đ', "d"),
-    ("è", "e"),
-    ('ẽ', "e"),
-    ("ë", "e"),
-    ("ð", "e"),
-    ('έ', "e"),
-    ('ɐ', "e"),
-    ('ə', "e"),
-    ('ξ', "e"),
-    ('н', "h"),
-    ("î", "i"),
-    ('í', "i"),
-    ("ị", "i"),
-    ("ï", "i"),
-    ('к', "k"),
-    ('ł', "l"),
-    ("ŋ", "n"),
-    ('ń', "n"),
-    ("ñ", "n"),
-    ('ῆ', "n"),
-    ('й', "n"),
-    ('η', "n"),
-    ("ó", "o"),
-    ('ồ', "o"),
-    ('ớ', "o"),
-    ('ὀ', "o"),
-    ("ô", "o"),
-    ("õ", "o"),
-    ('ò', "o"),
-    ('ø', "o"),
-    ('σ', "o"),
-    ("ο", "o"),
-    ("ο", "o"),
-    ('р', "p"),
-    ('ρ', "p"),
-    ("т", "t"),
-    ('ƭ', "t"),
-    ('ц', "u"),
-    ("ù", "u"),
-    ("û", "u"),
-    ('μ', "u"),
-    ('ш', "w"),
-#     ('у', "y"),
-#     ('ý', "y"),
-#     ('γ', "y"),
-]
-
-number_words = {
-    0: "dara", 1: "benn", 2: "ñaar", 3: "ñett", 4: "ñent", 5: "juróom ", 6: "juróom ak benn", 7: "juróom ak ñaar", 8: "juróom ak ñett", 9: "juróom ak ñent",
-    10: "fukk", 11: "fukk ak benn", 12: "fukk ak ñaar", 13: "fukk ak ñett", 14: "fukk ak ñent", 15: "fukk", 16: "fukk ak juróom ben", 17: "fukk ak juróom ñaar",
-    18: "fukk ak juróom ñett", 19: "fukk ak juróom ñent", 20: "ñaar fukk", 30: "ñett fukk", 40: "ñent fukk", 50: "juróom fukk", 60: "juróom benn fukk", 70: "juróom ñaar fukk",
-    80: "juróom ñett fukk", 90: "juróom ñent fukk", 100: "téeméer", 1000: " junni"
-}
-
-def number_to_words(number):
-    if number < 20:
-        return number_words[number]
-    elif number < 100:
-        tens, unit = divmod(number, 10)
-        return number_words[tens * 10] + (" " + number_words[unit] if unit else "")
-    elif number < 1000:
-        hundreds, remainder = divmod(number, 100)
-        return (number_words[hundreds] + " yüz" if hundreds > 1 else "yüz") + (" " + number_to_words(remainder) if remainder else "")
-    elif number < 1000000:
-        thousands, remainder = divmod(number, 1000)
-        return (number_to_words(thousands) + " bin" if thousands > 1 else "bin") + (" " + number_to_words(remainder) if remainder else "")
-    elif number < 1000000000:
-        millions, remainder = divmod(number, 1000000)
-        return number_to_words(millions) + " milyon" + (" " + number_to_words(remainder) if remainder else "")
-    elif number < 1000000000000:
-        billions, remainder = divmod(number, 1000000000)
-        return number_to_words(billions) + " milyar" + (" " + number_to_words(remainder) if remainder else "")
-    else:
-        return str(number)
-
-def replace_numbers_with_words(text):
-    def replace(match):
-        number = int(match.group())
-        return number_to_words(number)
-
-    # Find the numbers and change with words.
-    result = re.sub(r'\b\d+\b', replace, text)
-
-    return result
-
-def normalize_text(text):
-    # Convert to lowercase
-    text = text.lower()
-
-    # Replace numbers with words
-    text = replace_numbers_with_words(text)
-
-    # Apply character replacements
-    for old, new in replacements:
-        text = text.replace(old, new)
-
-    # Remove punctuation
-    text = re.sub(r'[^\w\s]', '', text)
-
+from num2words import num2words 
+
+# Vérification de la disponibilité de CUDA
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+# Chargement du modèle et du tokenizer
+try:
+    model = ParlerTTSForConditionalGeneration.from_pretrained("Moustapha91/parler-tts-mutli-wolof", torch_dtype=torch.float16).to(device)
+    tokenizer = AutoTokenizer.from_pretrained("Moustapha91/parler-tts-mutli-wolof")
+except Exception as e:
+    raise RuntimeError(f"Erreur lors du chargement du modèle : {e}")
+
+
+
+
+# Normalisation des nombres
+class EnglishNumberNormalizer:
+    def __call__(self, text):
+        # Trouver tous les nombres dans le texte
+        numbers = re.findall(r'\d+', text)
+        for number in numbers:
+            # Convertir le nombre en mots
+            text = text.replace(number, num2words(int(number), lang='fr'))
+        return text
+
+number_normalizer = EnglishNumberNormalizer()
+
+# Fonction de prétraitement
+def preprocess(text):
+    # Normaliser les nombres
+    text = number_normalizer(text).strip()
+    
+    # Remplacer les tirets par des espaces
+    text = text.replace("-", " ")
+    
+    # Ajouter un point à la fin si le texte ne se termine pas par une ponctuation
+    if not text.endswith(('.', '!', '?')):
+        text += "."
+    
+    # Traiter les abréviations
+    abbreviations_pattern = r'\b[A-Z][A-Z\.]+\b'
+    abbreviations = re.findall(abbreviations_pattern, text)
+    for abv in abbreviations:
+        # Séparer les lettres des abréviations (par exemple, "U.S.A." -> "U S A")
+        separated_abv = " ".join(abv.replace(".", ""))
+        text = text.replace(abv, separated_abv)
+    
     return text
 
-@spaces.GPU(duration=60)
-def text_to_speech(text, audio_file=None):
-    # Normalize the input text
-    normalized_text = normalize_text(text)
-
-    # Prepare the input for the model
-    inputs = processor(text=normalized_text, return_tensors="pt").to(device)
-
-    # Use the default speaker embedding
-    speaker_embeddings = default_embedding
-
-    # Generate speech
-    with torch.no_grad():
-        speech = model.generate_speech(inputs["input_ids"], speaker_embeddings.unsqueeze(0), vocoder=vocoder)
-
-    speech_np = speech.cpu().numpy()
-
-    return (16000, speech_np)
-
-iface = gr.Interface(
-    fn=text_to_speech,
-    inputs=[
-        gr.Textbox(label="Enter Woloftext to convert to speech")
-    ],
-    outputs=[
-        gr.Audio(label="Generated Speech", type="numpy")
-    ],
-    title="Wolof SpeechT5 Text-to-Speech Demo",
-    description="Enter Wolof text, and listen to the generated speech."
-)
-
-iface.launch(share=True)
+# Texte et description par défaut
+default_prompt = "Entreprenariat ci Senegal dafa am solo lool ci yokkuteg koom-koom, di gëna yokk liggéey ak indi gis-gis yu bees ci dëkk bi."
+default_description = """A crystal clear and distinct voice, with a moderate reading rate that facilitates understanding. The tone is monotonous, without variations or inflections, which provides a uniform listening experience. The voice is free of background noise and allows for continuous reading, without inappropriate pauses, thus ensuring a constant and pleasant flow."""
+
+
+
+# Fonction pour générer l'audio sans segmentation
+def generate_audio(prompt, description):
+    # Prétraiter le texte
+    prompt = preprocess(prompt)
+    
+    # Génération des IDs d'entrée
+    input_ids = tokenizer(description.strip(), return_tensors="pt").input_ids.to(device)
+    prompt_input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(device)
+
+    # Générer l'audio
+    generation_config = {
+    "temperature": 0.8,           # Contrôle la variabilité de la sortie
+    "max_new_tokens": 1000,       # Longueur maximale de la séquence générée
+    "do_sample": True,            # Active l'échantillonnage aléatoire
+    "top_k": 50,                  # Limite le nombre de tokens considérés
+    "repetition_penalty": 1.2,    # Pénalise la répétition de tokens
+    }
+
+    generation = model.generate(
+        input_ids=input_ids,
+        prompt_input_ids=prompt_input_ids,
+        **generation_config
+    )
 
+    #generation = model.generate(input_ids=input_ids, prompt_input_ids=prompt_input_ids)
+    audio_arr = generation.cpu().numpy().squeeze()  # Transformer en tableau numpy
+
+    # Taux d'échantillonnage
+    sampling_rate = model.config.sampling_rate
+
+    # Normaliser l'audio
+    audio_arr = audio_arr / np.max(np.abs(audio_arr))
+    torch.cuda.empty_cache()
+    return sampling_rate, audio_arr
+
+# Fonction pour mettre à jour le compteur de caractères
+def update_char_counter(text):
+    remaining_chars = 180 - len(text)
+    return f"Caractères restants : {remaining_chars}"
+
+# Interface Gradio
+def create_interface():
+    with gr.Blocks() as demo:
+        # Ajouter une image ou un logo
+        gr.Markdown("![Logo](https://huggingface.co/spaces/CONCREE/Adia_TTS/resolve/main/adia.png)") 
+
+        # Titre et description
+        gr.Markdown("# 🌟 Bienvenue sur Adia TTS 🌟")
+        gr.Markdown(f"[Adia TTS](https://huggingface.co/CONCREE/Adia_TTS) est un modèle de génération audio en wolof. Cette interface vous permet de générer des fichiers audio à partir de textes en wolof. Vous pouvez choisir une description pour personnaliser la voix générée.")
+
+        with gr.Row():
+            with gr.Column():
+                prompt_input = gr.Textbox(label="Entrez votre texte en wolof", placeholder="Adia TTS xeetu audio wolof la buy jàppale boroom këru liggéey yi ñu mëna def seen projet", value=default_prompt, max_length=180)
+                char_counter = gr.Label(value=update_char_counter(default_prompt))
+                description_input = gr.Textbox(label="Entrez une description pour la voix", value=default_description)
+                generate_button = gr.Button("Générer l'audio", variant="primary")
+
+            with gr.Column():
+                audio_output = gr.Audio(label="Audio généré", type="numpy")
+
+        # Section des exemples
+        gr.Markdown("## Exemples de textes et descriptions")
+        gr.Examples(
+            examples=[
+                [
+                 """Yeneen jumtukaay yuy dimbal mooy yi ñeel saytu xaalis, comptabilite ak yoriinu liggéey administratif. Marketing digital itam doon na jumtukaay bu am solo ngir yokk sa gis-gis.""",
+                    "A warm, natural, and friendly voice with a steady pace and clear pronunciation. The audio is crisp with no background noise, and the delivery is expressive but calm, giving a conversational feel.",
+                 
+                 
+                   ],
+                [
+                     """Liggéeyukaay ci wàllu mbay mi ci Senegal dafa am solo lool ci wàllu kaaraange dundu ak sos liggéey, ndax dafay boole xeeti liggéey yu bees yu melni agroecologie.""",
+                    "A crystal clear and distinct voice, with a moderate reading rate that facilitates understanding. The tone is monotonous, without variations or inflections, which provides a uniform listening experience. The voice is free of background noise and allows for continuous reading, without inappropriate pauses, thus ensuring a constant and pleasant flow.",
+                  ],
+                [
+                     """Politigu Senegaal, doxalinu demokraasi bu dëgër la, am wote yuy faral di am, te askan wi di ci bokk bu baax. Waaye, waxtaan yi am ci wàllu nguur, leer ak coppite yi am ci liggéeyuk""",
+                    "Adia's voice is very clear with a slight hint of expressiveness. The recording quality is moderate, with some background noise.",
+                  ],
+            ],
+            inputs=[prompt_input, description_input],
+            outputs=audio_output,
+            fn=generate_audio,  # Fonction à appeler lors du clic sur un exemple
+            label="Cliquez sur un exemple pour générer l'audio",
+            cache_examples=False,  
+        )
+
+        # Mettre à jour le compteur de caractères à chaque saisie
+        prompt_input.change(fn=update_char_counter, inputs=prompt_input, outputs=char_counter)
+
+        generate_button.click(fn=generate_audio, inputs=[prompt_input, description_input], outputs=audio_output)
+
+    return demo
+
+# Lancement de l'interface
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()