Upload folder using huggingface_hub

README.md

@@ -1,12 +1,13 @@
 ---
-title: Slogan2
-emoji: 🚀
-colorFrom: purple
-colorTo: indigo
+title: Slogan Finder
+emoji: 🏷️
+colorFrom: yellow
+colorTo: green
 sdk: gradio
-sdk_version: 5.43.1
+sdk_version: "4.0.0"
 app_file: app.py
 pinned: false
 ---
 
-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

@@ -0,0 +1,169 @@
+\
+import os, json, numpy as np, pandas as pd
+import gradio as gr
+import faiss
+
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+
+from logic.cleaning import clean_dataframe
+from logic.search import SloganSearcher
+
+ASSETS_DIR = "assets"
+DATA_PATH  = "data/slogan.csv"
+
+MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+NORMALIZE  = True
+
+GEN_MODEL_NAME = "google/flan-t5-base"
+NUM_GEN_CANDIDATES = 6
+MAX_NEW_TOKENS = 24
+TEMPERATURE = 0.9
+TOP_P = 0.95
+NOVELTY_SIM_THRESHOLD = 0.80
+
+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)
+
+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.")
+
+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()
+
+_ensure_assets()
+
+searcher = SloganSearcher(assets_dir=ASSETS_DIR, use_rerank=False)
+
+meta = json.load(open(META_PATH))
+_encoder = SentenceTransformer(meta["model_name"])
+
+_gen_tokenizer = AutoTokenizer.from_pretrained(GEN_MODEL_NAME)
+_gen_model = AutoModelForSeq2SeqLM.from_pretrained(GEN_MODEL_NAME)
+
+# ---- Prompt (adjust if you want your exact wording) ----
+def _prompt_for(description: str) -> str:
+    return (
+        "You are a professional slogan writer. "
+        "Write ONE original, catchy startup slogan under 8 words, Title Case, no punctuation. "
+        "Do not copy examples. Description:\n"
+        f"{description}\nSlogan:"
+    )
+
+def _generate_candidates(description: str, n: int = NUM_GEN_CANDIDATES):
+    prompt = _prompt_for(description)
+    inputs = _gen_tokenizer([prompt]*n, 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,
+        eos_token_id=_gen_tokenizer.eos_token_id,
+    )
+    texts = _gen_tokenizer.batch_decode(outputs, skip_special_tokens=True)
+    return [t.replace("Slogan:", "").strip().strip('"') for t in texts if t.strip()]
+
+def _pick_most_novel(candidates, retrieved_texts):
+    if not candidates:
+        return None
+    R = _encoder.encode(retrieved_texts, convert_to_numpy=True, normalize_embeddings=True) if retrieved_texts else None
+    best, best_novelty = None, -1e9
+    for c in candidates:
+        c_emb = _encoder.encode([c], convert_to_numpy=True, normalize_embeddings=True)
+        if R is None or len(retrieved_texts) == 0:
+            max_sim = 0.0
+        else:
+            sims = np.dot(R, c_emb[0])  # cosine
+            max_sim = float(np.max(sims))
+        novelty = 1.0 - max_sim
+        if (max_sim < NOVELTY_SIM_THRESHOLD and novelty > best_novelty) or best is None and novelty > best_novelty:
+            best, best_novelty = c, novelty
+    return best
+
+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, NUM_GEN_CANDIDATES)
+    generated = _pick_most_novel(gens, retrieved_texts) 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(generated)
+    return "\n".join(lines)
+
+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()

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 = PUNCT_RE.sub(" ", s)
+    s = WS_RE.sub(" ", 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

@@ -0,0 +1,9 @@
+gradio>=4.0.0
+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
+transformers>=4.40.0

runtime.txt

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