Update app.py

app.py

@@ -722,8 +722,9 @@ def generate_audio_elevenlabs(text):
         return None
 
 
-repo_id = "parler-tts/parler-tts-mini-v1"
+# Parler TTS integration
 
+repo_id = "parler-tts/parler-tts-mini-v1"
 parler_model = ParlerTTSForConditionalGeneration.from_pretrained(repo_id).to(device)
 parler_tokenizer = AutoTokenizer.from_pretrained(repo_id)
 parler_feature_extractor = AutoFeatureExtractor.from_pretrained(repo_id)
@@ -791,6 +792,200 @@ def generate_audio_parler_tts(text):
     logging.debug(f"Audio saved to {combined_audio_path}")
     return combined_audio_path
 
+# Streaming Parler-TTS with the Base Streamer
+
+import io
+import math
+from queue import Queue
+from threading import Thread
+from typing import Optional
+
+from transformers.generation.streamers import BaseStreamer
+
+class ParlerTTSStreamer(BaseStreamer):
+    def __init__(
+        self,
+        model: ParlerTTSForConditionalGeneration,
+        device: Optional[str] = None,
+        play_steps: Optional[int] = 10,
+        stride: Optional[int] = None,
+        timeout: Optional[float] = None,
+    ):
+        self.decoder = model.decoder
+        self.audio_encoder = model.audio_encoder
+        self.generation_config = model.generation_config
+        self.device = device if device is not None else model.device
+
+        self.play_steps = play_steps
+        if stride is not None:
+            self.stride = stride
+        else:
+            hop_length = math.floor(self.audio_encoder.config.sampling_rate / self.audio_encoder.config.frame_rate)
+            self.stride = hop_length * (play_steps - self.decoder.num_codebooks) // 6
+        self.token_cache = None
+        self.to_yield = 0
+
+        self.audio_queue = Queue()
+        self.stop_signal = None
+        self.timeout = timeout
+
+    def apply_delay_pattern_mask(self, input_ids):
+        _, delay_pattern_mask = self.decoder.build_delay_pattern_mask(
+            input_ids[:, :1],
+            bos_token_id=self.generation_config.bos_token_id,
+            pad_token_id=self.generation_config.decoder_start_token_id,
+            max_length=input_ids.shape[-1],
+        )
+        input_ids = self.decoder.apply_delay_pattern_mask(input_ids, delay_pattern_mask)
+
+        mask = (delay_pattern_mask != self.generation_config.bos_token_id) & (delay_pattern_mask != self.generation_config.pad_token_id)
+        input_ids = input_ids[mask].reshape(1, self.decoder.num_codebooks, -1)
+        input_ids = input_ids[None, ...]
+
+        input_ids = input_ids.to(self.audio_encoder.device)
+
+        decode_sequentially = (
+            self.generation_config.bos_token_id in input_ids
+            or self.generation_config.pad_token_id in input_ids
+            or self.generation_config.eos_token_id in input_ids
+        )
+        if not decode_sequentially:
+            output_values = self.audio_encoder.decode(
+                input_ids,
+                audio_scales=[None],
+            )
+        else:
+            sample = input_ids[:, 0]
+            sample_mask = (sample >= self.audio_encoder.config.codebook_size).sum(dim=(0, 1)) == 0
+            sample = sample[:, :, sample_mask]
+            output_values = self.audio_encoder.decode(sample[None, ...], [None])
+
+        audio_values = output_values.audio_values[0, 0]
+        return audio_values.cpu().float().numpy()
+
+    def put(self, value):
+        batch_size = value.shape[0] // self.decoder.num_codebooks
+        if batch_size > 1:
+            raise ValueError("ParlerTTSStreamer only supports batch size 1")
+
+        if self.token_cache is None:
+            self.token_cache = value
+        else:
+            self.token_cache = torch.concatenate([self.token_cache, value[:, None]], dim=-1)
+
+        if self.token_cache.shape[-1] % self.play_steps == 0:
+            audio_values = self.apply_delay_pattern_mask(self.token_cache)
+            self.on_finalized_audio(audio_values[self.to_yield : -self.stride])
+            self.to_yield += len(audio_values) - self.to_yield - self.stride
+
+    def end(self):
+        if self.token_cache is not None:
+            audio_values = self.apply_delay_pattern_mask(self.token_cache)
+        else:
+            audio_values = np.zeros(self.to_yield)
+
+        self.on_finalized_audio(audio_values[self.to_yield :], stream_end=True)
+
+    def on_finalized_audio(self, audio: np.ndarray, stream_end: bool = False):
+        self.audio_queue.put(audio, timeout=self.timeout)
+        if stream_end:
+            self.audio_queue.put(self.stop_signal, timeout=self.timeout)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        value = self.audio_queue.get(timeout=self.timeout)
+        if not isinstance(value, np.ndarray) and value == self.stop_signal:
+            raise StopIteration()
+        else:
+            return value
+
+def numpy_to_mp3(audio_array, sampling_rate):
+    if np.issubdtype(audio_array.dtype, np.floating):
+        max_val = np.max(np.abs(audio_array))
+        audio_array = (audio_array / max_val) * 32767
+        audio_array = audio_array.astype(np.int16)
+
+    audio_segment = AudioSegment(
+        audio_array.tobytes(),
+        frame_rate=sampling_rate,
+        sample_width=audio_array.dtype.itemsize,
+        channels=1
+    )
+
+    mp3_io = io.BytesIO()
+    audio_segment.export(mp3_io, format="mp3", bitrate="320k")
+
+    mp3_bytes = mp3_io.getvalue()
+    mp3_io.close()
+
+    return mp3_bytes
+
+sampling_rate = model.audio_encoder.config.sampling_rate
+frame_rate = model.audio_encoder.config.frame_rate
+
+def generate_base(text, description, play_steps_in_s=2.0):
+    play_steps = int(frame_rate * play_steps_in_s)
+    streamer = ParlerTTSStreamer(model, device=device, play_steps=play_steps)
+
+    inputs = parler_tokenizer(description, return_tensors="pt").to(device)
+    prompt = parler_tokenizer(text, return_tensors="pt").to(device)
+
+    generation_kwargs = dict(
+        input_ids=inputs.input_ids,
+        prompt_input_ids=prompt.input_ids,
+        streamer=streamer,
+        do_sample=True,
+        temperature=1.0,
+        min_new_tokens=10,
+    )
+
+    set_seed(SEED)
+    thread = Thread(target=model.generate, kwargs=generation_kwargs)
+    thread.start()
+
+    for new_audio in streamer:
+        print(f"Sample of length: {round(new_audio.shape[0] / sampling_rate, 2)} seconds")
+        yield numpy_to_mp3(new_audio, sampling_rate=sampling_rate)
+
+css = """
+        #share-btn-container {
+            display: flex;
+            padding-left: 0.5rem !important;
+            padding-right: 0.5rem !important;
+            background-color: #000000;
+            justify-content: center;
+            align-items: center;
+            border-radius: 9999px !important; 
+            width: 13rem;
+            margin-top: 10px;
+            margin-left: auto;
+            flex: unset !important;
+        }
+        #share-btn {
+            all: initial;
+            color: #ffffff;
+            font-weight: 600;
+            cursor: pointer;
+            font-family: 'IBM Plex Sans', sans-serif;
+            margin-left: 0.5rem !important;
+            padding-top: 0.25rem !important;
+            padding-bottom: 0.25rem !important;
+            right:0;
+        }
+        #share-btn * {
+            all: unset !important;
+        }
+        #share-btn-container div:nth-child(-n+2){
+            width: auto !important;
+            min-height: 0px !important;
+        }
+        #share-btn-container .wrap {
+            display: none !important;
+        }
+"""
+
 
 
 
@@ -1198,7 +1393,68 @@ def fetch_google_flights(departure_id="JFK", arrival_id="BHM", outbound_date=cur
 
 
 
-with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
+# with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
+#     with gr.Row():
+#         with gr.Column():
+#             state = gr.State()
+
+#             chatbot = gr.Chatbot([], elem_id="RADAR:Channel 94.1", bubble_full_width=False)
+#             choice = gr.Radio(label="Select Style", choices=["Details", "Conversational"], value="Conversational")
+#             retrieval_mode = gr.Radio(label="Retrieval Mode", choices=["VDB", "KGF"], value="VDB")
+#             model_choice = gr.Dropdown(label="Choose Model", choices=["GPT-4o", "Phi-3.5"], value="GPT-4o")
+
+#             # Link the dropdown change to handle_model_choice_change
+#             model_choice.change(fn=handle_model_choice_change, inputs=model_choice, outputs=[retrieval_mode, choice, choice])
+
+#             gr.Markdown("<h1 style='color: red;'>Talk to RADAR</h1>", elem_id="voice-markdown")
+
+#             chat_input = gr.Textbox(show_copy_button=True, interactive=True, show_label=False, label="ASK Radar !!!", placeholder="Hey Radar...!!")
+#             tts_choice = gr.Radio(label="Select TTS System", choices=["Alpha", "Beta"], value="Alpha")
+#             retriever_button = gr.Button("Retriever")
+
+#             clear_button = gr.Button("Clear")
+#             clear_button.click(lambda: [None, None], outputs=[chat_input, state])
+
+#             gr.Markdown("<h1 style='color: red;'>Radar Map</h1>", elem_id="Map-Radar")
+#             location_output = gr.HTML()
+#             audio_output = gr.Audio(interactive=False, autoplay=True)
+
+#             def stop_audio():
+#                 audio_output.stop()
+#                 return None
+
+#             retriever_sequence = (
+#                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="Ask_Retriever")
+#                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query")
+#                 .then(fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response")
+#                 .then(fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder")
+#                 .then(fn=clear_textbox, inputs=[], outputs=[chat_input])
+#             )
+
+#             chat_input.submit(fn=stop_audio, inputs=[], outputs=[audio_output])
+#             chat_input.submit(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query").then(
+#                 fn=bot, inputs=[chatbot, choice, tts_choice, retrieval_mode, model_choice], outputs=[chatbot, audio_output], api_name="generate_voice_response"
+#             ).then(
+#                 fn=show_map_if_details, inputs=[chatbot, choice], outputs=[location_output, location_output], api_name="map_finder"
+#             ).then(
+#                 fn=clear_textbox, inputs=[], outputs=[chat_input]
+#             )
+
+#             audio_input = gr.Audio(sources=["microphone"], streaming=True, type='numpy', every=0.1)
+#             audio_input.stream(transcribe_function, inputs=[state, audio_input], outputs=[state, chat_input], api_name="voice_query_to_text")
+
+#         # with gr.Column():
+#         #     weather_output = gr.HTML(value=fetch_local_weather())
+#         #     news_output = gr.HTML(value=fetch_local_news())
+#         #     events_output = gr.HTML(value=fetch_local_events())
+
+# demo.queue()
+# demo.launch(share=True)
+
+
+
+
+with gr.Blocks(theme='Pijush2023/scikit-learn-pijush', css=css) as demo:
     with gr.Row():
         with gr.Column():
             state = gr.State()
@@ -1208,7 +1464,6 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
             retrieval_mode = gr.Radio(label="Retrieval Mode", choices=["VDB", "KGF"], value="VDB")
             model_choice = gr.Dropdown(label="Choose Model", choices=["GPT-4o", "Phi-3.5"], value="GPT-4o")
 
-            # Link the dropdown change to handle_model_choice_change
             model_choice.change(fn=handle_model_choice_change, inputs=model_choice, outputs=[retrieval_mode, choice, choice])
 
             gr.Markdown("<h1 style='color: red;'>Talk to RADAR</h1>", elem_id="voice-markdown")
@@ -1224,10 +1479,6 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
             location_output = gr.HTML()
             audio_output = gr.Audio(interactive=False, autoplay=True)
 
-            def stop_audio():
-                audio_output.stop()
-                return None
-
             retriever_sequence = (
                 retriever_button.click(fn=stop_audio, inputs=[], outputs=[audio_output], api_name="Ask_Retriever")
                 .then(fn=add_message, inputs=[chatbot, chat_input], outputs=[chatbot, chat_input], api_name="voice_query")
@@ -1248,10 +1499,20 @@ with gr.Blocks(theme='Pijush2023/scikit-learn-pijush') as demo:
             audio_input = gr.Audio(sources=["microphone"], streaming=True, type='numpy', every=0.1)
             audio_input.stream(transcribe_function, inputs=[state, audio_input], outputs=[state, chat_input], api_name="voice_query_to_text")
 
-        # with gr.Column():
-        #     weather_output = gr.HTML(value=fetch_local_weather())
-        #     news_output = gr.HTML(value=fetch_local_news())
-        #     events_output = gr.HTML(value=fetch_local_events())
+        with gr.Column():
+            with gr.Tab("Base"):
+                with gr.Row():
+                    with gr.Column():
+                        input_text = gr.Textbox(label="Input Text", lines=2, value="Please surprise me and speak in whatever voice you enjoy.", elem_id="input_text")
+                        description = gr.Textbox(label="Description", lines=2, value="", elem_id="input_description")
+                        play_seconds = gr.Slider(3.0, 7.0, value=3.0, step=2, label="Streaming interval in seconds", info="Lower = shorter chunks, lower latency, more codec steps")
+                        run_button = gr.Button("Generate Audio", variant="primary")
+                    with gr.Column():
+                        audio_out = gr.Audio(label="Parler-TTS generation", format="mp3", elem_id="audio_out", streaming=True, autoplay=True)
+
+                inputs = [input_text, description, play_seconds]
+                outputs = [audio_out]
+                run_button.click(fn=generate_base, inputs=inputs, outputs=outputs, queue=True)
 
 demo.queue()
 demo.launch(share=True)