Upload 3 files

app.py

@@ -1,122 +1,56 @@
-from transformers import (BlenderbotSmallTokenizer,
-                        logging)
-from mtranslate import translate
-from io import BytesIO
-from base64 import b64encode
-import gradio as gr
-from speech_recognition import Recognizer,AudioFile
-from gtts import gTTS
-from blender_model import blender_onnx_model
+"""Deploying AI Voice Chatbot Gradio App."""
+from gradio import Audio, Interface, Textbox
 
-#supress huggingface warnings
-logging.set_verbosity_error()
-bot_tokenizer_name="facebook/blenderbot_small-90M"
-max_answer_length=100
-bot_language="en"
-main_language = 'de'
-bot_tokenizer = BlenderbotSmallTokenizer.from_pretrained(bot_tokenizer_name)
-#load chatbot model
-bot_model=blender_onnx_model
+from utils import (TextGenerationPipeline, from_en_translation,
+                   html_audio_autoplay, stt, to_en_translation, tts,
+                   tts_to_bytesio)
 
-def app(audio):
-    """
-    It takes voice input from user then 
-    responds it both verbally and in text.
-    """
-    text=stt(audio)
-    bot_response_en,bot_response_de=answer_generation(text)
-    voice_bot=tts(bot_response_de)
-    b64 = b64encode(voice_bot).decode()
-    #html code that automatically play sounds
-    html = f"""
-    <audio controls autoplay>
-    <source src="data:audio/wav;base64,{b64}" type="audio/wav">
-    </audio>
-    """
-    return text,html,bot_response_de,bot_response_en
+max_answer_length = 100
+desired_language = "de"
+response_generator_pipe = TextGenerationPipeline(max_length=max_answer_length)
 
-def stt(audio):
-    """
-    speech to text converter
 
-    Args:
-        audio: record of user speech
+def main(audio: object) -> tuple[str, str, str, object]:
+    """Calls functions for deploying gradio app.
 
-    Returns:
-        text (str): recognized speech of user
-    """
-    r = Recognizer()
-    # open the file
-    with AudioFile(audio) as source:
-        # listen for the data (load audio to memory)
-        audio_data = r.record(source)
-        # recognize (convert from speech to text)
-        text = r.recognize_google(audio_data,
-                                    language=main_language)
-    return text
-
-def answer_generation(user_input_de:str):
-    """
-    it takes user input as text in german language. 
-    Then it translates into English. Blenderbot works only in English.
-    Then the model generates an answer w.r.t English version of the input.
-    Finally, bot's response is translated into German.
+    It responds both verbally and in text
+    by taking voice input from user.
 
     Args:
-        user_input (str): text version of user's speech
+        audio (object): recorded speech of user
 
     Returns:
-        translated_bot_response (str): bot's response in german language
-    """
-    #de-en translation
-    user_input_en=translate(user_input_de,
-                            bot_language,
-                            main_language)
-    inputs = bot_tokenizer(user_input_en,
-                            return_tensors="pt")
-    generation= bot_model.generate(**inputs,
-                            max_length=max_answer_length)
-    bot_response_en=bot_tokenizer.decode(generation[0],
-                            skip_special_tokens = True)
-    #en-de translation
-    bot_response_de=translate(bot_response_en,
-                            main_language,
-                            bot_language)
-    
-    return bot_response_en,bot_response_de
+        tuple containing
 
-def tts(text:str):
-    """converts text into audio bytes
-
-    Args:
-        text (str): generated answer of bot
-
-    Returns:
-        bytes_object(bytes): suitable format for html autoplay sound option
+        - user_speech_text (str) : recognized speech
+        - bot_response_de (str) : translated answer of bot
+        - bot_response_en (str) : bot's original answer
+        - html (object) : autoplayer for bot's speech
     """
-    tts = gTTS(text=text,
-                lang=main_language,
-                slow=False)
-    bytes_object = BytesIO()
-    tts.write_to_fp(bytes_object)
-    bytes_object.seek(0)
-    return bytes_object.getvalue()
+    user_speech_text = stt(audio, desired_language)
+    tranlated_text = to_en_translation(user_speech_text, desired_language)
+    bot_response_en = response_generator_pipe(tranlated_text)
+    bot_response_de = from_en_translation(bot_response_en, desired_language)
+    bot_voice = tts(bot_response_de, desired_language)
+    bot_voice_bytes = tts_to_bytesio(bot_voice)
+    html = html_audio_autoplay(bot_voice_bytes)
+    return user_speech_text, bot_response_de, bot_response_en, html
+
 
-logo_image_path="German_AI_Voicebot.png"
-logo = f"<center><img src='file/{logo_image_path}' width=180px></center>"
-gr.Interface(
-    fn=app, 
+Interface(
+    fn=main,
     inputs=[
-        gr.Audio(source="microphone", type="filepath",
-        ), 
+        Audio(
+            source="microphone",
+            type="filepath",
+        ),
     ],
     outputs=[
-        gr.Textbox(label="You said: ").style(css="{color: red}"),
+        Textbox(label="You said: "),
+        Textbox(label="AI said: "),
+        Textbox(label="AI said (English): "),
         "html",
-        gr.Textbox(label="AI said: "),
-        gr.Textbox(label="AI said (English): "),
     ],
     live=True,
     allow_flagging="never",
-    description=logo,
-    ).launch()
+).launch(debug=True)

utils.py

@@ -0,0 +1,157 @@
+"""Some utility functions for the app."""
+from base64 import b64encode
+from io import BytesIO
+
+from gtts import gTTS
+from mtranslate import translate
+from speech_recognition import AudioFile, Recognizer
+from transformers import (BlenderbotSmallForConditionalGeneration,
+                          BlenderbotSmallTokenizer)
+
+
+def stt(audio: object, language: str) -> str:
+    """Converts speech to text.
+
+    Args:
+        audio: record of user speech
+
+    Returns:
+        text (str): recognized speech of user
+    """
+    r = Recognizer()
+    # open the audio file
+    with AudioFile(audio) as source:
+        # listen for the data (load audio to memory)
+        audio_data = r.record(source)
+        # recognize (convert from speech to text)
+        text = r.recognize_google(audio_data, language=language)
+    return text
+
+
+def to_en_translation(text: str, language: str) -> str:
+    """Translates text from specified language to English.
+
+    Args:
+        text (str): input text
+        language (str): desired language
+
+    Returns:
+        str: translated text
+    """
+    return translate(text, "en", language)
+
+
+def from_en_translation(text: str, language: str) -> str:
+    """Translates text from english to specified language.
+
+    Args:
+        text (str): input text
+        language (str): desired language
+
+    Returns:
+        str: translated text
+    """
+    return translate(text, language, "en")
+
+
+class TextGenerationPipeline:
+    """Pipeline for text generation of blenderbot model.
+
+    Returns:
+        str: generated text
+    """
+
+    # load tokenizer and the model
+    model_name = "facebook/blenderbot_small-90M"
+    tokenizer = BlenderbotSmallTokenizer.from_pretrained(model_name)
+    model = BlenderbotSmallForConditionalGeneration.from_pretrained(model_name)
+
+    def __init__(self, **kwargs):
+        """Specififying text generation parameters.
+
+        For example: max_length=100 which generates text shorter than
+        100 tokens. Visit:
+        https://huggingface.co/docs/transformers/main_classes/text_generation
+        for more parameters
+        """
+        self.__dict__.update(kwargs)
+
+    def preprocess(self, text) -> str:
+        """Tokenizes input text.
+
+        Args:
+            text (str): user specified text
+
+        Returns:
+            torch.Tensor (obj): text representation as tensors
+        """
+        return self.tokenizer(text, return_tensors="pt")
+
+    def postprocess(self, outputs) -> str:
+        """Converts tensors into text.
+
+        Args:
+            outputs (torch.Tensor obj): model text generation output
+
+        Returns:
+            str: generated text
+        """
+        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+    def __call__(self, text: str) -> str:
+        """Generates text from input text.
+
+        Args:
+            text (str): user specified text
+
+        Returns:
+            str: generated text
+        """
+        tokenized_text = self.preprocess(text)
+        output = self.model.generate(**tokenized_text, **self.__dict__)
+        return self.postprocess(output)
+
+
+def tts(text: str, language: str) -> object:
+    """Converts text into audio object.
+
+    Args:
+        text (str): generated answer of bot
+
+    Returns:
+        object: text to speech object
+    """
+    return gTTS(text=text, lang=language, slow=False)
+
+
+def tts_to_bytesio(tts_object: object) -> bytes:
+    """Converts tts object to bytes.
+
+    Args:
+        tts_object (object): audio object obtained from gtts
+
+    Returns:
+        bytes: audio bytes
+    """
+    bytes_object = BytesIO()
+    tts_object.write_to_fp(bytes_object)
+    bytes_object.seek(0)
+    return bytes_object.getvalue()
+
+
+def html_audio_autoplay(bytes: bytes) -> object:
+    """Creates html object for autoplaying audio at gradio app.
+
+    Args:
+        bytes (bytes): audio bytes
+
+    Returns:
+        object: html object that provides audio autoplaying
+    """
+    b64 = b64encode(bytes).decode()
+    html = f"""
+    <audio controls autoplay>
+    <source src="data:audio/wav;base64,{b64}" type="audio/wav">
+    </audio>
+    """
+    return html