Update app.py

app.py

@@ -1,51 +1,130 @@
 import time
-from typing import List, Tuple, Dict
+from typing import Dict, List, Tuple, Any
 
 import gradio as gr
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-import torch
-from transformers import AutoTokenizer, AutoModel
 from huggingface_hub import HfApi
 
 api = HfApi()
 
-# Twarde, stabilne rekomendacje (min. 3)
-RECOMMENDATIONS = {
+# -----------------------
+# i18n
+# -----------------------
+I18N: Dict[str, Dict[str, str]] = {
+    "EN": {
+        "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."
+        ),
+        "ui_lang": "UI language",
+        "tab_main": "Model advisor",
+        "task": "What do you want to do?",
+        "has_docs": "Do you have your own documents/text to analyze?",
+        "data_lang": "Data language",
+        "cpu_only": "CPU only",
+        "priority": "Priority",
+        "recommend_btn": "Recommend",
+        "result": "Result",
+        "yes": "Yes",
+        "no": "No",
+        "en": "EN",
+        "pl": "PL",
+        "mixed": "Mixed",
+        "speed": "Speed",
+        "quality": "Quality",
+        "task_chat": "Chat / instructions / generation",
+        "task_qa": "Answer questions from a document (input text)",
+        "task_sim": "Semantic similarity / duplicates / search",
+        "rec_type": "Recommended model type: {model_type}",
+        "rationale": "Rationale:",
+        "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.",
+        "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."
+        ),
+        "ui_lang": "Język interfejsu",
+        "tab_main": "Doradca modeli",
+        "task": "Co chcesz zrobić?",
+        "has_docs": "Czy masz własne dokumenty/teksty do analizy?",
+        "data_lang": "Język danych",
+        "cpu_only": "CPU only",
+        "priority": "Priorytet",
+        "recommend_btn": "Zarekomenduj",
+        "result": "Wynik",
+        "yes": "Tak",
+        "no": "Nie",
+        "en": "EN",
+        "pl": "PL",
+        "mixed": "Mieszany",
+        "speed": "Szybkość",
+        "quality": "Jakość",
+        "task_chat": "Chat / polecenia / generowanie",
+        "task_qa": "Odpowiedzi na pytania z dokumentu (tekst wejściowy)",
+        "task_sim": "Semantyczne podobieństwo / duplikaty / wyszukiwanie",
+        "rec_type": "Rekomendowany typ modelu: {model_type}",
+        "rationale": "Uzasadnienie:",
+        "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.",
+        "bonus_note": "Popularny model z Hub (dobrany po tagu zadania i pobraniach).",
+    },
+}
+
+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)
+# -----------------------
+RECOMMENDATIONS: Dict[str, List[Tuple[str, str]]] = {
     "instruction": [
-        ("google/flan-t5-small", "Lekki text2text, dobry na CPU do poleceń i krótkich odpowiedzi."),
-        ("google/flan-t5-base", "Lepsza jakość kosztem szybkości; nadal sensowne na CPU."),
-        ("google-t5/t5-small", "Prosty fallback text2text, gdy chcesz klasykę i szybkość.")
+        ("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."),
     ],
     "qa": [
-        ("distilbert/distilbert-base-cased-distilled-squad", "Szybki QA extractive na CPU; klasyczny wybór."),
-        ("distilbert/distilbert-base-uncased-distilled-squad", "Popularny model SQuAD; dobry default."),
-        ("deepset/bert-base-cased-squad2", "SQuAD2; częściej zwraca 'brak odpowiedzi'.")
+        ("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."),
     ],
     "embeddings": [
-        ("sentence-transformers/all-MiniLM-L6-v2", "Popularny do similarity search; szybki na CPU."),
-        ("intfloat/e5-small-v2", "Mocny embedding do wyszukiwania; dobry kompromis."),
-        ("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2", "Multilingual (lepszy przy PL/mix).")
+        ("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."),
     ],
 }
 
+# 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.)
+
 # -----------------------
-# A) Hub bonus: cache + filtr językowy
+# Hub bonus models (cache)
 # -----------------------
 _HUB_CACHE: Dict[Tuple[str, str], Tuple[float, List[str]]] = {}
-CACHE_TTL_SEC = 6 * 60 * 60  # 6 godzin
-
-def _language_tag_predicate(tags: List[str], language: str) -> bool:
-    if language == "Mieszany":
+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
-    # Tagowanie językowe na Hubie nie jest 100% spójne, więc sprawdzamy kilka wariantów.
-    lang = language.lower()
-    candidates = {lang, f"language:{lang}", f"lang:{lang}"}
-    tags_lower = {t.lower() for t in (tags or [])}
+    target = "en" if data_lang_value == "EN" else "pl"
+    candidates = {target, f"language:{target}", f"lang:{target}"}
+    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, language: str, limit: int = 12) -> List[str]:
-    key = (pipeline_tag, language)
+def hub_bonus_models(pipeline_tag: str, data_lang_value: str, limit: int = 12) -> List[str]:
+    key = (pipeline_tag, data_lang_value)
     now = time.time()
 
     if key in _HUB_CACHE:
@@ -54,13 +133,12 @@ def hub_bonus_models(pipeline_tag: str, language: str, limit: int = 12) -> List[
             return cached
 
     try:
-        # list_models: filtrujemy po pipeline tagu i sortujemy po pobraniach (popularność).
         models = api.list_models(filter=pipeline_tag, sort="downloads", direction=-1, limit=limit)
         out = []
         for m in models:
             mid = getattr(m, "modelId", None)
             tags = getattr(m, "tags", []) or []
-            if mid and _language_tag_predicate(tags, language):
+            if mid and _language_tag_predicate(tags, data_lang_value):
                 out.append(mid)
         _HUB_CACHE[key] = (now, out)
         return out
@@ -68,187 +146,154 @@ def hub_bonus_models(pipeline_tag: str, language: str, limit: int = 12) -> List[
         return []
 
 # -----------------------
-# B) Embeddingi lokalnie (CPU): mean pooling
+# Internal "task ids" (do NOT depend on UI language)
 # -----------------------
-_MODEL_CACHE: Dict[str, Tuple[AutoTokenizer, AutoModel]] = {}
-
-def _load_encoder(model_id: str):
-    if model_id in _MODEL_CACHE:
-        return _MODEL_CACHE[model_id]
-    tok = AutoTokenizer.from_pretrained(model_id)
-    mdl = AutoModel.from_pretrained(model_id)
-    mdl.eval()
-    _MODEL_CACHE[model_id] = (tok, mdl)
-    return tok, mdl
-
-@torch.no_grad()
-def embed_texts(model_id: str, texts: List[str], batch_size: int = 16) -> np.ndarray:
-    tok, mdl = _load_encoder(model_id)
-
-    all_vecs = []
-    for i in range(0, len(texts), batch_size):
-        batch = texts[i:i+batch_size]
-        enc = tok(batch, padding=True, truncation=True, return_tensors="pt")
-        out = mdl(**enc)
-
-        # Mean pooling po tokenach z maską attention
-        token_emb = out.last_hidden_state  # [B, T, H]
-        mask = enc["attention_mask"].unsqueeze(-1).expand(token_emb.size()).float()
-        summed = torch.sum(token_emb * mask, dim=1)
-        counts = torch.clamp(mask.sum(dim=1), min=1e-9)
-        mean_pooled = summed / counts
-
-        # Normalizacja L2 pomaga dla cosine similarity
-        normed = torch.nn.functional.normalize(mean_pooled, p=2, dim=1)
-        all_vecs.append(normed.cpu().numpy())
-
-    return np.vstack(all_vecs)
-
-def deduplicate_notes(model_id: str, raw_notes: str, threshold: float) -> str:
-    notes = [n.strip() for n in raw_notes.splitlines() if n.strip()]
-    if len(notes) < 2:
-        return "Wklej co najmniej 2 wpisy (po jednej linijce)."
-
-    vecs = embed_texts(model_id, notes)
-    sim = cosine_similarity(vecs)
-
-    # Grupowanie prostym union-find (spójne składowe przy sim >= threshold)
-    parent = list(range(len(notes)))
-
-    def find(x):
-        while parent[x] != x:
-            parent[x] = parent[parent[x]]
-            x = parent[x]
-        return x
-
-    def union(a, b):
-        ra, rb = find(a), find(b)
-        if ra != rb:
-            parent[rb] = ra
-
-    for i in range(len(notes)):
-        for j in range(i + 1, len(notes)):
-            if sim[i, j] >= threshold:
-                union(i, j)
-
-    groups: Dict[int, List[int]] = {}
-    for idx in range(len(notes)):
-        r = find(idx)
-        groups.setdefault(r, []).append(idx)
-
-    # Interesują nas grupy z duplikatami (rozmiar > 1)
-    dup_groups = [g for g in groups.values() if len(g) > 1]
-    dup_groups.sort(key=len, reverse=True)
-
-    if not dup_groups:
-        return f"Brak duplikatów przy progu {threshold:.2f}."
-
-    lines = []
-    lines.append(f"Znalezione grupy podobnych wpisów (próg {threshold:.2f}):")
-    lines.append("")
-    for gi, g in enumerate(dup_groups, start=1):
-        lines.append(f"Grupa {gi} (rozmiar {len(g)}):")
-        for idx in g:
-            lines.append(f"- {notes[idx]}")
-        lines.append("Sugestia: zostaw 1 wpis, pozostałe oznacz jako duplikaty.")
-        lines.append("")
+TASK_CHAT = "CHAT"
+TASK_QA = "QA"
+TASK_SIM = "SIM"
+
+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),
+    ]
+
+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")]
 
-    return "\n".join(lines).strip()
+def priority_choices(ui_lang: str) -> List[Tuple[str, str]]:
+    return [(t(ui_lang, "speed"), "SPEED"), (t(ui_lang, "quality"), "QUALITY")]
 
 # -----------------------
-# Doradca modeli
+# Recommendation logic
 # -----------------------
-def recommend(task, has_docs, language, cpu_only, priority):
-    if task == "Semantyczne podobieństwo / duplikaty / wyszukiwanie":
+def recommend(ui_lang: str, task_id: str, has_docs: str, data_lang_value: str, cpu_only: bool, priority: str) -> str:
+    if task_id == TASK_SIM:
         model_type = "embeddings"
         why = (
-            "Zadanie polega na porównaniu znaczenia wpisów i wykryciu duplikatów. "
-            "Najlepsze są modele embeddingowe + podobieństwo cosinusowe (sentence similarity)."
+            "You want semantic similarity / duplicate detection / search. Use embeddings + cosine similarity."
+            if ui_lang == "EN"
+            else "Chcesz podobieństwo semantyczne / duplikaty / wyszukiwanie. Użyj embeddingów + podobieństwa cosinusowego."
         )
         pipeline_tag = "sentence-similarity"
-    elif task == "Odpowiedzi na pytania z dokumentu (tekst wejściowy)":
+        note_key = "emb_note"
+    elif task_id == TASK_QA:
         model_type = "qa"
         why = (
-            "Masz kontekst (dokument/tekst) i pytanie. QA extractive znajduje odpowiedź w kontekście "
-            "i zwykle halucynuje rzadziej niż modele generatywne."
+            "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."
         )
         pipeline_tag = "question-answering"
+        note_key = "qa_note"
     else:
         model_type = "instruction"
         why = (
-            "Chcesz odpowiedzi sterowane poleceniem (chat/wyjaśnianie/streszczanie). "
-            "Modele instrukcyjne są dostrajane do wykonywania instrukcji."
+            "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"
 
     recs = RECOMMENDATIONS[model_type].copy()
 
-    # Bonus: dociągamy popularne modele z Hub (filtrowane po języku)
-    bonus = hub_bonus_models(pipeline_tag, language, limit=12)
+    # 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]
-
-    # Dodajemy do 2 bonusów, żeby nie zalać użytkownika
     for m in bonus[:2]:
-        recs.append((m, "Popularny model z Hub (dobrany po tagu zadania, sort po pobraniach)."))
+        recs.append((m, t(ui_lang, "bonus_note")))
 
-    lines = []
-    lines.append(f"Rekomendowany typ modelu: {model_type}")
+    lines: List[str] = []
+    lines.append(t(ui_lang, "rec_type").format(model_type=model_type))
     lines.append("")
-    lines.append("Uzasadnienie:")
+    lines.append(t(ui_lang, "rationale"))
     lines.append(f"- {why}")
     lines.append("")
-    lines.append("Modele (min. 3):")
+    lines.append(t(ui_lang, "models_min3"))
     for mid, note in recs[:5]:
         lines.append(f"- {mid} — {note}")
-
-    if model_type == "embeddings":
-        lines.append("")
-        lines.append("Zastosowanie do duplikatów (skrót): embeddingi -> cosine similarity -> próg -> grupy.")
-        if language in ["PL", "Mieszany"]:
-            lines.append("Wskazówka: preferuj model multilingual przy PL/mix języków.")
+    lines.append("")
+    lines.append(t(ui_lang, note_key))
 
     return "\n".join(lines)
 
 # -----------------------
-# UI (2 zakładki)
+# 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)
+    )
+
+# -----------------------
+# UI
 # -----------------------
-with gr.Blocks(title="Model Fit Finder (CPU)") as demo:
-    gr.Markdown("# Model Fit Finder (CPU)\nDobiera typ modelu i pokazuje minimum 3 propozycje. Zawiera też deduplikację embeddingami.")
+with gr.Blocks(title=I18N["EN"]["title"]) as demo:
+    header_md = gr.Markdown(f"# {t('EN', 'title')}\n{t('EN', 'intro')}")
 
-    with gr.Tab("Doradca modeli"):
+    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=[
-                "Chat / polecenia / generowanie",
-                "Odpowiedzi na pytania z dokumentu (tekst wejściowy)",
-                "Semantyczne podobieństwo / duplikaty / wyszukiwanie",
-            ],
-            value="Semantyczne podobieństwo / duplikaty / wyszukiwanie",
-            label="Co chcesz zrobić?"
+            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"),
         )
-        has_docs = gr.Radio(choices=["Tak", "Nie"], value="Tak", label="Czy masz własne dokumenty/teksty do analizy?")
-        language = gr.Radio(choices=["EN", "PL", "Mieszany"], value="Mieszany", label="Język danych")
-        cpu_only = gr.Checkbox(value=True, label="CPU only")
-        priority = gr.Radio(choices=["Szybkość", "Jakość"], value="Szybkość", label="Priorytet")
-
-        btn = gr.Button("Zarekomenduj")
-        out = gr.Textbox(lines=18, label="Wynik")
-        btn.click(fn=recommend, inputs=[task, has_docs, language, cpu_only, priority], outputs=[out])
-
-    with gr.Tab("Deduplikacja wpisów (embeddingi)"):
-        gr.Markdown(
-            "Wklej wpisy (po jednej linijce). Space policzy embeddingi lokalnie na CPU i pogrupuje duplikaty.\n"
-            "Uwaga: przy bardzo krótkich, technicznych wpisach warto testować próg w zakresie 0.85–0.95."
+        cpu_only = gr.Checkbox(value=True, label=t("EN", "cpu_only"))
+        priority = gr.Radio(
+            choices=priority_choices("EN"),
+            value="SPEED",
+            label=t("EN", "priority"),
         )
-        embed_model = gr.Dropdown(
-            choices=[m for m, _ in RECOMMENDATIONS["embeddings"]],
-            value=RECOMMENDATIONS["embeddings"][0][0],
-            label="Model embeddingowy"
+
+        recommend_btn = gr.Button(t("EN", "recommend_btn"))
+        out = gr.Textbox(lines=18, label=t("EN", "result"))
+
+        recommend_btn.click(
+            fn=recommend,
+            inputs=[ui_lang, task, has_docs, data_lang, cpu_only, priority],
+            outputs=[out],
         )
-        threshold = gr.Slider(0.70, 0.99, value=0.90, step=0.01, label="Próg podobieństwa (cosine)")
-        notes = gr.Textbox(lines=12, label="Wpisy (1 linia = 1 wpis)")
-        run = gr.Button("Wykryj duplikaty")
-        dup_out = gr.Textbox(lines=18, label="Grupy duplikatów")
-        run.click(fn=deduplicate_notes, inputs=[embed_model, notes, threshold], outputs=[dup_out])
+
+    # When UI language changes, update labels + choices.
+    ui_lang.change(
+        fn=apply_language,
+        inputs=[ui_lang],
+        outputs=[header_md, ui_lang, task, has_docs, data_lang, cpu_only, priority, recommend_btn, out, tab_main],
+    )
 
 demo.launch()