Text generation with the options of Qwen and Llama Instruct models

app.py

@@ -1,25 +1,26 @@
 import gradio as gr
-
+# import spaces
 from gradio_client import Client, handle_file
 
 import src.generate as generate
 import src.process as process
 
+# TODO: Abusing the 'global' notation for now so we can be flexible to multiple clients.
 global client
 
 # TODO: Ideally, instead of the Client method we're using for an external voice cloning app, we use the .load() function and pass in arguments to it directly while displaying the developer's desired UI.
 #chatterbox_space = gr.load("spaces/ResembleAI/Chatterbox")
 # ------------------- UI printing functions -------------------
 def clear_all():
-    # target, user_transcript, score_html, result_html, diff_html, tts_ui
-    return "", "", "", "", "", gr.Row.update(visible=False)
+    # target, user_transcript, score_html, diff_html, result_html,
+    # TODO(?): Add tts_text, tts_audio, clone_status (Maybe? Was there before.)
+    return "", "", "", "", "", "", "", None,
 
 
 def make_result_html(pass_threshold, passed, ratio):
     """Returns HTML summarizing results.
     Parameters:
-        pass_threshold: Minimum percentage of match between target and
-        recognized user utterance that counts as passing.
+        pass_threshold: Minimum percentage of match between target and recognized user utterance that counts as passing.
         passed: Whether the recognized user utterance is >= `pass_threshold`.
         ratio: Sequence match ratio.
     """
@@ -78,16 +79,16 @@ def make_html(sentence_match):
     return score_html, result_html, diff_html
 
 
-# ------------------- Core Check (Currently English-only) -------------------
+# ------------------- Core Check (English-only) -------------------
 # @spaces.GPU
 def get_user_transcript(audio_path: gr.Audio, target_sentence: str,
-                        asr_model_id: str, device_pref: str) -> (str, str):
+                        model_id: str, device_pref: str) -> (str, str):
     """ASR for the input audio and basic validation.
-    Uses the selected ASR model `asr_model_id` to recognize words in the input `audio_path`.
+    Uses the selected ASR model `model_id` to recognize words in the input `audio_path`.
     Parameters:
         audio_path: Processed audio file returned from gradio Audio component.
         target_sentence: Sentence the user needs to say.
-        asr_model_id: Desired ASR model.
+        model_id: Desired ASR model.
         device_pref: Preferred ASR processing device. Can be "auto", "cpu", "cuda".
     Returns:
         error_msg: If there's an error, a string describing what happened.
@@ -101,7 +102,7 @@ def get_user_transcript(audio_path: gr.Audio, target_sentence: str,
         return "Please start, record, then stop the audio recording before trying to transcribe.", ""
 
     # Runs the automatic speech recognition
-    user_transcript = process.run_asr(audio_path, asr_model_id, device_pref)
+    user_transcript = process.run_asr(audio_path, model_id, device_pref)
 
     # Handles processing errors.
     if isinstance(user_transcript, Exception):
@@ -109,13 +110,13 @@ def get_user_transcript(audio_path: gr.Audio, target_sentence: str,
     return "", user_transcript
 
 
-def transcribe_check(audio_path, target_sentence, asr_model_id, device_pref,
+def transcribe_check(audio_path, target_sentence, model_id, device_pref,
                      pass_threshold):
     """Transcribe user, calculate match to target sentence, create results HTML.
     Parameters:
         audio_path: Local path to recorded audio.
         target_sentence: Sentence the user needs to say.
-        asr_model_id: Desired ASR model.
+        model_id: Desired ASR model.
         device_pref: Preferred ASR processing device. Can be "auto", "cpu", "cuda".
     Returns:
         user_transcript: The recognized user utterance
@@ -127,8 +128,7 @@ def transcribe_check(audio_path, target_sentence, asr_model_id, device_pref,
     clone_audio = False
     # Transcribe user input
     error_msg, user_transcript = get_user_transcript(audio_path,
-                                                     target_sentence,
-                                                     asr_model_id,
+                                                     target_sentence, model_id,
                                                      device_pref)
     if error_msg:
         score_html = ""
@@ -144,74 +144,33 @@ def transcribe_check(audio_path, target_sentence, asr_model_id, device_pref,
         # Create the output to print out
         score_html, result_html, diff_html = make_html(sentence_match)
 
-    return (user_transcript, score_html, result_html, diff_html,
-            gr.Row(visible=clone_audio))
+    return user_transcript, score_html, result_html, diff_html, gr.Row(visible=clone_audio)
 
-def clone_voice(audio_input, text_input, exaggeration_input, cfgw_input,
-                seed_num_input, temperature_input):
+def clone_voice(audio_input, text_input):
+    # TODO: Note that this is the 'global' hack to pass in the client.
     global client
     # Additional specifications for Chatterbox include:
     # exaggeration_input=0.5,
     # temperature_input=0.8,
-    # seed_num_input=0,z
+    # seed_num_input=0,
     # cfgw_input=0.5,
     # api_name="/generate_tts_audio"
     return client.predict(text_input=text_input,
-                          audio_prompt_path_input=handle_file(audio_input),
-                          exaggeration_input=exaggeration_input,
-                          cfgw_input=cfgw_input,
-                          seed_num_input=seed_num_input,
-                          temperature_input=temperature_input)
+                            audio_prompt_path_input=handle_file(audio_input))
 
 
 # ------------------- UI -------------------
-with gr.Blocks(title="Voice Consent Gate") as demo:
-    gr.Markdown("# Voice Consent Gate: Demo")
-    with gr.Row():
-        with gr.Column():
-            with gr.Accordion(
-                    label="Click for further information on this demo",
-                    open=False):
-                gr.Markdown("""
-
+with gr.Blocks(title="Say the Sentence (English)") as demo:
+    gr.Markdown(
+        """
+        # 🎤 Say the Sentence (English)
+        1) Generate a sentence.  
+        2) Record yourself reading it.  
+        3) Transcribe & check your accuracy.  
+        4) If matched, clone your voice to speak any sentence you enter.
+        """
+    )
 
-                To create a basic voice cloning system with a voice consent gate, you need three parts:
-                1.  A way of generating novel consent sentences for the person whose voice will be cloned – the “speaker” – to say, making sure the sentence isn’t part of a previous recording but instead uniquely references the current consent context.
-                2. An _automatic speech recognition (ASR) system_ that recognizes the sentence conveying consent.
-                3. A _voice-cloning text-to-speech (TTS) system_ that takes as input text and the voice clonee’s speech snippets to generate speech.
-                Some voice-cloning TTS systems can now generate speech similar to a speaker’s voice using _just one sentence_. This means that a sentence used for consent can **also** be used for voice cloning. We demonstrate one way to do that here.
-                """)
-    with gr.Row():
-        with gr.Column(scale=2):
-            gr.Markdown(
-                """# 🎤 Say the Sentence (English)"""
-            )
-            gr.Markdown(
-            """
-            ## 1) Generate a sentence.  
-            ## 2) Record yourself reading it.  
-            ## 3) Transcribe & check your accuracy.  
-            ## 4) If matched, clone your voice to speak any sentence you enter.
-            """
-            )
-        with gr.Column():
-            consent_method = gr.Dropdown(label="Sentence generation method",
-                                         choices=["Llama 3.2 3B Instruct",
-                                                  "Pre-written"],
-                                         value="Pre-written")
-            asr_model = gr.Dropdown(label="Speech recognition model",
-                                    choices=["openai/whisper-tiny.en",  # fastest (CPU-friendly)
-                                            "openai/whisper-base.en",  # better accuracy, a bit slower
-                                            "distil-whisper/distil-small.en"
-                                            # optional distil English model
-                                            ],
-                                    value="openai/whisper-tiny.en",
-                                    )
-            voice_clone_model = gr.Dropdown(
-                label="Voice cloning model",
-                choices=["Chatterbox", ], value="Chatterbox")
-        #with gr.Column():
-        #    pass # Just for spacing
     with gr.Row():
         target = gr.Textbox(label="Target sentence", interactive=False,
                             placeholder="Click 'Generate sentence'")
@@ -221,10 +180,19 @@ with gr.Blocks(title="Voice Consent Gate") as demo:
         btn_clear = gr.Button("🧹 Clear")
 
     with gr.Row():
-        consent_audio = gr.Audio(sources=["microphone"], type="filepath",
-                                 label="Record your voice", key='consent_audio')
-
-    with gr.Accordion("Advanced ASR settings", open=False):
+        consent_audio = gr.Audio(sources=["microphone"], type="filepath", label="Record your voice", key='consent_audio')
+
+    with gr.Accordion("Advanced settings", open=False):
+        model_id = gr.Dropdown(
+            choices=[
+                "openai/whisper-tiny.en",  # fastest (CPU-friendly)
+                "openai/whisper-base.en",  # better accuracy, a bit slower
+                "distil-whisper/distil-small.en"  # optional distil English model
+                "distil-whisper/distil-small.en",
+            ],
+            value="openai/whisper-tiny.en",
+            label="ASR model (English only)",
+        )
         device_pref = gr.Radio(
             choices=["auto", "cpu", "cuda"],
             value="auto",
@@ -243,66 +211,47 @@ with gr.Blocks(title="Voice Consent Gate") as demo:
     diff_html = gr.HTML(
         label="Word-level diff (red = expected but missing / green = extra or replacement)")
 
-    gr.Markdown("## 🔁 Voice Consent Gate (opens upon consent)")
     # TODO: Ideally this is gr.Blocks, but that seems to have a visibility-change bug.
     with gr.Row(visible=False) as tts_ui:
-        # Using the render decorator so that we can access consent audio after it's recorded.
+        # Using the render decorator so that we can easily pass in the consent audio after it's recorded.
         @gr.render(inputs=consent_audio)
         def show_tts(audio_input):
+            # TODO: Abusing global, since we can't send a Client as a component to a function.
             global client
             if audio_input:
                 client = Client("ResembleAI/Chatterbox")
+                with gr.Row():
+                    gr.Markdown("# 🔁 Voice cloning")
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("## Audio input")
                         # Prepopulating with the consent audio.
-                        # Set interactive=True to be able to change.
-                        tts_audio = gr.Audio(audio_input, type="filepath")
+                        tts_audio = gr.Audio(audio_input, interactive=True, type="filepath")
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("## Text input")
                         tts_text = gr.Textbox(
                             "Now let's make my mum's favourite. So three mars bars into the pan. Then we add the tuna and just stir for a bit, just let the chocolate and fish infuse. A sprinkle of olive oil and some tomato ketchup. Now smell that. Oh boy this is going to be incredible.", interactive=True)
-                with gr.Row():
-                    # TODO: Ideally, these options aren't hardcoded -- e.g., using .load(), where they're imported, allowing for different options depending on the client.
-                    with gr.Accordion("More options", open=False):
-                        exaggeration = gr.Slider(
-                            0.25, 2, step=.05,
-                            label="Exaggeration (Neutral = 0.5, extreme values can be unstable)",
-                            value=.5
-                        )
-                        cfg_weight = gr.Slider(
-                            0.2, 1, step=.05, label="CFG/Pace", value=0.5
-                        )
-                        seed_num = gr.Number(value=0,
-                                             label="Random seed (0 for random)")
-                        temp = gr.Slider(0.05, 5, step=.05,
-                                         label="Temperature", value=.8)
                 with gr.Row():
                     clone_btn = gr.Button("Clone!")
                     cloned_audio = gr.Audio()
-                    clone_btn.click(fn=clone_voice,
-                                    inputs=[tts_audio, tts_text, exaggeration,
-                                            cfg_weight, seed_num, temp],
-                                    outputs=[cloned_audio])
+                    clone_btn.click(fn=clone_voice, inputs=[tts_audio, tts_text], outputs=[cloned_audio])
 
     # -------- Events --------
-    # Generate sentence: including model name + detailed prompt
-    btn_gen.click(
-        fn=generate.gen_sentence,
-        inputs=[consent_method, voice_clone_model],
-        outputs=target
-    )
+    # Use pre-specified sentence bank by default
+    btn_gen.click(fn=generate.gen_sentence_set, outputs=target)
+    # Or use LLM generation:
+    # btn_gen.click(fn=generate.gen_sentence_llm, outputs=target)
 
+    # TODO(?): clearing  tts_text, tts_audio, clone_status (not sure what that was)
     btn_clear.click(
         fn=clear_all,
-        outputs=[target, user_transcript, score_html, result_html, diff_html,
-                 tts_ui]
+        outputs=[target, user_transcript, score_html, result_html, diff_html]
     )
 
     btn_check.click(
         fn=transcribe_check,
-        inputs=[consent_audio, target, asr_model, device_pref, pass_threshold],
+        inputs=[consent_audio, target, model_id, device_pref, pass_threshold],
         outputs=[user_transcript, score_html, result_html, diff_html, tts_ui]
     )
 

src/generate.py

@@ -1,32 +1,16 @@
-# src/generate.py
-"""
-Module: generate
-----------------
-Handles the generation of "consent sentences" for the Voice Consent Gate demo.
-
-This module connects to an external language model (in this case, the public
-Hugging Face Space for Llama 3.2 3B Instruct) to generate natural-sounding
-sentences that users can read aloud to give informed consent for voice cloning.
-
-If the model call fails (e.g., due to rate limits or network issues),
-a fallback sentence is chosen from a small built-in sentence bank.
-
-Functions:
-    - _extract_llama_text(): Normalize the API output from the Llama demo.
-    - gen_sentence_llm(): Generate a consent sentence from the Llama model Space.
-    - gen_sentence_set(): Select a random prewritten sentence (for fallback/testing).
-"""
-
-import os
 import random
-from typing import Any
-from gradio_client import Client
+
+from transformers import pipeline, AutoTokenizer
 
 import src.process as process
-from src.prompts import get_consent_generation_prompt
 
+# You can choose to use either:
+# (1) a list of pre-specified sentences, in SENTENCE_BANK
+# (2) an LLM-generated sentence.
+# SENTENCE_BANK is used in the `gen_sentence_set` function.
+# LLM generation is used in the `gen_sentence_llm` function.
 
-# ------------------- Sentence Bank (unchanged) -------------------
+# ------------------- Sentence Bank (customize freely) -------------------
 SENTENCE_BANK = [
     "The quick brown fox jumps over the lazy dog.",
     "I promise to speak clearly and at a steady pace.",
@@ -41,153 +25,21 @@ SENTENCE_BANK = [
 ]
 
 
-# ------------------- Model / Space Configuration -------------------
-# The demo connects to the Llama 3.2 3B Instruct Space on Hugging Face.
-# You can override these defaults by setting environment variables in your Space.
-LLAMA_SPACE_ID = os.getenv(
-    "LLAMA_SPACE_ID", "huggingface-projects/llama-3.2-3B-Instruct"
-)
-LLAMA_API_NAME = "/chat"  # The Space exposes a single /chat endpoint.
-HF_TOKEN = os.getenv("HF_TOKEN")  # Optional; not required for public Spaces.
-
-
-def _extract_llama_text(result: Any) -> str:
-    """
-    Normalize the API response from the Llama 3.2 3B demo Space into plain text.
-
-    The Space’s `/chat` endpoint may return different shapes depending on how
-    the Gradio app is structured — sometimes a string, other times a dictionary
-    or list. This function recursively traverses and extracts the first
-    meaningful text string it finds.
-
-    Parameters
-    ----------
-    result : Any
-        The raw output returned by `client.predict()`.
-
-    Returns
-    -------
-    str
-        Cleaned text output (may be empty string if extraction fails).
-    """
-    if isinstance(result, str):
-        return result.strip()
-    if isinstance(result, (int, float, bool)):
-        return str(result)
-    if isinstance(result, list):
-        # If multiple segments are returned (e.g., multiple sentences),
-        # join them into one string.
-        parts = []
-        for x in result:
-            s = _extract_llama_text(x)
-            if s:
-                parts.append(s)
-        return " ".join(parts).strip()
-    if isinstance(result, dict):
-        # Common key names used in Gradio JSON responses
-        for key in ("text", "response", "content", "generated_text", "message"):
-            v = result.get(key)
-            if isinstance(v, str) and v.strip():
-                return v.strip()
-    return ""
-
-
-def gen_sentence(sentence_method="Pre-written", audio_model_name="Chatterbox"):
-    # chatterbox model name, detailed prompt (short_prompt=False)
-    if sentence_method == "Pre-written":
-        return gen_sentence_set()
-    else:
-        try:
-            return gen_sentence_llm(sentence_method,
-                audio_model_name,
-                fallback_on_error=False  # ← show errors during testing
-            )
-        except Exception as e:
-            # Show a helpful message directly in the Target sentence box
-            return f"[ERROR calling LLM] {type(e).__name__}: {e}"
-
-# TODO: Support more than just Llama 3.2 3B Instruct
-def gen_sentence_llm(sentence_method="Llama 3.2 3B Instruct", audio_model_name: str = "Chatterbox", *, fallback_on_error: bool = False  # Set True for production to avoid crashes
-) -> str:
-    """
-    Generate a consent sentence using the Llama 3.2 3B Instruct demo Space.
-
-    This function constructs a prompt describing the linguistic and ethical
-    requirements for a consent sentence (via `get_consent_generation_prompt`)
-    and sends it to the Llama demo hosted on Hugging Face Spaces.
-
-    The response is normalized into a single English sentence suitable
-    for reading aloud.
-
-    Parameters
-    ----------
-    audio_model_name : str, optional
-        The name of the voice-cloning model to mention in the sentence.
-        Defaults to "Chatterbox".
-    fallback_on_error : bool, optional
-        If True, return a random fallback sentence instead of raising
-        an error when the Space call fails. Default is False for debugging.
-
-    Returns
-    -------
-    str
-        A clean, human-readable consent sentence.
-
-    Raises
-    ------
-    Exception
-        Re-raises the underlying error if `fallback_on_error` is False.
-    """
-    # Generate the full natural-language prompt that the LLM will receive
-    prompt = get_consent_generation_prompt(audio_model_name)
-
-    try:
-        # Initialize Gradio client for the Llama demo Space
-        client = Client(LLAMA_SPACE_ID, hf_token=HF_TOKEN)
-
-        # The Llama demo exposes a simple /chat endpoint with standard decoding params
-        result = client.predict(
-            message=prompt,
-            max_new_tokens=128,
-            temperature=0.6,
-            top_p=0.9,
-            top_k=50,
-            repetition_penalty=1.2,
-            api_name=LLAMA_API_NAME,
-        )
-
-        # Normalize and clean up model output
-        text = _extract_llama_text(result)
-        text = process.normalize_text(text, lower=False)
-
-        # Handle empty or malformed outputs
-        if not text:
-            raise ValueError("Empty response from Llama Space")
-
-        # In case the model produces multiple lines or options, pick the first full sentence
-        first_line = next((ln.strip() for ln in text.splitlines() if ln.strip()), "")
-        return first_line or text
-
-    except Exception as e:
-        print(f"[gen_sentence_llm] Llama Space call failed: {type(e).__name__}: {e}")
-        if fallback_on_error:
-            # If fallback is enabled, use a predefined sentence instead
-            return random.choice(SENTENCE_BANK)
-        # Otherwise propagate the exception so the UI displays it
-        raise
-
-
-def gen_sentence_set() -> str:
-    """
-    Return a sentence from a predefined static list.
-
-    This is used as a simple fallback generator when model-based
-    generation is unavailable or for testing the ASR pipeline
-    without network access.
-
-    Returns
-    -------
-    str
-        A single English sentence from the fallback bank.
+def gen_sentence_llm():
+    """Generates a sentence using an LLM.
+    Returns:
+        Normalized text string to display in the UI.
     """
+    prompt = ""
+    tokenizer = AutoTokenizer.from_pretrained("openai-community/gpt2")
+    generator = pipeline('text-generation', model='gpt2')
+    result = generator(prompt, stop_strings=[".", ], num_return_sequences=1,
+                       tokenizer=tokenizer, pad_token_id=tokenizer.eos_token_id)
+    display_text = process.normalize_text(result[0]["generated_text"],
+                                          lower=False)
+    return display_text
+
+
+def gen_sentence_set():
+    """Returns a sentence for the user to say using a prespecified set of options."""
     return random.choice(SENTENCE_BANK)

src/prompts.py

@@ -1,59 +1,47 @@
-import random
+# src/utils/prompts.py
 
-def get_consent_generation_prompt(audio_model_name: str) -> str:
+def get_consent_generation_prompt(audio_model_name: str, short_prompt: bool = False) -> str:
     """
     Returns a text prompt instructing the model to generate a natural-sounding
     consent sentence for voice cloning with the specified model.
 
     Args:
         audio_model_name (str): Name of the audio model to mention in the prompt.
+        short_prompt (bool): If True, returns a concise one-line prompt suitable
+            for direct model input. If False (default), returns the full detailed prompt.
 
     Returns:
-        str: The prompt text, with a randomized topic for the second sentence.
+        str: The prompt text.
     """
 
-    # Possible neutral or everyday topics to diversify phonetic variety
-    topics = [
-        "the weather",
-        "daily routines",
-        "travel or commuting",
-        "food or cooking",
-        "music",
-        "nature or seasons",
-        "time of day",
-        "a calm place like a park or café",
-        "light exercise or relaxation",
-        "reading or learning something new",
-        "a pleasant conversation with a friend",
-        "observing surroundings like streets or sky",
-        "working or focusing quietly"
-    ]
-
-    # Randomly choose one for this prompt instance
-    topic = random.choice(topics)
+    if short_prompt:
+        return (
+            f"Generate one natural, spoken-style English sentence (10–20 words) in which a person "
+            f"clearly gives informed consent to use their voice for generating synthetic audio "
+            f"with the model {audio_model_name}. The sentence should sound conversational, include "
+            f"a clear consent phrase like 'I give my consent' or 'I agree', mention {audio_model_name} "
+            f"by name, and be phonetically varied but neutral in tone. Output only the final sentence."
+        )
 
     return f"""
-        Generate exactly two short, natural-sounding English sentences (10-15 words each) that a person could say aloud, using everyday language.
-
-        Sentence 1 (Consent sentence):
-        * Clearly states informed consent to use their voice for generating synthetic audio with an AI model called {audio_model_name}.
-        * Must explicitly include a consent phrase such as “I give my consent,” “I agree,” or “I allow.”
-        * Must clearly mention the model name {audio_model_name} in the sentence.
-        * Should sound fluent, polite, and natural to read aloud.
-        * Should have a neutral or positive tone and be self-contained.
-
-        Sentence 2 (Phonetic variety sentence):
-        * Should not repeat the consent content.
-        * Adds phonetic variety with a neutral descriptive clause, for example about {topic}.
-        * Should be fluent, natural, and comfortable to read aloud.
-        * Should sound polite and neutral, without emotional extremes.
-        * Should include diverse vowels and consonants naturally for clear pronunciation.
-
-        FORMAT:
-        * Output EXACTLY two sentences.
-        * No numbering, no quotes, no bullet points, and no introductory text.
-        * Use standard punctuation.
-
-        Example format (don’t copy text, just the format):
-        I give my consent to use my voice for generating audio with the model {audio_model_name}. The weather is clear and calm this afternoon, and I’m speaking at an even pace.
-        """
+        Generate a short, natural-sounding English sentence (10–20 words) that a person could say aloud 
+        to clearly state their informed consent to use their voice for generating synthetic audio with 
+        an AI model called {audio_model_name}.
+
+        The sentence should:
+        - Sound natural and conversational, not like legal text.
+        - Explicitly include a consent phrase, such as “I give my consent,” “I agree,” or “I allow.”
+        - Mention the model name ({audio_model_name}) clearly in the sentence.
+        - Include a neutral descriptive clause before or after the consent phrase to add phonetic variety 
+        (e.g., “The weather today is bright and calm” or “This recording is made clearly and freely.”)
+        - Have a neutral or polite tone (no emotional extremes).
+        - Be comfortable to read aloud and phonetically rich, covering diverse vowels and consonants naturally.
+        - Be self-contained, so the full sentence can serve as an independent audio clip.
+
+        Examples of structure to follow:
+        - “The weather is clear and warm today. I give my consent to use my voice for generating audio with the model {audio_model_name}.”
+        - “I give my consent to use my voice for generating audio with the model {audio_model_name}. This statement is made freely and clearly.”
+        - “Good afternoon. I agree to the use of my recorded voice for audio generation with the model {audio_model_name}.”
+
+        The output should be a single, natural sentence ready to be spoken aloud for recording purposes.
+        """