Update app.py

app.py

@@ -1,5 +1,6 @@
 import time
-from typing import Dict, List, Tuple, Any
+from dataclasses import dataclass
+from typing import Dict, List, Tuple, Any, Optional
 
 import gradio as gr
 from huggingface_hub import HfApi
@@ -14,7 +15,7 @@ I18N: Dict[str, Dict[str, str]] = {
         "title": "Model Fit Finder (CPU)",
         "intro": (
             "Pick your NLP task and constraints. The Space will recommend an appropriate model type "
-            "and list at least 3 concrete Hugging Face models, with short rationale."
+            "and list at least 3 concrete Hugging Face models. Recommendations change based on your settings."
         ),
         "ui_lang": "UI language",
         "tab_main": "Model advisor",
@@ -37,17 +38,21 @@ I18N: Dict[str, Dict[str, str]] = {
         "task_sim": "Semantic similarity / duplicates / search",
         "rec_type": "Recommended model type: {model_type}",
         "rationale": "Rationale:",
+        "settings": "Settings used:",
         "models_min3": "Models (min. 3):",
-        "emb_note": "Note: embedding models do not generate text; they produce vectors for similarity/search.",
-        "qa_note": "Note: extractive QA works best when you provide the relevant context text.",
-        "instr_note": "Note: instruction-tuned models follow your prompts; smaller variants are CPU-friendly.",
+        "why_these": "Why these models:",
+        "warning": "Warning:",
+        "qa_need_docs": "Extractive QA needs a context document/text. With no documents, consider an instruction model or embeddings-based search.",
+        "note_emb": "Embedding models do not generate text; they produce vectors for similarity/search.",
+        "note_qa": "Extractive QA finds answers in the provided context.",
+        "note_instr": "Instruction-tuned models follow prompts; smaller variants are CPU-friendly.",
         "bonus_note": "Popular model from Hub (selected by task tag and downloads).",
     },
     "PL": {
         "title": "Model Fit Finder (CPU)",
         "intro": (
             "Wybierz zadanie NLP i ograniczenia. Space zarekomenduje typ modelu "
-            "i pokaże co najmniej 3 konkretne modele z Hugging Face wraz z uzasadnieniem."
+            "i pokaże co najmniej 3 modele. Rekomendacje zmieniają się zależnie od ustawień."
         ),
         "ui_lang": "Język interfejsu",
         "tab_main": "Doradca modeli",
@@ -70,10 +75,14 @@ I18N: Dict[str, Dict[str, str]] = {
         "task_sim": "Semantyczne podobieństwo / duplikaty / wyszukiwanie",
         "rec_type": "Rekomendowany typ modelu: {model_type}",
         "rationale": "Uzasadnienie:",
+        "settings": "Użyte ustawienia:",
         "models_min3": "Modele (min. 3):",
-        "emb_note": "Uwaga: modele embeddingowe nie generują tekstu; produkują wektory do podobieństwa/wyszukiwania.",
-        "qa_note": "Uwaga: QA extractive działa najlepiej, gdy podasz kontekst (tekst źródłowy).",
-        "instr_note": "Uwaga: modele instrukcyjne wykonują polecenia; mniejsze warianty są przyjazne dla CPU.",
+        "why_these": "Dlaczego te modele:",
+        "warning": "Ostrzeżenie:",
+        "qa_need_docs": "QA extractive wymaga kontekstu (dokumentu/tekstu). Bez dokumentów rozważ model instrukcyjny albo wyszukiwanie embeddingowe.",
+        "note_emb": "Modele embeddingowe nie generują tekstu; produkują wektory do podobieństwa/wyszukiwania.",
+        "note_qa": "QA extractive znajduje odpowiedzi w podanym kontekście.",
+        "note_instr": "Modele instrukcyjne wykonują polecenia; mniejsze warianty są przyjazne dla CPU.",
         "bonus_note": "Popularny model z Hub (dobrany po tagu zadania i pobraniach).",
     },
 }
@@ -82,29 +91,80 @@ def t(ui_lang: str, key: str) -> str:
     return I18N.get(ui_lang, I18N["EN"]).get(key, I18N["EN"].get(key, key))
 
 # -----------------------
-# Stable baseline recommendations (min. 3 per type)
+# Internal stable values
 # -----------------------
-RECOMMENDATIONS: Dict[str, List[Tuple[str, str]]] = {
+TASK_CHAT = "CHAT"
+TASK_QA = "QA"
+TASK_SIM = "SIM"
+
+def task_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [
+        (t(ui_lang, "task_chat"), TASK_CHAT),
+        (t(ui_lang, "task_qa"), TASK_QA),
+        (t(ui_lang, "task_sim"), TASK_SIM),
+    ]
+
+def yesno_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [(t(ui_lang, "yes"), "YES"), (t(ui_lang, "no"), "NO")]
+
+def data_lang_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [(t(ui_lang, "en"), "EN"), (t(ui_lang, "pl"), "PL"), (t(ui_lang, "mixed"), "MIXED")]
+
+def priority_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [(t(ui_lang, "speed"), "SPEED"), (t(ui_lang, "quality"), "QUALITY")]
+
+# -----------------------
+# Candidate pool with metadata so settings can affect ranking
+# -----------------------
+@dataclass(frozen=True)
+class Candidate:
+    model_id: str
+    # heuristics / tags:
+    size: str        # "small" | "base" | "large"
+    languages: str   # "EN" | "MULTI"
+    cpu_ok: bool
+    note_en: str
+    note_pl: str
+
+CANDIDATES: Dict[str, List[Candidate]] = {
     "instruction": [
-        ("google/flan-t5-small", "Light text2text, good CPU baseline for instruction following."),
-        ("google/flan-t5-base", "Better quality, slower than small; still workable on CPU."),
-        ("google-t5/t5-small", "Simple text2text fallback when you want a fast baseline."),
+        Candidate("google/flan-t5-small", "small", "EN", True,
+                  "Very light instruction-following text2text model.", "Bardzo lekki model text2text do poleceń."),
+        Candidate("google/flan-t5-base", "base", "EN", True,
+                  "Better quality than small; slower on CPU.", "Lepsza jakość niż small; wolniejszy na CPU."),
+        Candidate("google-t5/t5-small", "small", "EN", True,
+                  "Fast fallback text2text baseline.", "Szybki fallback text2text."),
+        # multilingual-ish option (not perfect, but helps when user insists on PL/mixed for generation)
+        Candidate("google/mt5-small", "small", "MULTI", True,
+                  "Multilingual T5 small for mixed-language tasks.", "Wielojęzyczny mT5 small dla zadań mix języków."),
+        Candidate("google/mt5-base", "base", "MULTI", True,
+                  "Multilingual, higher quality than mt5-small; slower.", "Wielojęzyczny, lepsza jakość niż mt5-small; wolniejszy."),
     ],
     "qa": [
-        ("distilbert/distilbert-base-cased-distilled-squad", "Fast extractive QA on CPU; classic choice."),
-        ("distilbert/distilbert-base-uncased-distilled-squad", "Very popular SQuAD QA default."),
-        ("deepset/bert-base-cased-squad2", "SQuAD2; handles 'no answer' cases better."),
+        Candidate("distilbert/distilbert-base-cased-distilled-squad", "small", "EN", True,
+                  "Fast extractive QA; classic CPU choice.", "Szybki QA extractive; klasyk na CPU."),
+        Candidate("distilbert/distilbert-base-uncased-distilled-squad", "small", "EN", True,
+                  "Popular extractive QA default.", "Popularny domyślny QA extractive."),
+        Candidate("deepset/bert-base-cased-squad2", "base", "EN", True,
+                  "SQuAD2 variant; better 'no answer' behavior.", "Wariant SQuAD2; lepiej obsługuje 'brak odpowiedzi'."),
+        # multilingual QA is trickier; we provide one common multilingual baseline
+        Candidate("deepset/xlm-roberta-base-squad2", "base", "MULTI", True,
+                  "Multilingual extractive QA baseline (XLM-R).", "Wielojęzyczny QA extractive (XLM-R)."),
     ],
     "embeddings": [
-        ("sentence-transformers/all-MiniLM-L6-v2", "Popular sentence embeddings; fast on CPU."),
-        ("intfloat/e5-small-v2", "Strong retrieval embeddings; good quality/speed tradeoff."),
-        ("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "Multilingual; better for PL/mixed."),
+        Candidate("sentence-transformers/all-MiniLM-L6-v2", "small", "EN", True,
+                  "Very fast sentence embeddings; great for similarity on CPU.", "Bardzo szybkie embeddingi; świetne do podobieństwa na CPU."),
+        Candidate("sentence-transformers/all-mpnet-base-v2", "base", "EN", True,
+                  "Higher quality embeddings than MiniLM; slower.", "Lepsza jakość niż MiniLM; wolniejsze."),
+        Candidate("intfloat/e5-small-v2", "small", "EN", True,
+                  "Strong retrieval embeddings, good speed/quality balance.", "Mocne embeddingi do wyszukiwania; dobry balans."),
+        Candidate("intfloat/e5-base-v2", "base", "EN", True,
+                  "Higher quality e5; heavier on CPU.", "Lepsza jakość e5; cięższy na CPU."),
+        Candidate("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "base", "MULTI", True,
+                  "Multilingual embeddings; good for PL/mixed.", "Wielojęzyczne embeddingi; dobre dla PL/mix."),
     ],
 }
 
-# If you want Polish descriptions here as well, keep EN here and localize notes in output.
-# (Model IDs are universal; notes can be in EN and output can add localized note lines.)
-
 # -----------------------
 # Hub bonus models (cache)
 # -----------------------
@@ -112,10 +172,6 @@ _HUB_CACHE: Dict[Tuple[str, str], Tuple[float, List[str]]] = {}
 CACHE_TTL_SEC = 6 * 60 * 60  # 6h
 
 def _language_tag_predicate(tags: List[str], data_lang_value: str) -> bool:
-    """
-    data_lang_value is one of: EN, PL, MIXED (internal values).
-    HF tags aren't perfectly consistent; we do best-effort filtering.
-    """
     if data_lang_value == "MIXED":
         return True
     target = "en" if data_lang_value == "EN" else "pl"
@@ -123,15 +179,13 @@ def _language_tag_predicate(tags: List[str], data_lang_value: str) -> bool:
     tags_lower = {str(x).lower() for x in (tags or [])}
     return any(c in tags_lower for c in candidates)
 
-def hub_bonus_models(pipeline_tag: str, data_lang_value: str, limit: int = 12) -> List[str]:
+def hub_bonus_models(pipeline_tag: str, data_lang_value: str, limit: int = 20) -> List[str]:
     key = (pipeline_tag, data_lang_value)
     now = time.time()
-
     if key in _HUB_CACHE:
         ts, cached = _HUB_CACHE[key]
         if now - ts < CACHE_TTL_SEC:
             return cached
-
     try:
         models = api.list_models(filter=pipeline_tag, sort="downloads", direction=-1, limit=limit)
         out = []
@@ -146,102 +200,215 @@ def hub_bonus_models(pipeline_tag: str, data_lang_value: str, limit: int = 12) -
         return []
 
 # -----------------------
-# Internal "task ids" (do NOT depend on UI language)
+# Ranking rules (this is what makes settings matter)
 # -----------------------
-TASK_CHAT = "CHAT"
-TASK_QA = "QA"
-TASK_SIM = "SIM"
+def score_candidate(c: Candidate, data_lang_value: str, cpu_only: bool, priority: str) -> Tuple[int, List[str]]:
+    score = 0
+    reasons: List[str] = []
 
-def task_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    """Return Gradio dropdown choices as (label, value)."""
-    return [
-        (t(ui_lang, "task_chat"), TASK_CHAT),
-        (t(ui_lang, "task_qa"), TASK_QA),
-        (t(ui_lang, "task_sim"), TASK_SIM),
-    ]
+    # CPU constraint
+    if cpu_only:
+        if c.cpu_ok:
+            score += 2
+            reasons.append("CPU-friendly" if True else "")
+        else:
+            score -= 100  # effectively exclude
+            reasons.append("Not CPU-friendly")
 
-def yesno_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    return [(t(ui_lang, "yes"), "YES"), (t(ui_lang, "no"), "NO")]
+    # Language preference
+    if data_lang_value in ("PL", "MIXED"):
+        if c.languages == "MULTI":
+            score += 4
+            reasons.append("Multilingual (better for PL/mixed)")
+        else:
+            score -= 1
+            reasons.append("EN-focused")
+    else:  # EN
+        if c.languages == "EN":
+            score += 3
+            reasons.append("EN-optimized")
+        else:
+            score += 1
+            reasons.append("Multilingual")
 
-def data_lang_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    return [(t(ui_lang, "en"), "EN"), (t(ui_lang, "pl"), "PL"), (t(ui_lang, "mixed"), "MIXED")]
+    # Priority: speed vs quality
+    if priority == "SPEED":
+        if c.size == "small":
+            score += 4
+            reasons.append("Smaller/faster")
+        elif c.size == "base":
+            score += 1
+            reasons.append("Medium size")
+        else:
+            score -= 1
+            reasons.append("Heavier/slower")
+    else:  # QUALITY
+        if c.size == "base":
+            score += 4
+            reasons.append("Better quality baseline")
+        elif c.size == "small":
+            score += 2
+            reasons.append("Fast but may be lower quality")
+        else:
+            score += 3
+            reasons.append("High capacity")
 
-def priority_choices(ui_lang: str) -> List[Tuple[str, str]]:
-    return [(t(ui_lang, "speed"), "SPEED"), (t(ui_lang, "quality"), "QUALITY")]
+    return score, reasons
+
+def pick_models(model_type: str, data_lang_value: str, cpu_only: bool, priority: str, k: int = 4) -> Tuple[List[Candidate], Dict[str, List[str]]]:
+    candidates = CANDIDATES[model_type]
+    scored: List[Tuple[int, Candidate, List[str]]] = []
+    for c in candidates:
+        s, reasons = score_candidate(c, data_lang_value, cpu_only, priority)
+        scored.append((s, c, reasons))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+
+    chosen: List[Candidate] = []
+    why: Dict[str, List[str]] = {}
+    for s, c, reasons in scored:
+        if s < -50:
+            continue
+        if c.model_id not in {x.model_id for x in chosen}:
+            chosen.append(c)
+            why[c.model_id] = reasons
+        if len(chosen) >= k:
+            break
+
+    # ensure min 3
+    if len(chosen) < 3:
+        # fallback: take top regardless of language
+        for s, c, reasons in scored:
+            if c.model_id not in {x.model_id for x in chosen} and s > -50:
+                chosen.append(c)
+                why[c.model_id] = reasons
+            if len(chosen) >= 3:
+                break
+
+    return chosen, why
 
 # -----------------------
-# Recommendation logic
+# Main recommend function (now settings drive different outputs)
 # -----------------------
 def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, cpu_only: bool, priority: str) -> str:
+    warning: Optional[str] = None
+
     if task_id == TASK_SIM:
         model_type = "embeddings"
-        why = (
-            "You want semantic similarity / duplicate detection / search. Use embeddings + cosine similarity."
+        why_task = (
+            "You want semantic similarity / deduplication / search. Embeddings + cosine similarity fit best."
             if ui_lang == "EN"
-            else "Chcesz podobieństwo semantyczne / duplikaty / wyszukiwanie. Użyj embeddingów + podobieństwa cosinusowego."
+            else "Chcesz podobieństwo semantyczne / deduplikację / wyszukiwanie. Najlepsze są embeddingi + cosine similarity."
         )
         pipeline_tag = "sentence-similarity"
-        note_key = "emb_note"
+        note_key = "note_emb"
     elif task_id == TASK_QA:
         model_type = "qa"
-        why = (
+        why_task = (
             "You have a context (document/text) and a question. Extractive QA finds answers in the context."
             if ui_lang == "EN"
-            else "Masz kontekst (dokument/tekst) i pytanie. QA extractive znajduje odpowiedź w kontekście."
+            else "Masz kontekst (dokument/tekst) i pytanie. QA extractive znajduje odpowiedzi w kontekście."
         )
         pipeline_tag = "question-answering"
-        note_key = "qa_note"
+        note_key = "note_qa"
+        if has_docs == "NO":
+            warning = t(ui_lang, "qa_need_docs")
     else:
         model_type = "instruction"
-        why = (
+        why_task = (
             "You want instruction-following responses (chat/explain/summarize). Instruction-tuned models fit best."
             if ui_lang == "EN"
             else "Chcesz odpowiedzi sterowane poleceniem (chat/wyjaśnianie/streszczanie). Najlepsze są modele instrukcyjne."
         )
         pipeline_tag = "text-generation"
-        note_key = "instr_note"
+        note_key = "note_instr"
 
-    recs = RECOMMENDATIONS[model_type].copy()
+    # Pick models based on settings
+    chosen, why_map = pick_models(model_type, data_lang_value, cpu_only, priority, k=4)
 
-    # Add 1–2 "bonus" models from Hub, filtered by task tag + best-effort language tags.
-    bonus = hub_bonus_models(pipeline_tag, data_lang_value, limit=12)
-    existing = {mid for mid, _ in recs}
-    bonus = [m for m in bonus if m not in existing]
-    for m in bonus[:2]:
-        recs.append((m, t(ui_lang, "bonus_note")))
+    # Add 1–2 hub bonus models, but only if they diversify beyond chosen
+    bonus = hub_bonus_models(pipeline_tag, data_lang_value, limit=25)
+    chosen_ids = {c.model_id for c in chosen}
+    bonus = [m for m in bonus if m not in chosen_ids]
+    bonus = bonus[:2]
 
+    # Build output
     lines: List[str] = []
     lines.append(t(ui_lang, "rec_type").format(model_type=model_type))
     lines.append("")
     lines.append(t(ui_lang, "rationale"))
-    lines.append(f"- {why}")
+    lines.append(f"- {why_task}")
     lines.append("")
+    lines.append(t(ui_lang, "settings"))
+    lines.append(f"- data language: {data_lang_value}")
+    lines.append(f"- priority: {priority}")
+    lines.append(f"- cpu only: {cpu_only}")
+    lines.append(f"- has documents: {has_docs}")
+    lines.append("")
+
+    if warning:
+        lines.append(t(ui_lang, "warning"))
+        lines.append(f"- {warning}")
+        lines.append("")
+
     lines.append(t(ui_lang, "models_min3"))
-    for mid, note in recs[:5]:
-        lines.append(f"- {mid} — {note}")
+    for c in chosen:
+        note = c.note_en if ui_lang == "EN" else c.note_pl
+        lines.append(f"- {c.model_id} — {note}")
+
+    for mid in bonus:
+        lines.append(f"- {mid} — {t(ui_lang, 'bonus_note')}")
+
     lines.append("")
-    lines.append(t(ui_lang, note_key))
+    lines.append(t(ui_lang, "why_these"))
+    for c in chosen:
+        reasons = why_map.get(c.model_id, [])
+        # Localize reason snippets lightly
+        if ui_lang == "PL":
+            localized = []
+            for r in reasons:
+                if r == "CPU-friendly":
+                    localized.append("Działa na CPU")
+                elif r == "Multilingual (better for PL/mixed)":
+                    localized.append("Wielojęzyczny (lepszy dla PL/mix)")
+                elif r == "EN-optimized":
+                    localized.append("Optymalny dla EN")
+                elif r == "Smaller/faster":
+                    localized.append("Mniejszy/szybszy")
+                elif r == "Better quality baseline":
+                    localized.append("Lepsza jakość (baseline)")
+                elif r == "Fast but may be lower quality":
+                    localized.append("Szybki, ale może gorsza jakość")
+                elif r == "Medium size":
+                    localized.append("Średni rozmiar")
+                elif r == "Heavier/slower":
+                    localized.append("Cięższy/wolniejszy")
+                else:
+                    localized.append(r)
+            reasons_txt = ", ".join(localized)
+        else:
+            reasons_txt = ", ".join(reasons)
+        lines.append(f"- {c.model_id}: {reasons_txt}")
 
+    lines.append("")
+    lines.append(t(ui_lang, note_key))
     return "\n".join(lines)
 
 # -----------------------
 # Dynamic UI language updates
 # -----------------------
 def apply_language(ui_lang: str) -> Tuple[Any, ...]:
-    """
-    Returns gr.update objects for all UI text elements that should change when language changes.
-    """
     return (
-        gr.update(value=f"# {t(ui_lang, 'title')}\n{t(ui_lang, 'intro')}"),                 # header_md
-        gr.update(label=t(ui_lang, "ui_lang")),                                            # ui_lang radio label (cosmetic)
-        gr.update(label=t(ui_lang, "task"), choices=task_choices(ui_lang)),                # task dropdown
-        gr.update(label=t(ui_lang, "has_docs"), choices=yesno_choices(ui_lang)),           # has_docs
-        gr.update(label=t(ui_lang, "data_lang"), choices=data_lang_choices(ui_lang)),      # data_lang
-        gr.update(label=t(ui_lang, "cpu_only")),                                           # cpu_only
-        gr.update(label=t(ui_lang, "priority"), choices=priority_choices(ui_lang)),        # priority
-        gr.update(value=t(ui_lang, "recommend_btn")),                                      # button text
-        gr.update(label=t(ui_lang, "result")),                                             # output label
-        gr.update(label=t(ui_lang, "tab_main")),                                           # tab label (Gradio may not update tab titles live in all versions)
+        gr.update(value=f"# {t(ui_lang, 'title')}\n{t(ui_lang, 'intro')}"),  # header
+        gr.update(label=t(ui_lang, "ui_lang")),                             # ui lang label
+        gr.update(label=t(ui_lang, "task"), choices=task_choices(ui_lang)), # task choices localized
+        gr.update(label=t(ui_lang, "has_docs"), choices=yesno_choices(ui_lang)),
+        gr.update(label=t(ui_lang, "data_lang"), choices=data_lang_choices(ui_lang)),
+        gr.update(label=t(ui_lang, "cpu_only")),
+        gr.update(label=t(ui_lang, "priority"), choices=priority_choices(ui_lang)),
+        gr.update(value=t(ui_lang, "recommend_btn")),
+        gr.update(label=t(ui_lang, "result")),
+        gr.update(label=t(ui_lang, "tab_main")),
     )
 
 # -----------------------
@@ -250,38 +417,17 @@ def apply_language(ui_lang: str) -> Tuple[Any, ...]:
 with gr.Blocks(title=I18N["EN"]["title"]) as demo:
     header_md = gr.Markdown(f"# {t('EN', 'title')}\n{t('EN', 'intro')}")
 
-    ui_lang = gr.Radio(
-        choices=["EN", "PL"],
-        value="EN",
-        label=t("EN", "ui_lang"),
-    )
+    ui_lang = gr.Radio(choices=["EN", "PL"], value="EN", label=t("EN", "ui_lang"))
 
-    # Tab title live-update is not guaranteed across Gradio versions; we still keep the label update output.
     with gr.Tab(t("EN", "tab_main")) as tab_main:
-        task = gr.Dropdown(
-            choices=task_choices("EN"),
-            value=TASK_SIM,
-            label=t("EN", "task"),
-        )
-        has_docs = gr.Radio(
-            choices=yesno_choices("EN"),
-            value="YES",
-            label=t("EN", "has_docs"),
-        )
-        data_lang = gr.Radio(
-            choices=data_lang_choices("EN"),
-            value="MIXED",
-            label=t("EN", "data_lang"),
-        )
+        task = gr.Dropdown(choices=task_choices("EN"), value=TASK_SIM, label=t("EN", "task"))
+        has_docs = gr.Radio(choices=yesno_choices("EN"), value="YES", label=t("EN", "has_docs"))
+        data_lang = gr.Radio(choices=data_lang_choices("EN"), value="MIXED", label=t("EN", "data_lang"))
         cpu_only = gr.Checkbox(value=True, label=t("EN", "cpu_only"))
-        priority = gr.Radio(
-            choices=priority_choices("EN"),
-            value="SPEED",
-            label=t("EN", "priority"),
-        )
+        priority = gr.Radio(choices=priority_choices("EN"), value="SPEED", label=t("EN", "priority"))
 
         recommend_btn = gr.Button(t("EN", "recommend_btn"))
-        out = gr.Textbox(lines=18, label=t("EN", "result"))
+        out = gr.Textbox(lines=22, label=t("EN", "result"))
 
         recommend_btn.click(
             fn=recommend,
@@ -289,7 +435,6 @@ with gr.Blocks(title=I18N["EN"]["title"]) as demo:
             outputs=[out],
         )
 
-    # When UI language changes, update labels + choices.
     ui_lang.change(
         fn=apply_language,
         inputs=[ui_lang],