Update app.py

app.py

@@ -1,87 +1,59 @@
 import gradio as gr
 import torch
-from transformers.models.speecht5.number_normalizer import EnglishNumberNormalizer
-from string import punctuation
-import re
-import numpy as np  # Ensure NumPy is imported for audio data processing
-
 from parler_tts import ParlerTTSForConditionalGeneration
-from transformers import AutoTokenizer, AutoFeatureExtractor, set_seed
+from transformers import AutoTokenizer, set_seed
+import numpy as np
 
-# Set device to CPU only
-device = "cpu"
+# Set device
+device = "cuda:0" if torch.cuda.is_available() else "cpu"
 
-# Load Mini model and associated components with low memory usage
-repo_id = "TArtx/parler-tts-mini-v1-finetuned-12"
-model = ParlerTTSForConditionalGeneration.from_pretrained(repo_id).to(device)
+# Load model and tokenizer
+model = ParlerTTSForConditionalGeneration.from_pretrained("TArtx/parler-tts-mini-v1-finetuned-12").to(device)
 tokenizer = AutoTokenizer.from_pretrained("parler-tts/parler-tts-mini-v1")
-feature_extractor = AutoFeatureExtractor.from_pretrained("parler-tts/parler-tts-mini-v1")
 
 # Constants
-SAMPLE_RATE = feature_extractor.sampling_rate
+SAMPLE_RATE = model.config.sampling_rate
 SEED = 42
 
-# Default input text and description
+# Default inputs
 default_text = "This is a demonstration of my ability to convert written words into spoken language, seamlessly and naturally. As a text-to-speech model, my goal is to sound as clear and engaging as a human, making sure every word I say leaves an impression."
 default_description = "moderate speed, very clear, monotone, wonderful speech quality"
 
-# Number normalizer
-number_normalizer = EnglishNumberNormalizer()
-
-# Preprocessing function
-def preprocess(text):
-    text = number_normalizer(text).strip()
-    text = text.replace("-", " ")
-    if text[-1] not in punctuation:
-        text = f"{text}."
-    abbreviations_pattern = r'\b[A-Z][A-Z\.]+\b'
-
-    def separate_abb(chunk):
-        chunk = chunk.replace(".", "")
-        return " ".join(chunk)
-
-    abbreviations = re.findall(abbreviations_pattern, text)
-    for abv in abbreviations:
-        if abv in text:
-            text = text.replace(abv, separate_abb(abv))
-    return text
-
 # TTS generation function
 def gen_tts(text, description):
     try:
-        # Tokenize inputs and prompts with truncation to avoid memory issues
-        inputs = tokenizer(description.strip(), return_tensors="pt", truncation=True, max_length=128).to(device)
-        prompt = tokenizer(preprocess(text), return_tensors="pt", truncation=True, max_length=128).to(device)
-
+        # Set seed for reproducibility
         set_seed(SEED)
+
+        # Prepare inputs
+        input_ids = tokenizer(description.strip(), return_tensors="pt").input_ids.to(device)
+        prompt_input_ids = tokenizer(text.strip(), return_tensors="pt").input_ids.to(device)
+
+        # Generate audio
         generation = model.generate(
-            input_ids=inputs.input_ids,
-            prompt_input_ids=prompt.input_ids,
-            attention_mask=inputs.attention_mask,
-            prompt_attention_mask=prompt.prompt_attention_mask,
+            input_ids=input_ids, 
+            prompt_input_ids=prompt_input_ids,
             do_sample=True,
-            temperature=1.0,
+            temperature=0.7
         )
 
-        # Inspect the raw audio generation output
-        print(f"Generated audio shape: {generation.shape}")
-        print(f"Generated audio values: {generation.cpu().numpy().squeeze()}")
-
-        # Check if there are any meaningful values in the audio output
+        # Convert to numpy array
         audio_arr = generation.cpu().numpy().squeeze()
-        if np.all(audio_arr == 0):
-            raise ValueError("Generated audio is empty or silent.")
 
-        # Normalize the audio array to the range [-1, 1]
-        audio_arr = audio_arr / np.max(np.abs(audio_arr))
+        # Normalize audio
+        if np.max(np.abs(audio_arr)) > 0:
+            audio_arr = audio_arr / np.max(np.abs(audio_arr))
+            audio_arr = (audio_arr * np.iinfo(np.int16).max).astype(np.int16)
+        else:
+            # Fallback to white noise if generation fails
+            audio_arr = np.random.randint(-32768, 32767, SAMPLE_RATE * 10, dtype=np.int16)
 
-        # Convert the audio to 16-bit PCM (int16 format)
-        audio_arr = (audio_arr * np.iinfo(np.int16).max).astype(np.int16)
+        return SAMPLE_RATE, audio_arr
 
-        return SAMPLE_RATE, audio_arr  # Return sample rate and audio array
     except Exception as e:
         print(f"Error in TTS generation: {str(e)}")
-        return SAMPLE_RATE, np.zeros((SAMPLE_RATE,))  # Return silence in case of error
+        # Return white noise as fallback
+        return SAMPLE_RATE, np.random.randint(-32768, 32767, SAMPLE_RATE * 10, dtype=np.int16)
 
 # Gradio interface
 with gr.Blocks() as block:
@@ -100,9 +72,8 @@ with gr.Blocks() as block:
             audio_out = gr.Audio(label="Parler-TTS generation", type="numpy", elem_id="audio_out")
 
     inputs = [input_text, description]
-    outputs = audio_out  # Only output the audio component
-    run_button.click(fn=gen_tts, inputs=inputs, outputs=outputs, queue=True)
+    outputs = audio_out
+    run_button.click(fn=gen_tts, inputs=inputs, outputs=outputs)
 
 # Launch the interface
-block.queue()
-block.launch()
+block.launch(debug=True)