Upload folder using huggingface_hub

README.md

@@ -1,14 +1,13 @@
 ---
-title: SloganAI
-emoji: 🏢
-colorFrom: pink
+title: Slogan Finder
+emoji: 🏷️
+colorFrom: yellow
 colorTo: green
 sdk: gradio
-sdk_version: 5.43.1
+sdk_version: "5.43.1"
 app_file: app.py
 pinned: false
-license: mit
-short_description: Startup recommender with AI-generated slogans
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Slogan Finder
+Search *real slogans* (SBERT + FAISS) and get *1 AI-generated* suggestion.

app.py

@@ -1,391 +1,277 @@
-
-import os, re, json
-import numpy as np
-import pandas as pd
+\
+import os, json, numpy as np, pandas as pd
 import gradio as gr
 import faiss
-import torch
-from typing import List
-from sentence_transformers import SentenceTransformer, CrossEncoder
+import re
+from sentence_transformers import SentenceTransformer
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-# =========================
-# Global Config
-# =========================
-# מודלים (אותו סטינג כמו במחברת; יש Fallback ל-base אם ה-Large לא נכנס לזיכרון)
-FLAN_PRIMARY = os.getenv("FLAN_PRIMARY", "google/flan-t5-large")
-FLAN_FALLBACK = "google/flan-t5-base"
-EMBED_NAME = "sentence-transformers/all-mpnet-base-v2"
-RERANK_NAME = "cross-encoder/stsb-roberta-base"
-
-NUM_SLOGAN_SAMPLES = int(os.getenv("NUM_SLOGAN_SAMPLES", "16"))  # אפשר להעלות ל-32 אם יש GPU
-INDEX_ROOT = os.path.join(os.path.dirname(__file__), "vector_store")  # איפה ששמנו את האינדקסים
-DEFAULT_MODEL_FOR_INDEX = EMBED_NAME
-
-DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-# =========================
-# Lazy model loading (first call only)
-# =========================
-_GEN_TOK = None
-_GEN_MODEL = None
-_EMBED_MODEL = None
-_RERANKER = None
-
-def _ensure_models():
-    global _GEN_TOK, _GEN_MODEL, _EMBED_MODEL, _RERANKER
-    if _EMBED_MODEL is None:
-        _EMBED_MODEL = SentenceTransformer(EMBED_NAME)
-    if _RERANKER is None:
-        _RERANKER = CrossEncoder(RERANK_NAME)
-
-    if _GEN_MODEL is None:
-        try:
-            tok = AutoTokenizer.from_pretrained(FLAN_PRIMARY)
-            mdl = AutoModelForSeq2SeqLM.from_pretrained(FLAN_PRIMARY)
-            _GEN_TOK, _GEN_MODEL = tok, mdl.to(DEVICE)
-            print(f"[INFO] Loaded generator: {FLAN_PRIMARY}")
-        except Exception as e:
-            print(f"[WARN] Failed to load {FLAN_PRIMARY}. Falling back to {FLAN_FALLBACK}. Error: {e}")
-            tok = AutoTokenizer.from_pretrained(FLAN_FALLBACK)
-            mdl = AutoModelForSeq2SeqLM.from_pretrained(FLAN_FALLBACK)
-            _GEN_TOK, _GEN_MODEL = tok, mdl.to(DEVICE)
-            print(f"[INFO] Loaded generator: {FLAN_FALLBACK}")
-
-# =========================
-# Index cache (so we don't read multiple times)
-# =========================
-_INDEX_CACHE = {}   # model_key -> (faiss_index, meta_df)
-
-def _model_key(name: str) -> str:
-    return name.replace("/", "_")
-
-def _format_for_e5(texts, as_query=False):
-    prefix = "query: " if as_query else "passage: "
-    return [prefix + str(t) for t in texts]
-
-def _load_index_for_model(model_name: str = DEFAULT_MODEL_FOR_INDEX):
-    """Load FAISS index + meta once for a given model."""
-    mkey = _model_key(model_name)
-    if mkey in _INDEX_CACHE:
-        return _INDEX_CACHE[mkey]
-
-    base = os.path.join(INDEX_ROOT, mkey)
-    idx_path = os.path.join(base, "index.faiss")
-    meta_path = os.path.join(base, "meta.parquet")
-
-    if not (os.path.exists(idx_path) and os.path.exists(meta_path)):
-        # fallback: tiny demo index (3 rows) if user didn't push vector_store
-        print(f"[WARN] Missing index for {model_name}. Using tiny demo in-memory index.")
-        demo = pd.DataFrame({
-            "name": ["HowDidIDo", "Museotainment", "Movitr"],
-            "tagline": ["Online evaluation platform", "PacMan & Louvre meet", "Crowdsourced video translation"],
-            "description": [
-                "Public speaking, Presentation skills and interview practice",
-                "Interactive AR museum tours",
-                "Video translation with voice and subtitles"
-            ]
-        })
-        model = SentenceTransformer(model_name)
-        vecs = model.encode(demo["description"].tolist(), normalize_embeddings=True)
-        dim = vecs.shape[1]
-        index = faiss.IndexFlatIP(dim)
-        index.add(np.asarray(vecs, dtype=np.float32))
-        _INDEX_CACHE[mkey] = (index, demo)
-        return _INDEX_CACHE[mkey]
-
-    index = faiss.read_index(idx_path)
-    meta_df = pd.read_parquet(meta_path)
-    _INDEX_CACHE[mkey] = (index, meta_df)
-    return _INDEX_CACHE[mkey]
-
-# =========================
-# Recommendation (top-3) using FAISS index you generated
-# =========================
-def recommend(query_text: str, model_name: str = DEFAULT_MODEL_FOR_INDEX, top_k: int = 3) -> pd.DataFrame:
-    _ensure_models()
-    index, meta = _load_index_for_model(model_name)
-
-    # format for E5 if needed
-    if model_name.startswith("intfloat/e5"):
-        q_inp = _format_for_e5([query_text], as_query=True)
+from logic.cleaning import clean_dataframe
+from logic.search import SloganSearcher
+
+# -------------------- Config --------------------
+ASSETS_DIR   = "assets"
+DATA_PATH    = "data/slogan.csv"
+PROMPT_PATH  = "data/prompt.txt"
+
+MODEL_NAME   = "sentence-transformers/all-MiniLM-L6-v2"
+NORMALIZE    = True
+
+GEN_MODEL    = "google/flan-t5-base"
+NUM_GEN_CANDIDATES = 12
+MAX_NEW_TOKENS     = 18
+TEMPERATURE        = 0.7
+TOP_P              = 0.9
+REPETITION_PENALTY = 1.15
+
+# choose the most relevant yet non-duplicate candidate
+RELEVANCE_WEIGHT   = 0.7
+NOVELTY_WEIGHT     = 0.3
+DUPLICATE_MAX_SIM  = 0.92
+NOVELTY_SIM_THRESHOLD = 0.80  # keep some distance from retrieved
+
+META_PATH    = os.path.join(ASSETS_DIR, "meta.json")
+PARQUET_PATH = os.path.join(ASSETS_DIR, "slogans_clean.parquet")
+INDEX_PATH   = os.path.join(ASSETS_DIR, "faiss.index")
+EMB_PATH     = os.path.join(ASSETS_DIR, "embeddings.npy")
+
+def _log(m): print(f"[SLOGAN-SPACE] {m}", flush=True)
+
+# -------------------- Asset build --------------------
+def _build_assets():
+    if not os.path.exists(DATA_PATH):
+        raise FileNotFoundError(f"Dataset not found at {DATA_PATH} (CSV with columns: 'tagline', 'description').")
+    os.makedirs(ASSETS_DIR, exist_ok=True)
+
+    _log(f"Loading dataset: {DATA_PATH}")
+    df = pd.read_csv(DATA_PATH)
+
+    _log(f"Rows before cleaning: {len(df)}")
+    df = clean_dataframe(df)
+    _log(f"Rows after cleaning: {len(df)}")
+
+    if "description" in df.columns and df["description"].notna().any():
+        texts = df["description"].fillna(df["tagline"]).astype(str).tolist()
+        text_col, fallback_col = "description", "tagline"
     else:
-        q_inp = [query_text]
-
-    q_vec = _EMBED_MODEL.encode(q_inp, normalize_embeddings=True)
-    q_vec = np.asarray(q_vec, dtype=np.float32)
-    scores, idxs = index.search(q_vec, top_k)
-    scores, idxs = scores[0], idxs[0]
-    out = meta.iloc[idxs].copy()
-    out["score"] = scores
-    # make sure columns exist in output (name, tagline, description)
-    cols = [c for c in ["row_id","name","tagline","description","score"] if c in out.columns or c=="score"]
-    return out[cols] if "score" in out.columns else out
-
-# =========================
-# Advanced Slogan Generator (your Refined v2 logic)
-# =========================
-BLOCK_PATTERNS = [
-    r"^[A-Z][a-z]+ [A-Z][a-z]+ (Platform|Solution|System|Application|Marketplace)$",
-    r"^[A-Z][a-z]+ [A-Z][a-z]+$",
-    r"^[A-Z][a-z]+$",
-]
-HARD_BLOCK_WORDS = {
-    "platform","solution","system","application","marketplace",
-    "ai-powered","ai powered","empower","empowering",
-    "artificial intelligence","machine learning","augmented reality","virtual reality",
-}
-GENERIC_WORDS = {"app","assistant","smart","ai","ml","ar","vr","decentralized","blockchain"}
-MARKETING_VERBS = {"build","grow","simplify","discover","create","connect","transform","unlock","boost","learn","move","clarify"}
-BENEFIT_WORDS   = {"faster","smarter","easier","better","safer","clearer","stronger","together","confidently","simply","instantly"}
-GOOD_SLOGANS_TO_AVOID_DUP = {
-    "smarter care, faster decisions",
-    "checkout built for small brands",
-    "less guessing. more healing.",
-    "built to grow with your cart.",
-    "stand tall. feel better.",
-    "train your brain to win.",
-    "your body. your algorithm.",
-    "play smarter. grow brighter.",
-    "style that thinks with you."
-}
-
-def _tokens(s: str) -> List[str]:
-    return re.findall(r"[a-z0-9]{3,}", s.lower())
-
-def _jaccard(a: List[str], b: List[str]) -> float:
-    A, B = set(a), set(b)
-    return 0.0 if not A or not B else len(A & B) / len(A | B)
-
-def _titlecase_soft(s: str) -> str:
+        texts = df["tagline"].astype(str).tolist()
+        text_col, fallback_col = "tagline", "tagline"
+
+    _log(f"Encoding with {MODEL_NAME} (normalize={NORMALIZE}) …")
+    encoder = SentenceTransformer(MODEL_NAME)
+    emb = encoder.encode(texts, batch_size=64, convert_to_numpy=True, normalize_embeddings=NORMALIZE)
+
+    dim = emb.shape[1]
+    index = faiss.IndexFlatIP(dim) if NORMALIZE else faiss.IndexFlatL2(dim)
+    index.add(emb)
+
+    _log("Persisting assets …")
+    df.to_parquet(PARQUET_PATH, index=False)
+    faiss.write_index(index, INDEX_PATH)
+    np.save(EMB_PATH, emb)
+
+    meta = {
+        "model_name": MODEL_NAME,
+        "dim": int(dim),
+        "normalized": NORMALIZE,
+        "metric": "ip" if NORMALIZE else "l2",
+        "row_count": int(len(df)),
+        "text_col": text_col,
+        "fallback_col": fallback_col,
+    }
+    with open(META_PATH, "w") as f:
+        json.dump(meta, f, indent=2)
+    _log("Assets built successfully.")
+
+def _ensure_assets():
+    need = False
+    for p in (META_PATH, PARQUET_PATH, INDEX_PATH):
+        if not os.path.exists(p):
+            _log(f"Missing asset: {p}")
+            need = True
+    if need:
+        _log("Building assets from scratch …")
+        _build_assets()
+        return
+    try:
+        pd.read_parquet(PARQUET_PATH)
+    except Exception as e:
+        _log(f"Parquet read failed ({e}); rebuilding assets.")
+        _build_assets()
+
+# Build before UI
+_ensure_assets()
+
+# -------------------- Retrieval --------------------
+searcher = SloganSearcher(assets_dir=ASSETS_DIR, use_rerank=False)
+meta     = json.load(open(META_PATH))
+_encoder = SentenceTransformer(meta["model_name"])
+
+# -------------------- Generator --------------------
+_gen_tokenizer = AutoTokenizer.from_pretrained(GEN_MODEL)
+_gen_model     = AutoModelForSeq2SeqLM.from_pretrained(GEN_MODEL)
+
+# keep this list small so we don't nuke relevant outputs
+_BANNED_TERMS = {"portal", "e-commerce", "ecommerce", "shopping", "shop"}
+_PUNCT_CHARS = ":;—–-,.!?“”\"'`"
+_PUNCT_RE = re.compile(f"[{re.escape(_PUNCT_CHARS)}]")
+
+_MIN_WORDS, _MAX_WORDS = 2, 8
+
+def _load_prompt():
+    if os.path.exists(PROMPT_PATH):
+        with open(PROMPT_PATH, "r", encoding="utf-8") as f:
+            return f.read()
+    return (
+        "You are a professional slogan writer.\n"
+        "Write ONE original startup slogan under 8 words, Title Case, no punctuation.\n"
+        "Do not copy examples.\n"
+        "Description:\n{description}\nSlogan:"
+    )
+
+def _render_prompt(description: str, retrieved=None) -> str:
+    tmpl = _load_prompt()
+    if "{description}" in tmpl:
+        prompt = tmpl.replace("{description}", description)
+    else:
+        prompt = f"{tmpl}\n\nDescription:\n{description}\nSlogan:"
+    if retrieved:
+        prompt += "\n\nDo NOT copy these existing slogans:\n"
+        for s in retrieved[:3]:
+            prompt += f"- {s}\n"
+    return prompt
+
+def _title_case(s: str) -> str:
+    small = {"and","or","for","of","the","to","in","on","with","a","an"}
+    words = [w for w in s.split() if w]
     out = []
-    for w in s.split():
-        out.append(w if w.isupper() else w.capitalize())
+    for i,w in enumerate(words):
+        lw = w.lower()
+        if i>0 and lw in small: out.append(lw)
+        else: out.append(lw.capitalize())
     return " ".join(out)
 
-def _is_blocked_slogan(s: str) -> bool:
-    if not s: return True
-    s_strip = s.strip()
-    for pat in BLOCK_PATTERNS:
-        if re.match(pat, s_strip):
-            return True
-    s_low = s_strip.lower()
-    for w in HARD_BLOCK_WORDS:
-        if w in s_low:
-            return True
-    if s_low in GOOD_SLOGANS_TO_AVOID_DUP:
-        return True
-    return False
-
-def _generic_penalty(s: str) -> float:
-    hits = sum(1 for w in GENERIC_WORDS if w in s.lower())
-    return min(1.0, 0.25 * hits)
-
-def _for_penalty(s: str) -> float:
-    return 0.3 if re.search(r"\bfor\b", s.lower()) else 0.0
-
-def _neighbor_context(neighbors_df: pd.DataFrame) -> str:
-    if neighbors_df is None or neighbors_df.empty:
-        return ""
-    examples = []
-    for _, row in neighbors_df.head(3).iterrows():
-        tg = str(row.get("tagline", "")).strip()
-        if 5 <= len(tg) <= 70:
-            examples.append(f"- {tg}")
-    return "\n".join(examples)
-
-def _copies_neighbor(s: str, neighbors_df: pd.DataFrame) -> bool:
-    if neighbors_df is None or neighbors_df.empty:
-        return False
-    s_low = s.lower()
-    s_toks = _tokens(s_low)
-    for _, row in neighbors_df.iterrows():
-        t = str(row.get("tagline", "")).strip()
-        if not t:
-            continue
-        t_low = t.lower()
-        if s_low == t_low:
-            return True
-        if _jaccard(s_toks, _tokens(t_low)) >= 0.7:
-            return True
-    try:
-        s_vec = _EMBED_MODEL.encode([s])[0]; s_vec = s_vec / np.linalg.norm(s_vec)
-        for _, row in neighbors_df.head(3).iterrows():
-            t = str(row.get("tagline", "")).strip()
-            if not t: continue
-            t_vec = _EMBED_MODEL.encode([t])[0]; t_vec = t_vec / np.linalg.norm(t_vec)
-            if float(np.dot(s_vec, t_vec)) >= 0.85:
-                return True
-    except Exception:
-        pass
-    return False
-
-def _clean_slogan(text: str, max_words: int = 8) -> str:
-    text = text.strip().split("\n")[0]
-    text = re.sub(r"[\"“”‘’]", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    text = re.sub(r"^\W+|\W+$", "", text)
-    words = text.split()
-    if len(words) > max_words:
-        text = " ".join(words[:max_words])
-    return text
-
-def _score_candidates(query: str, cands: List[str], neighbors_df: pd.DataFrame) -> List[tuple]:
-    if not cands:
-        return []
-    ce_scores = np.asarray(_RERANKER.predict([(query, s) for s in cands]), dtype=np.float32) / 5.0
-    q_toks = _tokens(query)
-    results = []
-
-    neighbor_vecs = []
-    if neighbors_df is not None and not neighbors_df.empty:
-        for _, row in neighbors_df.head(3).iterrows():
-            t = str(row.get("tagline","")).strip()
-            if t:
-                v = _EMBED_MODEL.encode([t])[0]
-                neighbor_vecs.append(v / np.linalg.norm(v))
-
-    for i, s in enumerate(cands):
-        words = s.split()
-        brevity   = 1.0 - min(1.0, abs(len(words) - 5) / 5.0)   # best ~5 words
-        wl = set(w.lower() for w in words)
-        m_hits = len(wl & MARKETING_VERBS)
-        b_hits = len(wl & BENEFIT_WORDS)
-        marketing = min(1.0, 0.2*m_hits + 0.2*b_hits)
-        g_pen = _generic_penalty(s)
-        f_pen = _for_penalty(s)
-
-        n_pen = 0.0
-        if neighbor_vecs:
-            try:
-                s_vec = _EMBED_MODEL.encode([s])[0]; s_vec = s_vec / np.linalg.norm(s_vec)
-                sim_max = max(float(np.dot(s_vec, nv)) for nv in neighbor_vecs) if neighbor_vecs else 0.0
-                n_pen = sim_max
-            except Exception:
-                n_pen = 0.0
-
-        overlap = _jaccard(q_toks, _tokens(s))
-        anti_copy = 1.0 - overlap
-
-        score = (
-            0.55*float(ce_scores[i]) +
-            0.20*brevity +
-            0.15*marketing +
-            0.03*anti_copy -
-            0.07*g_pen -
-            0.03*f_pen -
-            0.10*n_pen
-        )
-        results.append((s, float(score)))
-    return results
-
-def generate_slogan(query_text: str, neighbors_df: pd.DataFrame = None, n_samples: int = NUM_SLOGAN_SAMPLES) -> str:
-    _ensure_models()
-    ctx = _neighbor_context(neighbors_df)
-    prompt = (
-        "You are a creative brand copywriter. Write short, original, memorable startup slogans (max 8 words).\n"
-        "Forbidden words: app, assistant, platform, solution, system, marketplace, AI, machine learning, augmented reality, virtual reality, decentralized, empower.\n"
-        "Focus on clear benefits and vivid verbs. Do not copy the description. Return ONLY a list, one slogan per line.\n\n"
-        "Good Examples:\n"
-        "Description: AI assistant for doctors to prioritize patient cases\n"
-        "Slogan: Less Guessing. More Healing.\n\n"
-        "Description: Payments for small online stores\n"
-        "Slogan: Built to Grow with Your Cart.\n\n"
-        "Description: Neurotech headset to boost focus\n"
-        "Slogan: Train Your Brain to Win.\n\n"
-        "Description: Interior design suggestions with AI\n"
-        "Slogan: Style That Thinks With You.\n\n"
-        "Bad Examples (avoid these): Innovative AI Platform / Smart App for Everyone / Empowering Small Businesses\n\n"
-    )
-    if ctx:
-        prompt += f"Similar taglines (style only):\n{ctx}\n\n"
-    prompt += f"Description: {query_text}\nSlogans:"
-
-    input_ids = _GEN_TOK(prompt, return_tensors="pt").input_ids.to(DEVICE)
-    outputs = _GEN_MODEL.generate(
-        input_ids,
-        max_new_tokens=24,
+def _strip_punct(s: str) -> str:
+    return _PUNCT_RE.sub("", s)
+
+def _strict_ok(s: str) -> bool:
+    if not s: return False
+    wc = len(s.split())
+    if wc < _MIN_WORDS or wc > _MAX_WORDS: return False
+    lo = s.lower()
+    if any(term in lo for term in _BANNED_TERMS): return False
+    if lo in {"the","a","an"}: return False
+    return True
+
+def _postprocess_strict(texts):
+    cleaned, seen = [], set()
+    for t in texts:
+        s = t.replace("Slogan:", "").strip().strip('"').strip("'")
+        s = " ".join(s.split())
+        s = _strip_punct(s)          # remove punctuation instead of rejecting
+        s = _title_case(s)
+        if _strict_ok(s):
+            k = s.lower()
+            if k not in seen:
+                seen.add(k); cleaned.append(s)
+    return cleaned
+
+def _postprocess_relaxed(texts):
+    # fallback if strict returns nothing: keep 2–8 words, strip punctuation, Title Case
+    cleaned, seen = [], set()
+    for t in texts:
+        s = t.strip().strip('"').strip("'")
+        s = _strip_punct(s)
+        s = " ".join(s.split())
+        wc = len(s.split())
+        if _MIN_WORDS <= wc <= _MAX_WORDS:
+            s = _title_case(s)
+            k = s.lower()
+            if k not in seen:
+                seen.add(k); cleaned.append(s)
+    return cleaned
+
+def _generate_candidates(description: str, retrieved_texts, n: int = NUM_GEN_CANDIDATES):
+    prompt = _render_prompt(description, retrieved_texts)
+
+    # only block very generic junk at decode time
+    bad_ids = _gen_tokenizer(list(_BANNED_TERMS), add_special_tokens=False).input_ids
+
+    inputs = _gen_tokenizer([prompt], return_tensors="pt", padding=True, truncation=True)
+    outputs = _gen_model.generate(
+        **inputs,
         do_sample=True,
-        top_k=60,
-        top_p=0.92,
-        temperature=1.2,
-        num_return_sequences=n_samples,
-        repetition_penalty=1.08
+        temperature=TEMPERATURE,
+        top_p=TOP_P,
+        num_return_sequences=n,
+        max_new_tokens=MAX_NEW_TOKENS,
+        no_repeat_ngram_size=3,
+        repetition_penalty=REPETITION_PENALTY,
+        bad_words_ids=bad_ids if bad_ids else None,
+        eos_token_id=_gen_tokenizer.eos_token_id,
     )
-    raw_cands = [_GEN_TOK.decode(o, skip_special_tokens=True) for o in outputs]
-
-    cand_set = set()
-    for txt in raw_cands:
-        for line in txt.split("\n"):
-            s = _clean_slogan(line)
-            if not s:
-                continue
-            if len(s.split()) < 2 or len(s.split()) > 8:
-                continue
-            if _is_blocked_slogan(s):
-                continue
-            if _copies_neighbor(s, neighbors_df):
-                continue
-            cand_set.add(_titlecase_soft(s))
-
-    if not cand_set:
-        return _clean_slogan(_GEN_TOK.decode(outputs[0], skip_special_tokens=True))
-
-    scored = _score_candidates(query_text, sorted(cand_set), neighbors_df)
-    if not scored:
-        return _clean_slogan(_GEN_TOK.decode(outputs[0], skip_special_tokens=True))
-
-    scored.sort(key=lambda x: x[1], reverse=True)
-    return scored[0][0]
-
-# =========================
-# Gradio Pipeline
-# =========================
-EXAMPLES = [
-    "AI coach for improving public speaking skills",
-    "Augmented reality app for interactive museum tours",
-    "Voice-controlled task manager for remote teams",
-    "Machine learning system for predicting crop yields",
-    "Platform for AI-assisted interior design suggestions",
-]
-
-def pipeline(user_input: str):
-    # 1) Top-3 recommendations from your FAISS index (mpnet by default)
-    recs = recommend(user_input, model_name=DEFAULT_MODEL_FOR_INDEX, top_k=3)
-
-    # 2) Generate slogan using the neighbors as style context
-    slogan = generate_slogan(user_input, neighbors_df=recs, n_samples=NUM_SLOGAN_SAMPLES)
-
-    # 3) Append the generated item as the 4th row
-    recs = recs.reset_index(drop=True)
-    # Ensure columns exist
-    if "name" not in recs.columns:        recs["name"] = ""
-    if "tagline" not in recs.columns:     recs["tagline"] = ""
-    if "description" not in recs.columns: recs["description"] = ""
-
-    recs.loc[len(recs)] = {
-        "row_id": np.nan,
-        "name": "Synthetic Example",
-        "tagline": slogan,
-        "description": user_input,
-        "score": np.nan
-    }
-    # Second output: the slogan itself (visible headline)
-    return recs[["name","tagline","description","score"]], slogan
-
-with gr.Blocks(title="SloganAI — Recommendations + Slogan Generator") as demo:
-    gr.Markdown("## SloganAI — Top-3 Recommendations + A High-Quality Generated Slogan\nEnter a startup idea, click **Submit**, or try an example.")
-    with gr.Row():
-        with gr.Column(scale=1):
-            inp = gr.Textbox(label="Enter a startup description", lines=3, placeholder="e.g., AI coach for improving public speaking skills")
-            ex  = gr.Examples(EXAMPLES, inputs=inp, label="One‑click examples")
-            btn = gr.Button("Submit", variant="primary")
-        with gr.Column(scale=2):
-            out_df = gr.Dataframe(headers=["Name","Tagline","Description","Score"], label="Top 3 + Generated")
-            out_sg = gr.Textbox(label="Generated Slogan", interactive=False)
-
-    btn.click(fn=pipeline, inputs=inp, outputs=[out_df, out_sg])
-
-if __name__ == "__main__":
-    _ensure_models()
-    demo.queue().launch()
+    texts = _gen_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+
+    cands = _postprocess_strict(texts)
+    if not cands:
+        cands = _postprocess_relaxed(texts)  # <- graceful fallback
+    return cands
+
+def _pick_best(candidates, retrieved_texts, description):
+    """Weighted relevance to description minus duplication vs retrieved."""
+    if not candidates:
+        return None
+    c_emb = _encoder.encode(candidates, convert_to_numpy=True, normalize_embeddings=True)
+    d_emb = _encoder.encode([description], convert_to_numpy=True, normalize_embeddings=True)[0]
+    rel = c_emb @ d_emb  # cosine sim to description
+
+    if retrieved_texts:
+        R = _encoder.encode(retrieved_texts, convert_to_numpy=True, normalize_embeddings=True)
+        dup = np.max(R @ c_emb.T, axis=0)  # max sim to any retrieved
+    else:
+        dup = np.zeros(len(candidates), dtype=np.float32)
+
+    # penalize near-duplicates outright
+    mask = dup < DUPLICATE_MAX_SIM
+    if mask.any():
+        scores = RELEVANCE_WEIGHT * rel[mask] - NOVELTY_WEIGHT * dup[mask]
+        best_idx = np.argmax(scores)
+        return [c for i, c in enumerate(candidates) if mask[i]][best_idx]
+
+    # else: pick most relevant that still clears a basic novelty bar, else top score
+    scores = RELEVANCE_WEIGHT * rel - NOVELTY_WEIGHT * dup
+    order = np.argsort(-scores)
+    for i in order:
+        if dup[i] < NOVELTY_SIM_THRESHOLD:
+            return candidates[i]
+    return candidates[order[0]]
+
+# -------------------- Inference pipeline --------------------
+def run_pipeline(user_description: str):
+    if not user_description or not user_description.strip():
+        return "Please enter a description."
+    retrieved_df = searcher.search(user_description, top_k=3, rerank_top_n=10)
+    retrieved_texts = retrieved_df["display"].tolist() if not retrieved_df.empty else []
+    gens = _generate_candidates(user_description, retrieved_texts, NUM_GEN_CANDIDATES)
+    chosen = _pick_best(gens, retrieved_texts, user_description) or (gens[0] if gens else "—")
+    lines = []
+    lines.append("### 🔎 Top 3 similar slogans")
+    if retrieved_texts:
+        for i, s in enumerate(retrieved_texts, 1):
+            lines.append(f"{i}. {s}")
+    else:
+        lines.append("No similar slogans found.")
+    lines.append("\n### ✨ AI-generated suggestion")
+    lines.append(chosen)
+    return "\n".join(lines)
+
+# -------------------- UI --------------------
+with gr.Blocks(title="Slogan Finder") as demo:
+    gr.Markdown("# 🔎 Slogan Finder\nDescribe your product/company; get 3 similar slogans + 1 AI-generated suggestion.")
+    query = gr.Textbox(label="Describe your product/company", placeholder="AI-powered patient financial navigation platform...")
+    btn = gr.Button("Get slogans", variant="primary")
+    out = gr.Markdown()
+    btn.click(run_pipeline, inputs=[query], outputs=out)
+
+demo.queue(max_size=64).launch()
+

data/prompt.txt

@@ -0,0 +1,22 @@
+You are a creative brand copywriter. Write short, original, memorable startup slogans (max 8 words).
+Forbidden words: app, assistant, platform, solution, system, marketplace, AI, machine learning, augmented reality, virtual reality, decentralized, empower.
+Focus on clear benefits and vivid verbs. Do not copy the description. Return ONLY a list, one slogan per line.
+
+Good Examples:
+Description: AI assistant for doctors to prioritize patient cases
+Slogan: Less Guessing. More Healing.
+
+Description: Payments for small online stores
+Slogan: Built to Grow with Your Cart.
+
+Description: Neurotech headset to boost focus
+Slogan: Train Your Brain to Win.
+
+Description: Interior design suggestions with AI
+Slogan: Style That Thinks With You.
+
+Bad Examples (avoid these): Innovative AI Platform / Smart App for Everyone / Empowering Small Businesses
+
+Description:
+{description}
+Slogan:

logic/cleaning.py

@@ -0,0 +1,96 @@
+\
+import pandas as pd
+import re, unicodedata
+from html import unescape
+
+MIN_LEN = 20
+MAX_LEN = 60
+KEEP_ASCII_ONLY = False
+MIN_ALPHA_RATIO = 0.60
+DROP_IF_ALL_CAPS = False
+
+BUZZY = {
+    "synergy","cutting edge","cutting-edge","best in class","best-in-class",
+    "world class","world-class","state of the art","state-of-the-art",
+    "revolutionary","disruptive platform","next generation","next-gen",
+    "leading provider","scalable solution"
+}
+
+URL_RE   = re.compile(r"(https?://|www\.)\S+", re.I)
+EMAIL_RE = re.compile(r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}", re.I)
+PHONE_RE = re.compile(r"(\+?\d[\d\-\s()]{6,}\d)")
+WS_RE    = re.compile(r"\s+")
+PUNCT_RE = re.compile(r"[^\w\s]+")
+TM_RE    = re.compile(r"[®️©️™️]")
+
+def _nfkc(s): return unicodedata.normalize("NFKC", s)
+
+def _clean_text(s: str) -> str:
+    s = "" if s is None else str(s)
+    s = unescape(s)
+    s = _nfkc(s)
+    s = s.replace("\\n"," ").replace("\\r"," ")
+    s = TM_RE.sub("", s)
+    s = WS_RE.sub(" ", s).strip()
+    return s
+
+def _alpha_ratio(s: str) -> float:
+    if not s: return 0.0
+    letters = sum(ch.isalpha() for ch in s)
+    return letters / max(1, len(s))
+
+def _looks_shouty(s: str) -> bool:
+    letters = [ch for ch in s if ch.isalpha()]
+    if not letters: return False
+    uppers = sum(ch.isupper() for ch in letters)
+    return uppers / len(letters) >= 0.85
+
+def _contains_buzzy(s: str) -> bool:
+    lo = s.lower()
+    return any(term in lo for term in BUZZY)
+
+def _has_junk(s: str) -> bool:
+    return bool(URL_RE.search(s) or EMAIL_RE.search(s) or PHONE_RE.search(s))
+
+def _ascii_only(s: str) -> bool:
+    try:
+        s.encode("ascii"); return True
+    except Exception:
+        return False
+
+def _dupe_key(s: str) -> str:
+    s = s.lower()
+    s = re.sub(r"[^\\w\\s]+", " ", s)
+    s = re.sub(r"\\s+", " ", s).strip()
+    return s
+
+def clean_dataframe(df: pd.DataFrame) -> pd.DataFrame:
+    if "tagline" not in df.columns:
+        raise ValueError("Input must contain a 'tagline' column.")
+    df = df.copy()
+    if "description" not in df.columns:
+        df["description"] = df["tagline"]
+
+    df["tagline"] = df["tagline"].map(_clean_text)
+    df["description"] = df["description"].map(_clean_text)
+
+    df = df[(df["tagline"].str.len() > 0)]
+    mask_junk = df["tagline"].map(_has_junk) | df["description"].map(_has_junk)
+    df = df[~mask_junk]
+
+    if KEEP_ASCII_ONLY:
+        df = df[df["tagline"].map(_ascii_only)]
+
+    df = df[df["tagline"].map(_alpha_ratio) >= MIN_ALPHA_RATIO]
+    df = df[df["tagline"].str.len().between(MIN_LEN, MAX_LEN)]
+
+    if DROP_IF_ALL_CAPS:
+        df = df[~df["tagline"].map(_looks_shouty)]
+
+    df = df[~df["tagline"].map(_contains_buzzy)]
+
+    key = df["tagline"].map(_dupe_key)
+    df = df.loc[~key.duplicated()].reset_index(drop=True)
+
+    df.loc[df["description"].str.len() == 0, "description"] = df["tagline"]
+    return df

logic/search.py

@@ -0,0 +1,45 @@
+\
+import json, os
+import numpy as np, pandas as pd
+import faiss
+from sentence_transformers import SentenceTransformer, CrossEncoder
+
+class SloganSearcher:
+    def _init_(self, assets_dir="assets", use_rerank=False, rerank_model="cross-encoder/stsb-roberta-base"):
+        meta_path = os.path.join(assets_dir, "meta.json")
+        if not os.path.exists(meta_path):
+            raise FileNotFoundError(f"Missing {meta_path}. Build assets first.")
+        with open(meta_path, "r") as f:
+            self.meta = json.load(f)
+
+        self.df = pd.read_parquet(os.path.join(assets_dir, "slogans_clean.parquet"))
+        self.index = faiss.read_index(os.path.join(assets_dir, "faiss.index"))
+        self.encoder = SentenceTransformer(self.meta["model_name"])
+
+        self.use_rerank = use_rerank
+        self.reranker = CrossEncoder(rerank_model) if use_rerank else None
+
+        self.text_col = self.meta.get("text_col", "description")
+        self.fallback_col = self.meta.get("fallback_col", "tagline")
+        self.norm = bool(self.meta.get("normalized", True))
+
+    def search(self, query: str, top_k=5, rerank_top_n=20):
+        if not isinstance(query, str) or len(query.strip()) == 0:
+            return pd.DataFrame(columns=["display", "score"] + (["rerank_score"] if self.use_rerank else []))
+        q = self.encoder.encode([query], convert_to_numpy=True, normalize_embeddings=self.norm)
+        sims, idxs = self.index.search(q, max(int(top_k), int(rerank_top_n) if self.use_rerank else int(top_k)))
+        idxs = idxs[0].tolist()
+        sims = sims[0].tolist()
+        results = self.df.iloc[idxs].copy()
+        results["score"] = sims
+        if self.use_rerank:
+            texts = results[self.text_col].fillna(results[self.fallback_col]).astype(str).tolist()
+            pairs = [[query, t] for t in texts]
+            rr = self.reranker.predict(pairs)
+            results["rerank_score"] = rr
+            results = results.sort_values("rerank_score", ascending=False).head(int(top_k))
+        else:
+            results = results.head(int(top_k))
+        results["display"] = results[self.fallback_col]
+        cols = ["display", "score"] + (["rerank_score"] if self.use_rerank else [])
+        return results[cols]

requirements.txt

@@ -1,8 +1,9 @@
-gradio
-transformers
-sentence-transformers
-faiss-cpu
-pandas
-numpy
+gradio==5.43.1
+huggingface_hub>=0.23.0
+sentence-transformers>=2.6.0
+faiss-cpu>=1.8.0
+pandas>=2.1.0
+numpy>=1.26.0
+pyarrow>=14.0.1
 torch
-pyarrow
+transformers>=4.40.0

runtime.txt

@@ -0,0 +1 @@
+python-3.10