Update app.py

app.py

@@ -1,9 +1,16 @@
+import time
+from typing import List, Tuple, Dict
+
 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()
 
-# Minimalnie: twardo wpisane, stabilne propozycje (CPU-friendly) + ewentualnie dynamiczne "bonusy"
+# Twarde, stabilne rekomendacje (min. 3)
 RECOMMENDATIONS = {
     "instruction": [
         ("google/flan-t5-small", "Lekki text2text, dobry na CPU do poleceń i krótkich odpowiedzi."),
@@ -13,39 +20,150 @@ RECOMMENDATIONS = {
     "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; potrafi częściej zwrócić 'brak odpowiedzi'.")
+        ("deepset/bert-base-cased-squad2", "SQuAD2; częściej zwraca 'brak odpowiedzi'.")
     ],
     "embeddings": [
-        ("sentence-transformers/all-MiniLM-L6-v2", "Bardzo popularny do similarity search; szybki."),
-        ("intfloat/e5-small-v2", "Silny embedding do wyszukiwania; dobry kompromis."),
+        ("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).")
     ],
 }
 
-def hub_bonus_models(pipeline_tag: str, limit: int = 5):
-    """
-    Opcjonalnie: dociągaj popularne modele z Hub.
-    Uwaga: to zapytania sieciowe; jeśli wolisz offline, usuń ten fragment.
-    """
+# -----------------------
+# A) Hub bonus: cache + filtr językowy
+# -----------------------
+_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":
+        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 [])}
+    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)
+    now = time.time()
+
+    if key in _HUB_CACHE:
+        ts, cached = _HUB_CACHE[key]
+        if now - ts < CACHE_TTL_SEC:
+            return cached
+
     try:
-        # huggingface_hub pozwala listować modele z filtrami (HfApi.list_models). :contentReference[oaicite:1]{index=1}
+        # 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:
-            if m.modelId:
-                out.append(m.modelId)
+            mid = getattr(m, "modelId", None)
+            tags = getattr(m, "tags", []) or []
+            if mid and _language_tag_predicate(tags, language):
+                out.append(mid)
+        _HUB_CACHE[key] = (now, out)
         return out
     except Exception:
         return []
 
+# -----------------------
+# B) Embeddingi lokalnie (CPU): mean pooling
+# -----------------------
+_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("")
+
+    return "\n".join(lines).strip()
+
+# -----------------------
+# Doradca modeli
+# -----------------------
 def recommend(task, has_docs, language, cpu_only, priority):
-    # Prosta logika decyzyjna
     if task == "Semantyczne podobieństwo / duplikaty / wyszukiwanie":
         model_type = "embeddings"
         why = (
-            "Chcesz porównywać znaczenie wpisów i wykrywać duplikaty. "
-            "Do tego używa się embeddingów (wektorów) i miary podobieństwa (np. cosinus). "
-            "To nie jest generowanie tekstu."
+            "Zadanie polega na porównaniu znaczenia wpisów i wykryciu duplikatów. "
+            "Najlepsze są modele embeddingowe + podobieństwo cosinusowe (sentence similarity)."
         )
         pipeline_tag = "sentence-similarity"
     elif task == "Odpowiedzi na pytania z dokumentu (tekst wejściowy)":
@@ -58,73 +176,79 @@ def recommend(task, has_docs, language, cpu_only, priority):
     else:
         model_type = "instruction"
         why = (
-            "Chcesz odpowiedzi 'z polecenia' (chat/wyjaśnianie/streszczanie). "
+            "Chcesz odpowiedzi sterowane poleceniem (chat/wyjaśnianie/streszczanie). "
             "Modele instrukcyjne są dostrajane do wykonywania instrukcji."
         )
         pipeline_tag = "text-generation"
 
-    # Zbuduj wynik: min. 3
     recs = RECOMMENDATIONS[model_type].copy()
 
-    # Bonus: dociągnij popularne modele z Hub (nie obowiązkowe)
-    bonus = hub_bonus_models(pipeline_tag, limit=5)
-    # Usuń te, które już mamy
+    # Bonus: dociągamy popularne modele z Hub (filtrowane po języku)
+    bonus = hub_bonus_models(pipeline_tag, language, limit=12)
     existing = {mid for mid, _ in recs}
     bonus = [m for m in bonus if m not in existing]
-    # Dodaj 0–2 bonusy, ale nie kosztem czytelności
+
+    # 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 i pobraniach)."))
+        recs.append((m, "Popularny model z Hub (dobrany po tagu zadania, sort po pobraniach)."))
 
-    # Sformatuj odpowiedź
     lines = []
     lines.append(f"Rekomendowany typ modelu: {model_type}")
     lines.append("")
     lines.append("Uzasadnienie:")
     lines.append(f"- {why}")
     lines.append("")
-    lines.append("Minimum 3 pasujące modele:")
+    lines.append("Modele (min. 3):")
     for mid, note in recs[:5]:
         lines.append(f"- {mid} — {note}")
 
-    # Dodatkowe wskazówki „jak użyć” dla embeddings
     if model_type == "embeddings":
         lines.append("")
-        lines.append("Jak użyć do duplikatów (zarys):")
-        lines.append("- Policz embedding dla każdego wpisu.")
-        lines.append("- Porównuj podobieństwo cosinusowe.")
-        lines.append("- Ustal próg (np. 0.85–0.95) i grupuj podobne wpisy.")
-        lines.append("- W każdej grupie zostaw 1 rekord, resztę oznacz jako duplikaty.")
-
+        lines.append("Zastosowanie do duplikatów (skrót): embeddingi -> cosine similarity -> próg -> grupy.")
         if language in ["PL", "Mieszany"]:
-            lines.append("")
-            lines.append("Uwaga językowa:")
-            lines.append("- Przy PL lub mieszanych językach preferuj model multilingual z listy.")
+            lines.append("Wskazówka: preferuj model multilingual przy PL/mix języków.")
+
     return "\n".join(lines)
 
+# -----------------------
+# UI (2 zakładki)
+# -----------------------
 with gr.Blocks(title="Model Fit Finder (CPU)") as demo:
-    gr.Markdown("# Model Fit Finder\nDobiera typ modelu i podaje konkretne propozycje (CPU).")
-
-    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ć?"
-    )
-    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],
-    )
+    gr.Markdown("# Model Fit Finder (CPU)\nDobiera typ modelu i pokazuje minimum 3 propozycje. Zawiera też deduplikację embeddingami.")
+
+    with gr.Tab("Doradca modeli"):
+        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ć?"
+        )
+        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."
+        )
+        embed_model = gr.Dropdown(
+            choices=[m for m, _ in RECOMMENDATIONS["embeddings"]],
+            value=RECOMMENDATIONS["embeddings"][0][0],
+            label="Model embeddingowy"
+        )
+        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])
 
 demo.launch()