Spaces:
Runtime error
Runtime error
| import gradio as gr | |
| from transformers import pipeline | |
| # ----------------------- | |
| # 1. Language + model config | |
| # ----------------------- | |
| LANG_CODES = { | |
| "English": "en", | |
| "French": "fr", | |
| "German": "de", | |
| "Spanish": "es", | |
| "Swedish": "sv", | |
| } | |
| # Map (src_lang_code, tgt_lang_code) -> MarianMT model | |
| MODEL_MAP = { | |
| ("en", "fr"): "Helsinki-NLP/opus-mt-en-fr", | |
| ("fr", "en"): "Helsinki-NLP/opus-mt-fr-en", | |
| ("en", "de"): "Helsinki-NLP/opus-mt-en-de", | |
| ("de", "en"): "Helsinki-NLP/opus-mt-de-en", | |
| ("en", "es"): "Helsinki-NLP/opus-mt-en-es", | |
| ("es", "en"): "Helsinki-NLP/opus-mt-es-en", | |
| ("en", "sv"): "Helsinki-NLP/opus-mt-en-sv", | |
| ("sv", "en"): "Helsinki-NLP/opus-mt-sv-en", | |
| } | |
| # Lazy-loaded translation pipelines | |
| _translation_pipelines = {} | |
| # One small LLM for explanations / feedback | |
| explain_llm = pipeline("text2text-generation", model="google/flan-t5-small") | |
| def get_translation_pipeline(src_code: str, tgt_code: str): | |
| """ | |
| Returns a transformers pipeline for a given language pair, loading it lazily. | |
| """ | |
| key = (src_code, tgt_code) | |
| if key not in MODEL_MAP: | |
| raise ValueError(f"Language pair {src_code}->{tgt_code} not supported yet.") | |
| if key not in _translation_pipelines: | |
| model_name = MODEL_MAP[key] | |
| task = f"translation_{src_code}_to_{tgt_code}" | |
| _translation_pipelines[key] = pipeline(task, model=model_name) | |
| return _translation_pipelines[key] | |
| # ----------------------- | |
| # 2. Core translation logic | |
| # ----------------------- | |
| def _apply_style_hints(text: str, tone: str, domain: str, tgt_lang: str) -> str: | |
| """ | |
| MarianMT isn't instruction-tuned, but we can still stuff a hint into the input. | |
| It won't be perfect, but conceptually shows tone/domain-aware translation. | |
| """ | |
| hints = [] | |
| if domain != "General": | |
| hints.append(f"{domain} context") | |
| if tone != "Neutral": | |
| hints.append(f"{tone} tone") | |
| if hints: | |
| hint_str = ", ".join(hints) | |
| # Just prepend some natural-language hints in English. | |
| styled = f"[{hint_str} in {tgt_lang}] {text}" | |
| return styled | |
| return text | |
| def translate_text(text: str, src_lang: str, tgt_lang: str, tone: str, domain: str): | |
| """ | |
| Main translation function for the UI. | |
| """ | |
| text = (text or "").strip() | |
| if not text: | |
| return "Please enter some text to translate." | |
| if src_lang == tgt_lang: | |
| return text # trivial case | |
| src_code = LANG_CODES[src_lang] | |
| tgt_code = LANG_CODES[tgt_lang] | |
| try: | |
| translator = get_translation_pipeline(src_code, tgt_code) | |
| except ValueError as e: | |
| return str(e) | |
| styled_input = _apply_style_hints(text, tone, domain, tgt_lang) | |
| out = translator(styled_input, max_length=512) | |
| translated = out[0]["translation_text"] | |
| return translated.strip() | |
| def back_translate(text: str, src_lang: str, tgt_lang: str, tone: str, domain: str): | |
| """ | |
| Translate from src -> tgt, then back tgt -> src to check meaning preservation. | |
| """ | |
| text = (text or "").strip() | |
| if not text: | |
| return "Please enter some text to translate.", "" | |
| if src_lang == tgt_lang: | |
| return text, text | |
| # First translation: src -> tgt | |
| forward = translate_text(text, src_lang, tgt_lang, tone, domain) | |
| # Back translation: tgt -> src (no style hints on the way back) | |
| backward = translate_text(forward, tgt_lang, src_lang, "Neutral", "General") | |
| return forward, backward | |
| def explain_translation(src_text: str, translated_text: str, src_lang: str, tgt_lang: str): | |
| """ | |
| Use Flan-T5 to explain the translation in simple terms. | |
| """ | |
| src_text = (src_text or "").strip() | |
| translated_text = (translated_text or "").strip() | |
| if not src_text or not translated_text: | |
| return "Provide both the original text and the translation to get an explanation." | |
| prompt = ( | |
| "You are a helpful language teacher. " | |
| "Explain this translation to a learner in simple terms. " | |
| "Mention important word choices, tone, and any interesting grammar.\n\n" | |
| f"Source language: {src_lang}\n" | |
| f"Target language: {tgt_lang}\n\n" | |
| f"Original text:\n{src_text}\n\n" | |
| f"Translation:\n{translated_text}\n\n" | |
| "Explanation (in English, 1–2 short paragraphs):" | |
| ) | |
| out = explain_llm(prompt, max_new_tokens=256, temperature=0.4) | |
| return out[0]["generated_text"].strip() | |
| def learning_mode_feedback(src_text: str, user_translation: str, src_lang: str, tgt_lang: str): | |
| """ | |
| Compare user's translation to model translation and give feedback. | |
| """ | |
| src_text = (src_text or "").strip() | |
| user_translation = (user_translation or "").strip() | |
| if not src_text or not user_translation: | |
| return "Please provide both the original text and your translation." | |
| # Model's best guess (neutral, general) | |
| model_translation = translate_text(src_text, src_lang, tgt_lang, "Neutral", "General") | |
| prompt = ( | |
| "You are a friendly language teacher. Compare the student's translation to the model translation. " | |
| "Explain what is good, what could be improved, and give 2–4 concrete suggestions. " | |
| "Be encouraging, not harsh.\n\n" | |
| f"Source language: {src_lang}\n" | |
| f"Target language: {tgt_lang}\n\n" | |
| f"Original text:\n{src_text}\n\n" | |
| f"Student's translation:\n{user_translation}\n\n" | |
| f"Model's translation:\n{model_translation}\n\n" | |
| "Feedback (in English, short and structured):" | |
| ) | |
| out = explain_llm(prompt, max_new_tokens=320, temperature=0.4) | |
| feedback = out[0]["generated_text"].strip() | |
| return f"**Model translation:**\n\n{model_translation}\n\n---\n\n**Feedback:**\n\n{feedback}" | |
| # ----------------------- | |
| # 3. Gradio UI | |
| # ----------------------- | |
| LANG_CHOICES = list(LANG_CODES.keys()) | |
| TONES = ["Neutral", "Formal", "Informal", "Simplified"] | |
| DOMAINS = ["General", "Business", "Technical", "Casual"] | |
| with gr.Blocks(title="PolyglotLab – Smart Translator & Learning Studio") as demo: | |
| gr.Markdown( | |
| """ | |
| # 🌈 PolyglotLab – Smart Translator & Learning Studio | |
| A translation playground built with Hugging Face + Gradio. | |
| - ✨ Multi-language translation (English, French, German, Spanish, Swedish) | |
| - 🎭 Tone hints (neutral, formal, informal, simplified) | |
| - 🧩 Domain hints (business, technical, casual) | |
| - 🔁 Back-translation checks for meaning | |
| - 📚 Learning mode with feedback on *your* translations | |
| """ | |
| ) | |
| with gr.Tab("Smart Translate"): | |
| with gr.Row(): | |
| src_lang_in = gr.Dropdown(LANG_CHOICES, value="English", label="Source language") | |
| tgt_lang_in = gr.Dropdown(LANG_CHOICES, value="French", label="Target language") | |
| text_in = gr.Textbox( | |
| label="Text to translate", | |
| lines=4, | |
| placeholder="Type or paste text here...", | |
| ) | |
| with gr.Row(): | |
| tone_in = gr.Dropdown(TONES, value="Neutral", label="Tone hint") | |
| domain_in = gr.Dropdown(DOMAINS, value="General", label="Domain / context") | |
| explain_checkbox = gr.Checkbox(value=True, label="Explain the translation") | |
| translate_btn = gr.Button("Translate ✨") | |
| translated_out = gr.Textbox(label="Translation", lines=4) | |
| explanation_out = gr.Markdown(label="Explanation") | |
| def translate_and_explain(text, src, tgt, tone, domain, do_explain): | |
| translation = translate_text(text, src, tgt, tone, domain) | |
| if not do_explain: | |
| return translation, "" | |
| exp = explain_translation(text, translation, src, tgt) | |
| return translation, exp | |
| translate_btn.click( | |
| fn=translate_and_explain, | |
| inputs=[text_in, src_lang_in, tgt_lang_in, tone_in, domain_in, explain_checkbox], | |
| outputs=[translated_out, explanation_out], | |
| ) | |
| with gr.Tab("Back-translation Check"): | |
| gr.Markdown( | |
| "Translate from source to target, then back to source to see if the meaning is preserved." | |
| ) | |
| bt_src_lang = gr.Dropdown(LANG_CHOICES, value="English", label="Source language") | |
| bt_tgt_lang = gr.Dropdown(LANG_CHOICES, value="German", label="Target language") | |
| bt_text_in = gr.Textbox( | |
| label="Original text", | |
| lines=4, | |
| placeholder="Type a sentence to test...", | |
| ) | |
| bt_tone_in = gr.Dropdown(TONES, value="Neutral", label="Tone hint") | |
| bt_domain_in = gr.Dropdown(DOMAINS, value="General", label="Domain / context") | |
| bt_btn = gr.Button("Run Back-translation 🔁") | |
| bt_forward_out = gr.Textbox(label="Forward translation (src → tgt)", lines=4) | |
| bt_backward_out = gr.Textbox(label="Back-translation (tgt → src)", lines=4) | |
| bt_btn.click( | |
| fn=back_translate, | |
| inputs=[bt_text_in, bt_src_lang, bt_tgt_lang, bt_tone_in, bt_domain_in], | |
| outputs=[bt_forward_out, bt_backward_out], | |
| ) | |
| with gr.Tab("Learning Mode"): | |
| gr.Markdown( | |
| """ | |
| Paste a sentence and your own translation. | |
| The model will show its translation and give you friendly feedback. | |
| """ | |
| ) | |
| lm_src_lang = gr.Dropdown(LANG_CHOICES, value="English", label="Source language") | |
| lm_tgt_lang = gr.Dropdown(LANG_CHOICES, value="French", label="Target language") | |
| lm_src_text = gr.Textbox( | |
| label="Original text", | |
| lines=4, | |
| placeholder="Enter a sentence in the source language...", | |
| ) | |
| lm_user_translation = gr.Textbox( | |
| label="Your translation", | |
| lines=4, | |
| placeholder="Write your translation here...", | |
| ) | |
| lm_btn = gr.Button("Get feedback 🧑🏫") | |
| lm_feedback_out = gr.Markdown(label="Feedback") | |
| lm_btn.click( | |
| fn=learning_mode_feedback, | |
| inputs=[lm_src_text, lm_user_translation, lm_src_lang, lm_tgt_lang], | |
| outputs=lm_feedback_out, | |
| ) | |
| if __name__ == "__main__": | |
| demo.launch() | |