Deploy refined v2 slogan generator with Gradio UI

app.py

@@ -2,118 +2,97 @@
 import gradio as gr
 import pandas as pd
 import numpy as np
-from sentence_transformers import SentenceTransformer
-import faiss
+import faiss, re, torch
+from sentence_transformers import SentenceTransformer, CrossEncoder
 from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-import torch
-import re
 
-# Load generation model (FLAN-T5-base for reliability)
-GEN_TOK   = AutoTokenizer.from_pretrained("google/flan-t5-base")
-GEN_MODEL = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-base")
+# ------------------ Models ------------------
+GEN_TOK   = AutoTokenizer.from_pretrained("google/flan-t5-large")
+GEN_MODEL = AutoModelForSeq2SeqLM.from_pretrained("google/flan-t5-large")
 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 GEN_MODEL = GEN_MODEL.to(DEVICE)
 
-# Load embedding model
-embed_model = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+EMBED_MODEL = SentenceTransformer("sentence-transformers/all-mpnet-base-v2")
+RERANKER    = CrossEncoder("cross-encoder/stsb-roberta-base")
 
-# Marketing lexicons
-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"}
+# ------------------ Dummy dataset (for demo) ------------------
+data = 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"
+    ]
+})
+
+# Build FAISS index
+data_vecs = EMBED_MODEL.encode(data["description"].tolist())
+faiss.normalize_L2(data_vecs)
+index = faiss.IndexFlatIP(data_vecs.shape[1])
+index.add(data_vecs)
+
+def recommend(query, top_k=3):
+    query_vec = EMBED_MODEL.encode([query])
+    faiss.normalize_L2(query_vec)
+    scores, idx = index.search(query_vec, top_k)
+    results = data.iloc[idx[0]].copy()
+    results["score"] = scores[0]
+    return results[["name", "tagline", "description", "score"]]
+
+# ------------------ 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]+$"
+    r"^[A-Z][a-z]+$",
 ]
-FORBIDDEN_WORDS = {
-    "app","assistant","platform","solution","system","marketplace",
-    "ai","machine learning","augmented reality","virtual reality",
-    "decentralized","empower"
-}
 
-def _tokens(s: str):
-    return re.findall(r"[a-z0-9]{3,}", s.lower())
+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"}
+BENEFIT_WORDS   = {"faster","smarter","easier","better","safer","clearer"}
 
-def _jaccard(a, b):
-    A, B = set(a), set(b)
-    return len(A & B) / len(A | B) if A and B else 0.0
+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()
+    if len(words) > max_words:
+        text = " ".join(words[:max_words])
+    return text
 
 def _is_blocked_slogan(s: str) -> bool:
-    if not s:
+    s_low = s.lower()
+    if any(w in s_low for w in HARD_BLOCK_WORDS):
         return True
     for pat in BLOCK_PATTERNS:
         if re.match(pat, s.strip()):
             return True
-    low = s.lower()
-    for w in FORBIDDEN_WORDS:
-        if w in low:
-            return True
     return False
 
-def _generic_penalty(s: str) -> float:
-    low = s.lower()
-    hits = sum(1 for w in FORBIDDEN_WORDS if w in low)
-    return min(1.0, hits * 0.2)
-
-def _for_penalty(s: str) -> float:
-    return 0.3 if re.search(r"\bfor\b", s.lower()) else 0.0
-
-def _clean_line(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])
-    # Soft title case
-    out_words = []
-    for w in text.split():
-        out_words.append(w if w.isupper() else w.capitalize())
-    return " ".join(out_words)
-
-def _marketing_score(s: str) -> float:
-    words = set(w.lower() for w in s.split())
-    verb_hits = len(words & MARKETING_VERBS)
-    benefit_hits = len(words & BENEFIT_WORDS)
-    return min(1.0, 0.25 * verb_hits + 0.25 * benefit_hits)
-
-def recommend(query: str, top_k: int = 3) -> pd.DataFrame:
-    """Return top_k items most similar to the query based on description embeddings."""
-    query_vec = embed_model.encode([query])
-    faiss.normalize_L2(query_vec)
-    scores, idx = index.search(query_vec, top_k)
-    results = data.iloc[idx[0]].copy()
-    results["score"] = scores[0]
-    return results[["name", "tagline", "description", "score"]]
-
-def generate_slogan(query_text: str, neighbors_df: pd.DataFrame = None, n_samples: int = 16) -> str:
-    """
-    Generate multiple slogans using FLAN-T5, filter and score them,
-    then return the best slogan based on semantic similarity and marketing tone.
-    """
-    ctx_lines = []
-    if neighbors_df is not None and not neighbors_df.empty:
-        for _, row in neighbors_df.head(3).iterrows():
-            tg = str(row.get("tagline", "")).strip()
-            if 5 <= len(tg) <= 70:
-                ctx_lines.append(f"- {tg}")
-    context = "\n".join(ctx_lines)
+def _score_candidates(query: str, cands: list) -> list:
+    if not cands:
+        return []
+    ce_scores = np.asarray(RERANKER.predict([(query, s) for s in cands]), dtype=np.float32) / 5.0
+    results = []
+    for i, s in enumerate(cands):
+        words = s.split()
+        brevity = 1.0 - min(1.0, abs(len(words) - 5) / 5.0)
+        marketing = 0.2*len(set(words) & MARKETING_VERBS) + 0.2*len(set(words) & BENEFIT_WORDS)
+        score = 0.6*float(ce_scores[i]) + 0.2*brevity + 0.2*marketing
+        results.append((s, float(score)))
+    return results
+
+# ------------------ Generator ------------------
+def generate_slogan(query_text: str, n_samples: int = 16) -> str:
     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"
+        "Focus on benefits and vivid verbs. Do not copy the description.\n\n"
+        f"Description: {query_text}\nSlogans:"
     )
-    if context:
-        prompt += f"Similar taglines (style only):\n{context}\n\n"
-    prompt += f"Description: {query_text}\nSlogans:"
 
     input_ids = GEN_TOK(prompt, return_tensors="pt").input_ids.to(DEVICE)
     outputs = GEN_MODEL.generate(
@@ -123,80 +102,36 @@ def generate_slogan(query_text: str, neighbors_df: pd.DataFrame = None, n_sample
         top_k=60,
         top_p=0.92,
         temperature=1.2,
-        num_return_sequences=n_samples,
-        repetition_penalty=1.08
+        num_return_sequences=n_samples
     )
-    raw_texts = [GEN_TOK.decode(o, skip_special_tokens=True) for o in outputs]
 
-    candidates = set()
-    for txt in raw_texts:
+    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_line(line)
-            if not s or len(s.split()) < 2 or len(s.split()) > 8:
-                continue
-            if _is_blocked_slogan(s):
-                continue
-            # Avoid copying neighbor taglines
-            skip = False
-            if neighbors_df is not None and not neighbors_df.empty:
-                for _, row in neighbors_df.iterrows():
-                    tg = str(row.get("tagline", "")).strip()
-                    if not tg:
-                        continue
-                    if s.lower() == tg.lower():
-                        skip = True
-                        break
-                    if _jaccard(_tokens(s), _tokens(tg.lower())) >= 0.7:
-                        skip = True
-                        break
-                if skip:
-                    continue
-            candidates.add(s)
-
-    if not candidates:
-        first = _clean_line(raw_texts[0])
-        return first if first else query_text
-
-    query_vec = embed_model.encode([query_text])[0]
-    query_vec = query_vec / np.linalg.norm(query_vec)
-    scored = []
-    for s in candidates:
-        s_vec = embed_model.encode([s])[0]
-        s_vec = s_vec / np.linalg.norm(s_vec)
-        similarity = float(np.dot(query_vec, s_vec))
-        brevity = 1.0 - min(1.0, abs(len(s.split()) - 5) / 5.0)
-        marketing = _marketing_score(s)
-        generic = _generic_penalty(s)
-        for_pen = _for_penalty(s)
-        score = 0.6*similarity + 0.2*brevity + 0.2*marketing - 0.05*generic - 0.05*for_pen
-        scored.append((s, score))
-    scored.sort(key=lambda x: x[1], reverse=True)
-    return scored[0][0]
+            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
+            cand_set.add(s.capitalize())
 
-# Dummy dataset; replace with your full dataset
-data = 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"
-    ]
-})
+    if not cand_set:
+        return "Fresh Ideas, Built To Scale"
 
-# Build FAISS index
-data_vecs = embed_model.encode(data["description"].tolist())
-faiss.normalize_L2(data_vecs)
-index = faiss.IndexFlatIP(data_vecs.shape[1])
-index.add(data_vecs)
+    scored = _score_candidates(query_text, sorted(cand_set))
+    scored.sort(key=lambda x: x[1], reverse=True)
+    return scored[0][0] if scored else "Fresh Ideas, Built To Scale"
 
+# ------------------ Pipeline ------------------
 def pipeline(user_input):
     recs = recommend(user_input, top_k=3)
-    slogan = generate_slogan(user_input, neighbors_df=recs)
+    slogan = generate_slogan(user_input)
     recs = recs.reset_index(drop=True)
     recs.loc[len(recs)] = ["Generated Slogan", slogan, user_input, np.nan]
     return recs
 
+# ------------------ Gradio UI ------------------
 examples = [
     "AI coach for improving public speaking skills",
     "Augmented reality app for interactive museum tours",
@@ -208,7 +143,7 @@ examples = [
 demo = gr.Interface(
     fn=pipeline,
     inputs=gr.Textbox(label="Enter a startup description"),
-    outputs=gr.Dataframe(headers=["Name","Tagline","Description","Score"]),
+    outputs=gr.Dataframe(headers=["Name", "Tagline", "Description", "Score"]),
     examples=examples,
     title="SloganAI – Startup Recommendation & Slogan Generator",
     description="Enter a startup idea and get top-3 similar startups + 1 generated slogan."