Add translation to English sample with automatic source language detection

app.py

@@ -8,6 +8,7 @@ from image_classification import create_image_classification_tab
 from image_to_text import create_image_to_text_tab
 from text_to_image import create_text_to_image_tab
 from text_to_speech import create_text_to_speech_tab
+from translation import create_translation_tab
 
 
 class App:
@@ -25,7 +26,8 @@ class App:
         image_classification_model: str,
         text_to_speech_model: str,
         audio_transcription_model: str,
-        chat_model: str
+        chat_model: str,
+        fallback_translation_model: str
     ):
         """Initialize the App with an InferenceClient instance and model IDs.
         
@@ -38,6 +40,8 @@ class App:
             text_to_speech_model: Model ID for text-to-speech.
             audio_transcription_model: Model ID for automatic speech recognition.
             chat_model: Model ID for chatbot.
+            fallback_translation_model: Fallback translation model ID for languages
+                without specific translation models.
         """
         self.client = client
         self.text_to_image_model = text_to_image_model
@@ -46,6 +50,7 @@ class App:
         self.text_to_speech_model = text_to_speech_model
         self.audio_transcription_model = audio_transcription_model
         self.chat_model = chat_model
+        self.fallback_translation_model = fallback_translation_model
 
     def run(self):
         """Launch the Gradio application with all building block tabs.
@@ -70,6 +75,11 @@ class App:
                     create_asr_tab(self.client, self.audio_transcription_model)
                 with gr.Tab("Chat"):
                     create_chatbot_tab(self.chat_model)
+                with gr.Tab("Translation to English"):
+                    create_translation_tab(
+                        self.client,
+                        self.fallback_translation_model
+                    )
 
             demo.launch()
 
@@ -83,6 +93,7 @@ if __name__ == "__main__":
         image_classification_model=getenv("IMAGE_CLASSIFICATION_MODEL"),
         text_to_speech_model=getenv("TEXT_TO_SPEECH_MODEL"),
         audio_transcription_model=getenv("AUDIO_TRANSCRIPTION_MODEL"),
-        chat_model=getenv("CHAT_MODEL")
+        chat_model=getenv("CHAT_MODEL"),
+        fallback_translation_model=getenv("FALLBACK_TRANSLATION_MODEL")
     )
     app.run()

requirements.txt

@@ -1,6 +1,7 @@
 gradio>=5.49.1
 huggingface-hub>=0.34.0,<1.0
 inflect>=7.0.0
+langdetect>=1.0.9
 librosa>=0.10.0
 numpy>=1.24.0
 pandas>=2.0.0

translation.py

@@ -0,0 +1,130 @@
+from functools import partial
+import gradio as gr
+from huggingface_hub import InferenceClient
+from langdetect import detect, LangDetectException
+
+
+# Language code mapping to Helsinki-NLP translation models
+# If a specific language pair model doesn't exist, we'll use the multilingual model
+LANGUAGE_TO_MODEL_MAP = {
+    "fr": "Helsinki-NLP/opus-mt-fr-en",
+    "de": "Helsinki-NLP/opus-mt-de-en",
+    "es": "Helsinki-NLP/opus-mt-es-en",
+    "it": "Helsinki-NLP/opus-mt-it-en",
+    "pt": "Helsinki-NLP/opus-mt-pt-en",
+    "ru": "Helsinki-NLP/opus-mt-ru-en",
+    "zh": "Helsinki-NLP/opus-mt-zh-en",
+    "ja": "Helsinki-NLP/opus-mt-ja-en",
+    "ko": "Helsinki-NLP/opus-mt-ko-en",
+    "ar": "Helsinki-NLP/opus-mt-ar-en",
+    "nl": "Helsinki-NLP/opus-mt-nl-en",
+    "pl": "Helsinki-NLP/opus-mt-pl-en",
+    "tr": "Helsinki-NLP/opus-mt-tr-en",
+    "vi": "Helsinki-NLP/opus-mt-vi-en",
+    "hi": "Helsinki-NLP/opus-mt-hi-en",
+    "cs": "Helsinki-NLP/opus-mt-cs-en",
+    "sv": "Helsinki-NLP/opus-mt-sv-en",
+    "fi": "Helsinki-NLP/opus-mt-fi-en",
+    "uk": "Helsinki-NLP/opus-mt-uk-en",
+    "ro": "Helsinki-NLP/opus-mt-ro-en",
+    "th": "Helsinki-NLP/opus-mt-th-en",
+}
+
+
+def detect_language(text: str) -> str:
+    """Detect the language of the input text using langdetect library.
+    
+    Uses the langdetect library, which is a Python port of Google's language-detection
+    library. It supports over 55 languages and is known for high accuracy, especially
+    for languages with unique character sets like Korean, Japanese, and Chinese.
+    
+    Args:
+        text: Input text to detect the language of.
+    
+    Returns:
+        ISO 639-1 language code (e.g., "en", "fr", "de", "ko", "ja") of the detected language.
+    
+    Raises:
+        LangDetectException: If the language cannot be detected (e.g., text is too short).
+    """
+    try:
+        language_code = detect(text)
+        return language_code
+    except LangDetectException:
+        # If detection fails, default to English (will be handled by translation logic)
+        return "en"
+
+
+def get_translation_model(language_code: str, fallback_model: str) -> str:
+    """Get the appropriate translation model for a given language code.
+    
+    Args:
+        language_code: ISO 639-1 language code (e.g., "fr", "de", "en").
+        fallback_model: Fallback model to use if no specific model is available.
+    
+    Returns:
+        Model ID for translation, or fallback model if language not in mapping.
+    """
+    if language_code == "en":
+        return None  # Already in English
+    return LANGUAGE_TO_MODEL_MAP.get(language_code, fallback_model)
+
+
+def translate_to_english(
+    client: InferenceClient,
+    fallback_translation_model: str,
+    text: str
+) -> str:
+    """Translate text to English using automatic language detection.
+    
+    First detects the source language using the langdetect library, then selects
+    the appropriate translation model and translates the text to English.
+    
+    Args:
+        client: Hugging Face InferenceClient instance for API calls.
+        fallback_translation_model: Fallback translation model to use if no
+            language-specific model is available.
+        text: Input text to translate to English.
+    
+    Returns:
+        String containing the translated text in English, or a message if the
+        text is already in English.
+    """
+    # Detect the language using langdetect library
+    detected_lang = detect_language(text)
+    
+    # Check if already in English
+    if detected_lang == "en":
+        return text
+    
+    # Get the appropriate translation model
+    translation_model = get_translation_model(detected_lang, fallback_translation_model)
+    
+    # Translate using the selected model
+    result = client.translation(text, model=translation_model)
+    return result.translation_text
+
+
+def create_translation_tab(
+    client: InferenceClient,
+    fallback_translation_model: str
+):
+    """Create the translation to English tab in the Gradio interface.
+    
+    This function sets up all UI components for translation with automatic
+    language detection, including input textbox, translate button, and output textbox.
+    
+    Args:
+        client: Hugging Face InferenceClient instance for API calls.
+        fallback_translation_model: Fallback translation model to use if no
+            language-specific model is available.
+    """
+    gr.Markdown("Translate text to English. The source language will be automatically detected.")
+    translation_input = gr.Textbox(label="Input Text", lines=5)
+    translation_button = gr.Button("Translate")
+    translation_output = gr.Textbox(label="Translated Text", lines=5, interactive=False)
+    translation_button.click(
+        fn=partial(translate_to_english, client, fallback_translation_model),
+        inputs=translation_input,
+        outputs=translation_output
+    )