Deploy Space: robust paths + FAISS-or-CSV fallback + Refined v2

app.py

@@ -1,277 +1,304 @@
-\
-import os, json, numpy as np, pandas as pd
-import gradio as gr
-import faiss
-import re
-from sentence_transformers import SentenceTransformer
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-
-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:
-        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.")
+import os, re, json, numpy as np, pandas as pd, gradio as gr, faiss, torch
+from typing import List
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-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
+# =========================
+# Config
+# =========================
+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"))
+INDEX_ROOT   = os.path.join(os.path.dirname(__file__), "vector_store")
+DEFAULT_MODEL_FOR_INDEX = EMBED_NAME
+CSV_PATH     = os.path.join(os.path.dirname(__file__), "cleaned_data.csv")
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# =========================
+# Lazy models
+# =========================
+_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] {e}; fallback to {FLAN_FALLBACK}")
+            tok = AutoTokenizer.from_pretrained(FLAN_FALLBACK)
+            mdl = AutoModelForSeq2SeqLM.from_pretrained(FLAN_FALLBACK)
+            _GEN_TOK, _GEN_MODEL = tok, mdl.to(DEVICE)
+
+# =========================
+# Index cache
+# =========================
+_INDEX_CACHE = {}   # mkey -> (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 _build_memory_index_from_csv(model_name: str):
+    if not os.path.exists(CSV_PATH):
+        return None
+    df = pd.read_csv(CSV_PATH)
+    for col in ("name","tagline","description"):
+        if col not in df.columns: df[col] = ""
+    texts = df["description"].astype(str).tolist()
+    embedder = SentenceTransformer(model_name) if model_name != EMBED_NAME else _EMBED_MODEL
+    if model_name.startswith("intfloat/e5"):
+        texts = _format_for_e5(texts, as_query=False)
+    vecs = embedder.encode(texts, normalize_embeddings=True)
+    vecs = np.asarray(vecs, dtype=np.float32)
+    idx = faiss.IndexFlatIP(vecs.shape[1])
+    idx.add(vecs)
+    return idx, df[["name","tagline","description"]].copy()
+
+def _load_index_for_model(model_name: str = DEFAULT_MODEL_FOR_INDEX):
+    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 os.path.exists(idx_path) and os.path.exists(meta_path):
+        index = faiss.read_index(idx_path)
+        meta  = pd.read_parquet(meta_path)
+        _INDEX_CACHE[mkey] = (index, meta)
+        return _INDEX_CACHE[mkey]
+
+    # fallback: build from CSV if available
+    built = _build_memory_index_from_csv(model_name)
+    if built is not None:
+        _INDEX_CACHE[mkey] = built
+        return built
+
+    # last fallback: tiny demo
+    print("[WARN] FAISS & CSV missing — using tiny demo 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"
+        ]
+    })
+    embedder = SentenceTransformer(model_name) if model_name != EMBED_NAME else _EMBED_MODEL
+    vecs = embedder.encode(demo["description"].tolist(), normalize_embeddings=True)
+    vecs = np.asarray(vecs, dtype=np.float32)
+    idx = faiss.IndexFlatIP(vecs.shape[1]); idx.add(vecs)
+    _INDEX_CACHE[mkey] = (idx, demo)
+    return _INDEX_CACHE[mkey]
+
+# =========================
+# Recommend
+# =========================
+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)
+    q_inp = _format_for_e5([query_text], as_query=True) if model_name.startswith("intfloat/e5") else [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)
+    out = meta.iloc[idxs[0]].copy()
+    out["score"] = scores[0]
+    for col in ("name","tagline","description"):
+        if col not in out.columns: out[col] = ""
+    cols = ["name","tagline","description","score"]
+    return out[cols]
+
+# =========================
+# Refined v2 – helpers
+# =========================
+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:
+    return " ".join(w if w.isupper() else w.capitalize() for w in s.split())
+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()
+    if any(w in s_low for w in HARD_BLOCK_WORDS): return True
+    return s_low in GOOD_SLOGANS_TO_AVOID_DUP
+
+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 ""
+    ex=[]
+    for _,row in neighbors_df.head(3).iterrows():
+        tg=str(row.get("tagline","")).strip()
+        if 5<=len(tg)<=70: ex.append(f"- {tg}")
+    return "\n".join(ex)
+
+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:
-        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 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 _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,
-        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,
+        em=SentenceTransformer(EMBED_NAME)
+        s_vec=em.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=em.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: 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()
+    words=text.split()
+    return " ".join(words[:max_words]) if len(words)>max_words else text
+
+def _score_candidates(query: str, cands: List[str], neighbors_df: pd.DataFrame) -> List[tuple]:
+    if not cands: return []
+    ce_scores=np.asarray(CrossEncoder(RERANK_NAME).predict([(query,s) for s in cands]),dtype=np.float32)/5.0
+    q_toks=_tokens(query); results=[]
+
+    em=SentenceTransformer(EMBED_NAME)
+    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=em.encode([t])[0]; neighbor_vecs.append(v/np.linalg.norm(v))
+
+    for i,s in enumerate(cands):
+        words=s.split()
+        brev=1.0-min(1.0,abs(len(words)-5)/5.0)
+        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=em.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: n_pen=0.0
+        overlap=_jaccard(q_toks,_tokens(s)); anti_copy=1.0-overlap
+        score=0.55*float(ce_scores[i])+0.20*brev+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:\nDescription: AI assistant for doctors to prioritize patient cases\nSlogan: Less Guessing. More Healing.\n\n"
+        "Description: Payments for small online stores\nSlogan: Built to Grow with Your Cart.\n\n"
+        "Description: Neurotech headset to boost focus\nSlogan: Train Your Brain to Win.\n\n"
+        "Description: Interior design suggestions with AI\nSlogan: Style That Thinks With You.\n\n"
+        "Bad Examples (avoid these): Innovative AI Platform / Smart App for Everyone / Empowering Small Businesses\n\n"
     )
-    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()
-
+    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,do_sample=True,top_k=60,top_p=0.92,temperature=1.2,num_return_sequences=n_samples,repetition_penalty=1.08)
+    raw=[_GEN_TOK.decode(o,skip_special_tokens=True) for o in outputs]
+    cand=set()
+    for txt in raw:
+        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.add(_titlecase_soft(s))
+    if not cand: return _clean_slogan(_GEN_TOK.decode(outputs[0],skip_special_tokens=True))
+    scored=_score_candidates(query_text,sorted(cand),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
+# =========================
+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):
+    recs=recommend(user_input, model_name=DEFAULT_MODEL_FOR_INDEX, top_k=3)
+    slogan=generate_slogan(user_input, neighbors_df=recs, n_samples=NUM_SLOGAN_SAMPLES)
+    recs=recs.reset_index(drop=True)
+    for col in ("name","tagline","description"):
+        if col not in recs.columns: recs[col]=""
+    recs.loc[len(recs)]={"name":"Synthetic Example","tagline":slogan,"description":user_input,"score":np.nan}
+    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")
+    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")
+            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()

requirements.txt

@@ -1,9 +1,8 @@
-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
+gradio>=4.36.1,<5
+transformers>=4.42,<5
+sentence-transformers>=2.3.1
+faiss-cpu
+pandas
+numpy
 torch
-transformers>=4.40.0
+pyarrow