"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Plain-text fallback render (always visible regardless of CSS animation) ──
+ st.markdown(
+ f"",
+ unsafe_allow_html=True,
+ )
+
+ # ── Why This Matters — emotional impact hero ──────────────────────────────
+ _why_this_matters(cpci, attn, mem, val, cl, use_case)
+
+ # ── Fallback: warn if CPCi is genuinely zero (pipeline failure) ───────────
+ if cpci == 0 and (attn > 0 or mem > 0):
+ st.warning(
+ "⚠️ CPCi shows 0 but signals are non-zero — check signal pipeline. "
+ f"(Attention={attn}, Memory={mem}, Valence={val:.2f})"
+ )
+
+ # ── Signal strip — 4 numbers ──────────────────────────────────────────────
+ st.markdown(
+ f"",
+ unsafe_allow_html=True,
+ )
+
+ # ── Final Verdict — standalone section ────────────────────────────────────
+ verdict_txt = _final_verdict_text(cpci, attn, mem, val, cl, use_case)
+ st.markdown(
+ f""
+ f"🧠 CPCi — Cost Per Cognitive Impression {_TT_CPCI}
"
+ f""
+ f""
+ f"Predicts cognitive impact before media spend
"
+ f""
+ f"out of 100 · {uc['icon']} {use_case}
"
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(""
+ f"⚡ Final Verdict
"
+ f"{verdict_txt}
"
+ f""
+ f"
"
+ f"{badge(clabel, cstyle)}
"
+ f""
+ f"● "
+ f"Confidence: {conf_level}"
+ f"
"
+ f"", + unsafe_allow_html=True) + + # ── Business Impact — CMO-facing commercial translation ─────────────────── + _business_impact(cpci, attn, mem, val, cl, use_case) + + # ── Creative Optimization Scenario — what one fix is worth ──────────────── + _optimization_scenario(cpci, attn, mem, val, cl, vf, use_case) + + # ── Collapsed details (Brief + Classification) ─────────────────────────── + with st.expander("📋 Creative Brief & Classification"): + _creative_brief(cpci, attn, mem, val, cl, vf, use_case) + _render_classification(cpci, attn, mem, val, cl, vf, use_case) + + st.markdown("
", + unsafe_allow_html=True) + + # ── What This Means — full width, immediately below ─────────────────────── + _quick_read(cpci, attn, mem, val, cl, vf, use_case) + + st.markdown("
", + unsafe_allow_html=True) + + # ── Media Implications — placement fit + strategy ───────────────────────── + _media_implications(cpci, attn, mem, val, cl, vf, use_case) + + # ══════════════════════════════════════════════════════════════════════════ + # TIER 2 — Secondary detail (visually quiet, below a clear separator) + # ══════════════════════════════════════════════════════════════════════════ + st.markdown( + "
"
+ ""
+ "Detailed Analysis
",
+ unsafe_allow_html=True,
+ )
+
+ detail_left, detail_right = st.columns([1, 1], gap="large")
+
+ with detail_left:
+ _section_card(
+ icon = "📈",
+ title = "Strategic Implication",
+ accent= "#3B82F6",
+ body = narr.get("strategic_implication", ""),
+ pointers=[
+ ("Use case", use_case, "#3B82F6"),
+ ("CPCi", f"{cpci}/100", cc),
+ ("Attention", f"{attn}/100", a_color),
+ ("Memory", f"{mem}/100", m_color),
+ ],
+ )
+
+ with detail_right:
+ _render_recommendations(
+ body = narr.get("recommendations", ""),
+ pointers = [
+ ("Priority fix",
+ "Add face" if vf["face_count"] == 0
+ else "Boost contrast" if vf["contrast_score"] < 60
+ else "Reduce objects" if vf["object_count"] > 6
+ else "Add tagline" if vf["text_density"] < 0.05
+ else "Trim copy",
+ "#F59E0B"),
+ ("Attention gap", f"{max(0, 60-attn)} pts", a_color),
+ ("Memory gap", f"{max(0, 70-mem)} pts", m_color),
+ ("Load", cl, cl_color),
+ ],
+ )
+
+ # Cognitive Diagnosis — full width, most technical, last
+ _cognitive_diagnosis(
+ attn=attn, mem=mem, val=val, cl=cl, cl_score=cl_score,
+ vf=vf,
+ a_color=a_color, a_label=a_label,
+ m_color=m_color, m_label=m_label,
+ v_color=v_color, v_label=v_label,
+ cl_color=cl_color,
+ )
+
+ # Trust indicators — how this works, limitations, confidence
+ st.markdown("", unsafe_allow_html=True) + _render_trust_indicators(cpci, attn, mem, conf_level, conf_color) + + # Export report bar + st.markdown("
", unsafe_allow_html=True) + _render_export_bar(r, use_case) + + # ── CTA block ──────────────────────────────────────────────────────────── + _render_cta_block(r, use_case) + + +# ── Multi-creative comparison ───────────────────────────────────────────────── + +import base64 as _b64 + +def _client_insight(narr: dict, cpci: float, attn: int, mem: int, val: float, cl: str, use_case: str) -> str: + """ + One plain-English sentence a client can instantly understand. + Pulled from narrative if available, otherwise generated from signals. + No jargon. No scores. Just what it means for the campaign. + """ + # Try narrative first + si = narr.get("strategic_implication", "") + if si and len(si) > 20: + # Return first sentence only + return si.split(".")[0].strip() + "." + + # Fallback: signal-driven + if cpci >= 70: + if attn >= 65: + return "This creative will stop the scroll and encode the brand — both are rare in the same creative, and this is ready to scale." + return "This creative will drive cognitive engagement efficiently — all signals are above the threshold required for reliable performance." + elif cpci >= 55: + if attn < 45: + return "This creative will build recall among viewers who see it, but will not reliably stop cold audiences — acquisition efficiency is at risk." + if mem < 50: + return "This creative will attract attention but will not be remembered after a single exposure — reach without recall is wasted media." + return "This creative is one signal fix away from scale — the foundation is strong but one dimension is suppressing the composite score." + elif cpci >= 40: + if cl == "High": + return "This creative will lose viewers before the message lands — visual overload is causing the brain to abandon processing before engagement occurs." + return "This creative will not convert efficiently at scale — the cognitive signal profile is too weak to justify full budget deployment." + else: + return "This creative will not perform regardless of budget or targeting — the cognitive barriers require a rebuild, not a boost in spend." + + +def _client_recommendation(narr: dict, cpci: float, attn: int, mem: int, val: float, cl: str, vf: dict) -> str: + """One actionable sentence a client can take to their creative team.""" + rec = narr.get("recommendations", "") + if rec and len(rec) > 20: + return rec.split(".")[0].strip() + "." + + # Fallback + if vf.get("face_count", 0) == 0 and attn < 50: + return "Add a human face as the primary visual — it is the fastest single change to trigger an orienting response and lift emotional valence." + if cl == "High": + return "Remove at least half the visual elements before scaling — working memory saturation is actively blocking every other signal." + if mem < 45: + return "Rebuild around one dominant image and one short line of copy — single-exposure recall requires radical simplicity." + if val < -0.05: + return "Replace the dominant cool tones with warmer equivalents — the palette is generating subconscious avoidance that will compound across impressions." + if attn < 45: + return "Increase the primary subject's size and contrast — the creative needs to clear the visual salience threshold before targeting or spend can help." + return "Test a version with a human face as the hero — it is the highest-probability change for lifting attention, emotion, and recall simultaneously." + + +def _show_results_client(r: dict, use_case: str) -> None: + """Client Mode — single creative. Clean, no technical metrics.""" + s = r["signals"] + narr = r.get("narrative", {}) + cpci = r["cpci"] + attn = s["attention_score"] + mem = s["memory_score"] + val = s["emotional_valence"] + cl = s["cognitive_load"] + vf = r["visual_features"] + + cc = "#22C55E" if cpci >= 70 else ("#F59E0B" if cpci >= 40 else "#EF4444") + verdict = _final_verdict_text(cpci, attn, mem, val, cl, use_case) + insight = _client_insight(narr, cpci, attn, mem, val, cl, use_case) + rec = _client_recommendation(narr, cpci, attn, mem, val, cl, vf) + + # Confidence (same logic as expert mode) + if attn > 50 and mem > 50: + conf_level, conf_color = "High", "#22C55E" + elif attn < 30 and mem < 30: + conf_level, conf_color = "Low", "#EF4444" + elif abs(attn - mem) > 35 or (attn < 30 or mem < 30): + conf_level, conf_color = "Low", "#EF4444" + else: + conf_level, conf_color = "Medium", "#F59E0B" + + # Label + if cpci >= 70: perf_label = "Strong Performer" + elif cpci >= 40: perf_label = "Needs Optimisation" + else: perf_label = "Not Ready to Scale" + + # ── Creative image hero ─────────────────────────────────────────────────── + _render_creative_hero(r.get("file_path", ""), r.get("name", ""), is_video=r.get("visual_features", {}).get("is_video", False)) + + left, right = st.columns([2, 3], gap="large") + + with left: + st.markdown( + f"
"
+ f"
" + f"
",
+ unsafe_allow_html=True,
+ )
+
+ with right:
+ st.markdown(
+ f"Creative Score
"
+ f"{cpci}
"
+ f""
+ f"out of 100 · {use_case}
"
+ f"" + f"
Performance Outlook
"
+ f""
+ f"{perf_label}
"
+ f""
+ f"
" + f"
" + f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown("Verdict
"
+ f"{verdict}
"
+ f"" + f"
Key Insight
"
+ f"{insight}
"
+ f"" + f"
Recommendation
"
+ f"{rec}
"
+ f"", + unsafe_allow_html=True) + + # Why This Matters — emotional impact hero before business detail + _why_this_matters(cpci, attn, mem, val, cl, use_case) + + # Business Impact — CMO-facing translation + _business_impact(cpci, attn, mem, val, cl, use_case) + + # Optimization Scenario — turns the diagnosis into a growth story + _optimization_scenario(cpci, attn, mem, val, cl, vf, use_case) + + # ── Collapsed details (Brief + Classification) ─────────────────────────── + with st.expander("📋 Creative Brief & Classification"): + _creative_brief(cpci, attn, mem, val, cl, vf, use_case) + _render_classification(cpci, attn, mem, val, cl, vf, use_case) + + st.markdown("
", + unsafe_allow_html=True) + + # Media Implications + _media_implications(cpci, attn, mem, val, cl, vf, use_case) + + st.markdown("
", + unsafe_allow_html=True) + + # Trust indicators — how this works, limitations, confidence + st.markdown("
", unsafe_allow_html=True) + _render_trust_indicators(cpci, attn, mem, conf_level, conf_color) + + # Export report bar + st.markdown("
", unsafe_allow_html=True) + _render_export_bar(r, use_case) + + # ── CTA block ──────────────────────────────────────────────────────────── + _render_cta_block(r, use_case) + + +def _show_comparison_client(sorted_results: list, use_case: str) -> None: + """Client Mode — comparison. One card per creative, verdict + insight + recommendation only.""" + n = len(sorted_results) + + st.markdown( + "
Cognitive Signal Engine™
"
+ "Creative Intelligence Analyzer
"
+ f"Client Report · {use_case} · Comparing {n} Creatives
",
+ unsafe_allow_html=True,
+ )
+
+ cols = st.columns(n, gap="medium")
+ for i, (col, r) in enumerate(zip(cols, sorted_results)):
+ s = r["signals"]
+ narr = r.get("narrative", {})
+ cpci = r["cpci"]
+ attn = s["attention_score"]
+ mem = s["memory_score"]
+ val = s["emotional_valence"]
+ cl = s["cognitive_load"]
+ vf = r["visual_features"]
+ is_win = (i == 0)
+ cc = "#22C55E" if cpci >= 70 else ("#F59E0B" if cpci >= 40 else "#EF4444")
+ card_cls = "ab-card-winner" if is_win else "ab-card"
+
+ verdict = _final_verdict_text(cpci, attn, mem, val, cl, use_case)
+ insight = _client_insight(narr, cpci, attn, mem, val, cl, use_case)
+ rec = _client_recommendation(narr, cpci, attn, mem, val, cl, vf)
+
+ img_src = _img_b64(r.get("file_path", ""))
+ img_html = (
+ f"🏆 Recommended
"
+ if is_win else
+ f"Option {i+1}
"
+ )
+
+ col.markdown(
+ f""
+ f"{rank_html}"
+ f"{img_html}"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # Why the winner wins (client-friendly language)
+ if n > 1:
+ winner = sorted_results[0]
+ runner_up = sorted_results[1]
+ why = _why_wins(winner, runner_up, use_case)
+ st.markdown(
+ f"{short_name(r['name'], 24)}
"
+ f"{cpci}
"
+ f"/ 100
"
+ f"Verdict
"
+ f"{verdict}
"
+ f"Key Insight
"
+ f"{insight}
"
+ f"Recommendation
"
+ f""
+ f"{rec}
"
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(
+ "Our Recommendation
"
+ f"🏆 {winner['name']}
"
+ f"{why}
"
+ f"Cognitive Signal Engine™
", + unsafe_allow_html=True, + ) + + +_IMG_EXTS = {"jpg", "jpeg", "png", "gif", "webp"} +_VIDEO_EXTS_B64 = {"mp4", "mov", "avi", "webm", "m4v", "mkv"} + +def _img_b64(file_path: str) -> str: + """Return a base64 data URI for an image file (for inline HTML display). + For video files, uses the saved thumbnail (generated during analysis). + Returns '' if unavailable so callers show a 'No preview' fallback. + """ + if not file_path: + return "" + try: + ext = file_path.rsplit(".", 1)[-1].lower() + # For video files, use the thumbnail PNG saved alongside it + if ext in _VIDEO_EXTS_B64: + thumb = file_path + "_thumb.png" + if os.path.exists(thumb): + with open(thumb, "rb") as f: + data = _b64.b64encode(f.read()).decode() + return f"data:image/png;base64,{data}" + return "" # no thumbnail → show "No preview" placeholder + # Image files — only encode known image types to avoid binary garbage + if ext not in _IMG_EXTS: + return "" + with open(file_path, "rb") as f: + data = _b64.b64encode(f.read()).decode() + mime = {"jpg": "jpeg", "jpeg": "jpeg", "png": "png", + "gif": "gif", "webp": "webp"}.get(ext, "jpeg") + return f"data:image/{mime};base64,{data}" + except Exception: + return "" + + +_HERO_VIDEO_EXTS = {".mp4", ".mov", ".avi", ".webm", ".m4v"} + +def _render_creative_hero(file_path: str, name: str = "", is_video: bool = False) -> None: + """Render the uploaded creative prominently above analysis output.""" + label_html = ( + f""
+ f"{'🎬 Analyzed Video Creative' if is_video else 'Analyzed Creative'}
"
+ )
+ name_html = (
+ f"{name}
"
+ if name else ""
+ )
+
+ # Check by extension if not explicitly flagged
+ if not is_video:
+ is_video = os.path.splitext(file_path)[1].lower() in _HERO_VIDEO_EXTS
+
+ if is_video and os.path.exists(file_path):
+ st.markdown(
+ f"{label_html}
",
+ unsafe_allow_html=True,
+ )
+ # Centre the video player with constrained width
+ _vid_l, _vid_c, _vid_r = st.columns([1, 4, 1])
+ with _vid_c:
+ with open(file_path, "rb") as vf:
+ st.video(vf.read())
+ if name:
+ st.caption(name)
+ return
+
+ img_src = _img_b64(file_path)
+ if not img_src:
+ return
+ st.markdown(
+ f""
+ f"{label_html}"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+
+def _why_wins(winner: dict, runner_up: dict, use_case: str) -> str:
+ """
+ Return a tight 2–3 sentence decisive summary of why the winner beats the runner-up.
+ No hedging. No 'it seems'. Just facts + numbers.
+ """
+ ws = winner["signals"]; rs = runner_up["signals"]
+ wvf = winner["visual_features"]; rvf = runner_up["visual_features"]
+ w_cpci = winner["cpci"]; r_cpci = runner_up["cpci"]
+ gap = round(w_cpci - r_cpci, 1)
+
+ parts = []
+
+ # --- CPCi gap opener
+ if gap >= 20:
+ parts.append(
+ f"{winner['name']} dominates by {gap} CPCi points — "
+ f"a margin that translates directly to higher conversion probability in market."
+ )
+ elif gap >= 10:
+ parts.append(
+ f"{winner['name']} outperforms by {gap} CPCi points — "
+ f"a clear, meaningful edge across the cognitive signal stack."
+ )
+ else:
+ parts.append(
+ f"{winner['name']} edges ahead by {gap} CPCi points — "
+ f"a narrow but consistent advantage across multiple signals."
+ )
+
+ # --- Strongest signal advantage
+ attn_gap = ws["attention_score"] - rs["attention_score"]
+ mem_gap = ws["memory_score"] - rs["memory_score"]
+ val_gap = round(ws["emotional_valence"] - rs["emotional_valence"], 2)
+ load_adv = {"Low": 0, "Medium": 1, "High": 2}
+ load_gap = load_adv.get(rs["cognitive_load"], 1) - load_adv.get(ws["cognitive_load"], 1)
+
+ advantages = sorted(
+ [("attn", attn_gap), ("mem", mem_gap), ("val", val_gap * 40), ("load", load_gap * 15)],
+ key=lambda x: x[1], reverse=True,
+ )
+ top_sig, top_gap = advantages[0]
+
+ if top_sig == "attn" and attn_gap > 3:
+ reason = (
+ f"The primary edge is attention (+{attn_gap} pts) — "
+ )
+ if wvf.get("face_count", 0) > rvf.get("face_count", 0):
+ reason += "the winner's human face triggers involuntary fixation before the viewer consciously decides to look."
+ elif wvf.get("contrast_score", 50) > rvf.get("contrast_score", 50) + 8:
+ reason += "higher contrast pops the winner out of feed clutter where the loser blends in."
+ else:
+ reason += "the winner's cleaner composition gives the eye a clear landing point — the loser fragments attention across too many elements."
+ elif top_sig == "mem" and mem_gap > 3:
+ reason = (
+ f"The decisive factor is memory encoding (+{mem_gap} pts) — "
+ )
+ if wvf.get("object_count", 5) < rvf.get("object_count", 5):
+ reason += f"the winner's simpler layout ({wvf.get('object_count',0)} objects vs {rvf.get('object_count',0)}) encodes cleanly into long-term memory; the loser's clutter gets discarded."
+ elif 0.05 <= wvf.get("text_density", 0) <= 0.25 and rvf.get("text_density", 0) > 0.25:
+ reason += "optimal text density gives the brain a verbal anchor; the loser overloads the verbal channel and nothing sticks."
+ else:
+ reason += "a simpler visual hierarchy lets the brain commit the message — the loser asks viewers to do too much cognitive work."
+ elif top_sig == "load" and load_gap > 0:
+ reason = (
+ f"Lower cognitive load is the key differentiator — "
+ f"the winner processes in milliseconds ({ws['cognitive_load']}), "
+ f"the loser demands effort ({rs['cognitive_load']}) that scrolling audiences won't give."
+ )
+ elif top_sig == "val" and val_gap > 0.05:
+ reason = (
+ f"Emotional valence (+{val_gap:+.2f}) tips the balance — "
+ )
+ if wvf.get("face_count", 0) > rvf.get("face_count", 0):
+ reason += "the winner's human face generates affiliative warmth the loser's visuals simply cannot replicate."
+ else:
+ reason += "the winner's color palette encodes positive affect subconsciously; the loser's palette creates mild aversion most viewers never consciously notice."
+ else:
+ reason = (
+ "The winner holds a consistent but slim edge across all signals — "
+ "no single metric dominates, but small advantages in contrast, simplicity, "
+ "and color warmth compound into a measurable CPCi lead."
+ )
+
+ parts.append(reason)
+
+ # --- Use-case verdict
+ is_perf = use_case == "Performance Marketing"
+ is_brand = use_case == "FMCG Branding"
+ if is_perf:
+ parts.append(
+ f"For Performance Marketing, attention is the first conversion gate — "
+ f"{winner['name']} clears it; {runner_up['name']} risks the scroll-past before a click can happen."
+ )
+ elif is_brand:
+ parts.append(
+ f"For Brand Building, memory encoding determines whether this spend compounds over time — "
+ f"{winner['name']} encodes; {runner_up['name']} fades."
+ )
+ else:
+ parts.append(
+ f"Scale {winner['name']} first. Test {runner_up['name']} only after fixing its weakest signal."
+ )
+
+ return " ".join(parts)
+
+
+def show_comparison(sorted_results: list, use_case: str = "Performance Marketing", client_mode: bool = False) -> None:
+ """
+ A/B testing decision screen:
+ 1. Side-by-side creative cards — winner glows green
+ 2. "Why this wins" decisive summary
+ 3. Signal bar breakdown
+ 4. Per-creative score explanations + download
+ """
+ if client_mode:
+ _show_comparison_client(sorted_results, use_case)
+ return
+ winner = sorted_results[0]
+ n = len(sorted_results)
+
+ # ── Header ────────────────────────────────────────────────────────────────
+ st.markdown(
+ ""
+ f"
"
+ f"{name_html}"
+ f"
"
+ f"Cognitive Signal Engine™
"
+ "Creative Intelligence Analyzer
"
+ f"Comparing {n} Creatives — {use_case}
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Creative cards ────────────────────────────────────────────────────────
+ cols = st.columns(n, gap="small")
+ for i, (col, r) in enumerate(zip(cols, sorted_results)):
+ s = r["signals"]
+ cpci = r["cpci"]
+ is_win = (i == 0)
+ cc = "#22C55E" if cpci >= 70 else ("#F59E0B" if cpci >= 40 else "#EF4444")
+ card_cls = "ab-card-winner" if is_win else "ab-card"
+
+ # Rank label / winner badge
+ rank_html = (
+ "🏆 Winner
"
+ if is_win else
+ f"#{i+1}
"
+ )
+
+ # Signal colors
+ a_c = "#22C55E" if s["attention_score"] >= 65 else ("#F59E0B" if s["attention_score"] >= 35 else "#EF4444")
+ m_c = "#22C55E" if s["memory_score"] >= 65 else ("#F59E0B" if s["memory_score"] >= 40 else "#EF4444")
+ v = s["emotional_valence"]
+ v_c = "#22C55E" if v > 0.1 else ("#F59E0B" if v > -0.1 else "#EF4444")
+ cl = s["cognitive_load"]
+ l_c = "#22C55E" if cl == "Low" else ("#F59E0B" if cl == "Medium" else "#EF4444")
+
+ # Verdict
+ vdict_color = cc
+ vdict_txt = _final_verdict_text(cpci, s["attention_score"], s["memory_score"], v, cl, use_case)
+
+ # Image thumbnail
+ img_src = _img_b64(r.get("file_path", ""))
+ img_html = (
+ f"No preview
"
+ )
+
+ col.markdown(
+ f""
+ f"{rank_html}"
+ f"{img_html}"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # ── CPCi score bars ────────────────────────────────────────────────────────
+ max_cpci = sorted_results[0]["cpci"] if sorted_results[0]["cpci"] > 0 else 1
+ bars_html = ""
+ for r in sorted_results:
+ pct = int(r["cpci"] / max_cpci * 100)
+ bc = "#22C55E" if r["cpci"] >= 70 else ("#F59E0B" if r["cpci"] >= 40 else "#EF4444")
+ nm = short_name(r["name"], 18)
+ bars_html += (
+ f""
+ )
+
+ st.markdown(
+ f"{short_name(r['name'], 22)}
"
+ f"{cpci}
"
+ f"CPCi Score / 100
"
+ f""
+ f""
+ f""
+ f""
+ f""
+ f"
"
+ f"Attention
"
+ f"{s['attention_score']}
Memory
"
+ f"{s['memory_score']}
Valence
"
+ f"{v:+.2f}
Load
"
+ f"{cl}
"
+ f"{vdict_txt}
"
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Why this wins ─────────────────────────────────────────────────────────
+ runner_up = sorted_results[1] if n > 1 else sorted_results[0]
+ why_body = _why_wins(winner, runner_up, use_case)
+
+ st.markdown(
+ f"CPCi Score Comparison
"
+ f"{bars_html}"
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Per-creative detail ────────────────────────────────────────────────────
+ st.markdown("Why this wins
"
+ f"🏆 {winner['name']}
"
+ f"{why_body}
"
+ f"", unsafe_allow_html=True) + show_score_explanations(sorted_results) + + # ── Trust indicators (use winner's signals for confidence) ──────────────── + w_attn = winner["signals"]["attention_score"] + w_mem = winner["signals"]["memory_score"] + w_cpci = winner["cpci"] + if w_attn > 50 and w_mem > 50: + w_conf_level, w_conf_color = "High", "#22C55E" + elif w_attn < 30 and w_mem < 30: + w_conf_level, w_conf_color = "Low", "#EF4444" + elif abs(w_attn - w_mem) > 35 or (w_attn < 30 or w_mem < 30): + w_conf_level, w_conf_color = "Low", "#EF4444" + else: + w_conf_level, w_conf_color = "Medium", "#F59E0B" + _render_trust_indicators(w_cpci, w_attn, w_mem, w_conf_level, w_conf_color) + + # ── Download ────────────────────────────────────────────────────────────── + st.markdown("
", unsafe_allow_html=True) + export_all = [{k: v for k, v in r.items() if k not in ("reasoning", "file_path")} for r in sorted_results] + st.download_button( + "⬇️ Export Comparison Report", + json.dumps(export_all, indent=2), + "creative_comparison_report.json", + "application/json", + use_container_width=True, + ) + st.markdown( + "
" + "Powered by OpenCV · Tesseract OCR · Cognitive Signal Engine™ · " + "Color Psychology · CLT (Sweller) · Dual-Coding (Paivio)
", + unsafe_allow_html=True, + ) + + +def _final_verdict_text(cpci, attn, mem, val, cl, use_case) -> str: + """Return the verdict string only (used by both show_results and comparison cards).""" + attn_weak = attn < 45; mem_weak = mem < 50 + load_high = cl == "High"; val_neg = val < -0.05 + attn_str = attn >= 65; mem_str = mem >= 65 + is_perf = use_case == "Performance Marketing" + is_brand = use_case == "FMCG Branding" + if cpci >= 70: + if attn_str and mem_str: return "Ready to scale — strong on every signal." + if attn_str and mem_weak: return "Strong for attention, weak for recall — add retargeting." + if mem_str and attn_weak: return "Powerful recall, weak hook — fix opening frame." + if load_high: return "High scores, high clutter — simplify before scaling." + return "Ready to scale — above threshold on all signals." + elif cpci >= 55: + if attn_weak and not mem_weak: return "Strong recall, weak acquisition — not cold-audience ready." + if mem_weak and not attn_weak: return "Stops the scroll but won't be remembered." + if load_high: return "High potential — strip cognitive load first." + if val_neg and is_brand: return "Brand risk — emotional tone must improve before spend." + return "High potential — optimize attention before scaling." + elif cpci >= 40: + if attn_weak and mem_weak: return "NOT ready for scale." + if load_high and attn_weak: return "Too cluttered to convert — rebuild." + if val_neg: return "Negative signal — will hurt brand at scale." + if is_perf and mem_weak: return "Will not convert — memory encoding too weak." + return "Borderline — fix one signal before scaling." + else: + if val_neg and load_high: return "Do not run — will damage brand perception." + if attn < 25: return "NOT ready for scale — will be ignored." + if mem < 30: return "Forgettable at any spend level — rebuild." + return "NOT ready for scale." + + +MEDALS = ["🥇", "🥈", "🥉", "④", "⑤"] + +def show_comparison_table(results: list) -> None: + """ + Section 1: Comparison table — one row per creative, all key metrics side by side. + Sorted in upload order (not ranked — ranking is Section 2). + """ + st.markdown("", unsafe_allow_html=True) + st.markdown("
📊 Side-by-Side Comparison
", unsafe_allow_html=True)
+
+ # Header row
+ cols = st.columns([2.5, 1, 1, 1, 1.2, 1.2])
+ headers = ["Creative", "Attention", "Memory", "Valence", "Cog. Load", "CPCi (Cognitive Impact)"]
+ for col, h in zip(cols, headers):
+ col.markdown(f"{h}
", unsafe_allow_html=True)
+
+ # Data rows
+ for i, r in enumerate(results):
+ s = r["signals"]
+ bg = "#141B24" if i % 2 == 0 else "#141B24"
+ cols = st.columns([2.5, 1, 1, 1, 1.2, 1.2])
+
+ # Creative name + color palette
+ swatch_html = color_swatches(r["visual_features"]["dominant_colors"])
+ cols[0].markdown(
+ f""
+ f"{short_name(r['name'])}
" + f"{swatch_html}
",
+ unsafe_allow_html=True,
+ )
+
+ # Attention
+ ac = "#22C55E" if s["attention_score"] >= 70 else ("#F59E0B" if s["attention_score"] >= 40 else "#EF4444")
+ cols[1].markdown(
+ f"" + f"{swatch_html}
"
+ f"{s['attention_score']}
", unsafe_allow_html=True,
+ )
+
+ # Memory
+ mc = "#22C55E" if s["memory_score"] >= 70 else ("#F59E0B" if s["memory_score"] >= 40 else "#EF4444")
+ cols[2].markdown(
+ f""
+ f"{s['memory_score']}
", unsafe_allow_html=True,
+ )
+
+ # Valence
+ val = s["emotional_valence"]
+ vc = "#22C55E" if val > 0.1 else ("#F59E0B" if val > -0.1 else "#EF4444")
+ cols[3].markdown(
+ f""
+ f"{val:+.2f}
", unsafe_allow_html=True,
+ )
+
+ # Cognitive load
+ cl = s["cognitive_load"]
+ cl_c = "#22C55E" if cl == "Low" else ("#F59E0B" if cl == "Medium" else "#EF4444")
+ cols[4].markdown(
+ f""
+ f"{cl}
", unsafe_allow_html=True,
+ )
+
+ # CPCi
+ cc = cpci_color(r["cpci"])
+ cols[5].markdown(
+ f""
+ f"{r['cpci']}
", unsafe_allow_html=True,
+ )
+
+
+def show_ranking(sorted_results: list) -> None:
+ """
+ Section 2: Ranked list sorted by CPCi descending.
+ Winner gets gold highlight + medal. Progress bars show relative CPCi.
+ """
+ st.markdown("", unsafe_allow_html=True) + st.markdown("
🏆 Performance Ranking
", unsafe_allow_html=True)
+
+ max_cpci = sorted_results[0]["cpci"] if sorted_results else 100
+
+ for i, r in enumerate(sorted_results):
+ medal = MEDALS[i] if i < len(MEDALS) else f"#{i+1}"
+ card_class = "rank-card rank-winner" if i == 0 else ("rank-card rank-second" if i == 1 else "rank-card")
+ cc = cpci_color(r["cpci"])
+ s = r["signals"]
+
+ st.markdown(f"""
+
+
""", unsafe_allow_html=True)
+
+ # Progress bar showing CPCi relative to the winner
+ bar_pct = r["cpci"] / max_cpci if max_cpci > 0 else 0
+ st.progress(bar_pct)
+
+
+def show_winner_explanation(sorted_results: list) -> None:
+ """
+ Section 3: Explain why the top creative beats each competitor, metric by metric.
+ Identifies specific weaknesses in each losing creative.
+ """
+ st.markdown("
+
+
+ {medal}
+ {r['name']}
+ {"Winner" if i == 0 else ""}
+
+ {r['cpci']}/100
+
+ 🎯 Attention: {s['attention_score']}
+ 🧠 Memory: {s['memory_score']}
+ ❤️ Valence: {s['emotional_valence']:+.2f}
+ ⚙️ Load: {s['cognitive_load']}
+
+ ", unsafe_allow_html=True) + st.markdown("
🧬 Why the Winner Wins
", unsafe_allow_html=True)
+
+ winner = sorted_results[0]
+ losers = sorted_results[1:]
+ ws = winner["signals"]
+ wvf = winner["visual_features"]
+ w_attn = ws["attention_score"]
+ w_mem = ws["memory_score"]
+ w_val = ws["emotional_valence"]
+ w_cl = ws["cognitive_load"]
+ w_cpci = winner["cpci"]
+
+ load_rank = {"Low": 0, "Medium": 1, "High": 2}
+
+ # Winner summary box
+ st.markdown(f"""
+
+
""", unsafe_allow_html=True)
+
+ # Per-competitor breakdown
+ for loser in losers:
+ ls = loser["signals"]
+ lvf = loser["visual_features"]
+ l_attn = ls["attention_score"]
+ l_mem = ls["memory_score"]
+ l_val = ls["emotional_valence"]
+ l_cl = ls["cognitive_load"]
+ l_cpci = loser["cpci"]
+ cpci_gap = round(w_cpci - l_cpci, 1)
+
+ # Build advantage list
+ advantages = []
+ weaknesses = []
+
+ if w_attn > l_attn + 5:
+ diff = w_attn - l_attn
+ advantages.append(
+ f"+{diff} pts Attention ({w_attn} vs {l_attn}) — "
+ + ("Winner has faces creating involuntary fixation. " if wvf["face_count"] > lvf["face_count"] else "")
+ + (f"Winner contrast {wvf['contrast_score']:.0f} vs {lvf['contrast_score']:.0f} — "
+ f"higher contrast stops the scroll. " if wvf["contrast_score"] > lvf["contrast_score"] + 10 else "")
+ + (f"Loser has {lvf['object_count']} objects vs {wvf['object_count']} — clutter fragments attention." if lvf["object_count"] > wvf["object_count"] + 2 else "")
+ )
+ elif l_attn > w_attn + 5:
+ weaknesses.append(f"Loser has +{l_attn - w_attn} pts higher attention ({l_attn} vs {w_attn}) but weaker on other metrics.")
+
+ if w_mem > l_mem + 5:
+ diff = w_mem - l_mem
+ advantages.append(
+ f"+{diff} pts Memory Encoding ({w_mem} vs {l_mem}) — "
+ + (f"Winner has {wvf['object_count']} objects vs {lvf['object_count']} — simpler composition encodes more cleanly. " if wvf["object_count"] < lvf["object_count"] else "")
+ + ("Winner text density is in optimal 5–25% range. " if 0.05 <= wvf["text_density"] <= 0.25 and not (0.05 <= lvf["text_density"] <= 0.25) else "")
+ + (f"Loser text density {lvf['text_density']*100:.0f}% overloads the verbal channel." if lvf["text_density"] > 0.25 else "")
+ )
+
+ if w_val > l_val + 0.1:
+ diff = round(w_val - l_val, 2)
+ advantages.append(
+ f"+{diff} Emotional Valence ({w_val:+.2f} vs {l_val:+.2f}) — "
+ + ("Winner has warmer color palette driving positive affect. " if w_val > 0 else "")
+ + ("Loser colors are dark/desaturated, encoding mild aversion. " if l_val < -0.05 else "")
+ + (f"Winner has {wvf['face_count']} face(s) adding affiliative warmth. " if wvf["face_count"] > lvf["face_count"] else "")
+ )
+
+ if load_rank[w_cl] < load_rank[l_cl]:
+ advantages.append(
+ f"Lower Cognitive Load ({w_cl} vs {l_cl}) — "
+ f"winner processes faster in scroll environments. "
+ f"Loser has {lvf['object_count']} objects + {lvf['text_density']*100:.0f}% text "
+ f"saturating working memory capacity."
+ )
+
+ # If winner leads on everything, add a clean sweep note
+ if not advantages:
+ advantages.append(
+ f"Narrow but consistent margin — winner outperforms by {cpci_gap} CPCi points "
+ f"across a combination of small improvements in contrast, simplicity, and color warmth."
+ )
+
+ adv_html = "".join(f"
+ 🥇 Winner
+
+ {winner['name']}
+
+ CPCi {w_cpci} —
+ Attention {w_attn} ·
+ Memory {w_mem} ·
+ Valence {w_val:+.2f} ·
+ Load {w_cl}
+
+
+ This creative wins because it delivers the highest cognitive impact (CPCi) —
+ meaning it is most likely to convert attention into memory and action.
+
+ Note: " + " ".join(weaknesses) + "" + if weaknesses else "" + ) + + st.markdown(f""" +
+ Winner vs {loser['name']}
+
+ Loser CPCi: {l_cpci} | Gap: -{cpci_gap}
+
+
""", unsafe_allow_html=True)
+
+ # Actionable summary
+ st.markdown("+
-
+ {adv_html}
+
", unsafe_allow_html=True) + export_all = [ + {k: v for k, v in r.items() if k != "reasoning"} + for r in sorted_results + ] + st.download_button( + "⬇️ Export Comparison Report", + json.dumps(export_all, indent=2), + "creative_comparison_report.json", + "application/json", + use_container_width=True, + ) + st.markdown( + "
" + "Powered by OpenCV · Tesseract OCR · Cognitive Signal Engine™ · " + "Color Psychology · Cognitive Load Theory (Sweller) · Dual-Coding Theory (Paivio)" + "
", + unsafe_allow_html=True, + ) + + +# ── Per-creative score explanation ─────────────────────────────────────────── + +def _hex_to_hsv(hex_color: str): + """Parse a hex color string to HSV tuple. Returns (h_degrees, s, v).""" + hex_color = hex_color.lstrip("#") + r, g, b = (int(hex_color[i:i+2], 16) / 255.0 for i in (0, 2, 4)) + h, s, v = colorsys.rgb_to_hsv(r, g, b) + return h * 360, s, v + + +def generate_score_explanation(r: dict) -> dict: + """ + Generate rule-based bullet point explanations for each metric score. + + Every bullet references a REAL detected value — no generic copy. + Returns a dict with keys: "attention", "memory", "valence", "load", + each mapping to a list of (icon, text) tuples. + + Icons: ✅ positive driver ⚠️ negative driver ➡️ neutral/moderate + """ + s = r["signals"] + vf = r["visual_features"] + obj_count = vf["object_count"] + face_count = vf["face_count"] + contrast = vf["contrast_score"] + text_dens = vf["text_density"] + colors = vf["dominant_colors"] + cl = s["cognitive_load"] + reasoning = r.get("reasoning") or {} + cl_score = ( + reasoning["load"]["composite"] + if isinstance(reasoning, dict) and "load" in reasoning + else s.get("cognitive_load_score", 50) + ) + + bullets = {"attention": [], "memory": [], "valence": [], "load": []} + + # ── ATTENTION ───────────────────────────────────────────────────────────── + + # Object clutter + if obj_count > 7: + penalty = min(30, (obj_count - 3) * 2) + bullets["attention"].append( + ("⚠️", f"{obj_count} objects detected — high visual clutter fragments attention " + f"(clutter penalty: -{penalty} pts; threshold is >7 objects)") + ) + elif obj_count <= 3: + bullets["attention"].append( + ("✅", f"{obj_count} object(s) — clean composition, full attentional focus on primary element") + ) + else: + bullets["attention"].append( + ("➡️", f"{obj_count} objects — moderate clutter, small attention penalty applied") + ) + + # Face presence + if face_count > 0: + boost = 22 if face_count == 1 else (36 if face_count == 2 else 44) + bullets["attention"].append( + ("✅", f"{face_count} human face(s) detected — faces trigger involuntary fixation " + f"via the fusiform face area (+{boost} pts attention boost)") + ) + else: + bullets["attention"].append( + ("⚠️", "No faces detected — missing the strongest natural attention trigger in ad creative. " + "Adding one face can add +22 pts to attention score") + ) + + # Contrast + if contrast < 40: + bullets["attention"].append( + ("⚠️", f"Contrast score {contrast:.0f}/100 — low contrast means the creative blends " + f"into the feed; pre-attentive pop is weak") + ) + elif contrast >= 70: + bullets["attention"].append( + ("✅", f"Contrast score {contrast:.0f}/100 — high contrast creates a pre-attentive " + f"visual pop that stops scrolling before conscious processing") + ) + else: + bullets["attention"].append( + ("➡️", f"Contrast score {contrast:.0f}/100 — adequate but not scroll-stopping; " + f"increasing to 70+ can meaningfully improve attention") + ) + + # ── MEMORY ──────────────────────────────────────────────────────────────── + + # Simplicity + if obj_count <= 4: + bullets["memory"].append( + ("✅", f"{obj_count} object(s) — simple composition gives the brain a clear primary " + f"element to bind into long-term memory (picture superiority effect)") + ) + elif obj_count > 7: + bullets["memory"].append( + ("⚠️", f"{obj_count} objects — too many competing elements fragment the hippocampal " + f"binding event; each extra object above 2 costs ~6 memory points") + ) + else: + bullets["memory"].append( + ("➡️", f"{obj_count} objects — acceptable complexity, but simplifying to ≤4 " + f"would improve memory encoding") + ) + + # Text density + td_pct = text_dens * 100 + if 0.05 <= text_dens <= 0.25: + bullets["memory"].append( + ("✅", f"Text coverage {td_pct:.1f}% — optimal zone (5–25%). " + f"Enough text to provide a verbal anchor for brand recall " + f"without overloading the visual channel (dual-coding theory)") + ) + elif text_dens < 0.05: + bullets["memory"].append( + ("⚠️", f"Text coverage {td_pct:.1f}% — too little text. " + f"Without a verbal anchor (tagline, brand name), " + f"memory relies entirely on the visual trace which fades faster") + ) + elif text_dens > 0.30: + bullets["memory"].append( + ("⚠️", f"Text coverage {td_pct:.1f}% — excess copy overwhelms the visual channel. " + f"Above 25% density, memory encoding declines as the brain " + f"shifts from image processing to slow serial text reading") + ) + else: + bullets["memory"].append( + ("➡️", f"Text coverage {td_pct:.1f}% — approaching overload zone (>25%). " + f"Trim copy to stay in the optimal range") + ) + + # ── EMOTIONAL VALENCE ───────────────────────────────────────────────────── + + # Face warmth + if face_count > 0: + face_boost = min(0.30, face_count * 0.25) + bullets["valence"].append( + ("✅", f"{face_count} face(s) — trigger affiliative warmth and emotional mirroring. " + f"Valence boost from faces: +{face_boost:.2f} " + f"(capped at +0.30 to prevent compounding)") + ) + else: + bullets["valence"].append( + ("⚠️", "No faces detected — faces are the strongest single valence driver. " + "Adding a person with visible emotion can shift valence by +0.20 to +0.30") + ) + + # Color temperature analysis + warm_found = [] + dark_found = [] + for hex_c in colors: + try: + h_deg, sat, val_hsv = _hex_to_hsv(hex_c) + if val_hsv < 0.20: + dark_found.append(hex_c) + elif sat > 0.30 and (h_deg < 70 or h_deg >= 345): + warm_found.append(hex_c) + except Exception: + pass + + if warm_found: + bullets["valence"].append( + ("✅", f"Warm tones in palette: {', '.join(warm_found[:2])} — " + f"red/orange/yellow hues sit in the high-arousal, positive-valence " + f"quadrant of Russell's circumplex model") + ) + else: + bullets["valence"].append( + ("➡️", "No dominant warm tones — palette is cool or neutral. " + "Cool colors (blue, grey) are emotionally safe but do not actively " + "drive positive valence or purchase intent") + ) + + if dark_found: + bullets["valence"].append( + ("⚠️", f"Dark colors present: {', '.join(dark_found[:2])} — " + f"HSV value < 20% encodes mild negative affect regardless of hue. " + f"Dark palettes reduce perceived warmth and energy") + ) + + # ── COGNITIVE LOAD ──────────────────────────────────────────────────────── + + high_obj = obj_count > 7 + high_text = text_dens > 0.30 + low_obj = obj_count <= 4 + low_text = text_dens < 0.10 + + if high_obj and high_text: + bullets["load"].append( + ("⚠️", f"{obj_count} objects AND {td_pct:.0f}% text — both the visual and " + f"linguistic processing channels are simultaneously overloaded. " + f"Working memory (Miller's 7±2 limit) will saturate; viewer disengages") + ) + elif high_obj: + bullets["load"].append( + ("⚠️", f"{obj_count} objects — visual channel overloaded (>7 exceeds Miller's 7±2 rule). " + f"Reduce to ≤7 objects to bring visual complexity into acceptable range") + ) + elif high_text: + bullets["load"].append( + ("⚠️", f"{td_pct:.0f}% text — linguistic channel overloaded (>30% density). " + f"Compress copy to one primary message; every extra word costs processing capacity") + ) + elif low_obj and low_text: + bullets["load"].append( + ("✅", f"{obj_count} objects + {td_pct:.0f}% text — both channels are well within " + f"processing capacity. Effortless comprehension; ideal for mobile scroll environments") + ) + else: + bullets["load"].append( + ("➡️", f"{obj_count} objects + {td_pct:.0f}% text — moderate load, " + f"acceptable for most placements but may reduce performance in " + f"passive scroll contexts (Reels, TikTok)") + ) + + icon = "✅" if cl == "Low" else ("➡️" if cl == "Medium" else "⚠️") + bullets["load"].append( + (icon, f"Composite load score: {cl_score:.0f}/100 → classified as {cl} load") + ) + + return bullets + + +def show_score_explanations(results: list) -> None: + """ + Render 'Why this score?' bullet points for each creative as collapsible expanders. + Each expander shows 4 metric sections with real-value bullet points. + """ + st.markdown("", unsafe_allow_html=True) + st.markdown( + "
📝 Why Each Creative Scored This Way
",
+ unsafe_allow_html=True,
+ )
+ st.markdown(
+ "" + "Click any creative to expand its full score explanation — every bullet " + "references an actual detected value.
", + unsafe_allow_html=True, + ) + + METRIC_CONFIG = [ + ("attention", "🎯 Attention Score", "#3B82F6"), + ("memory", "🧠 Memory Encoding", "#22C55E"), + ("valence", "❤️ Emotional Valence", "#CBD5E1"), + ("load", "⚙️ Cognitive Load", "#F59E0B"), + ] + + ICON_COLOR = {"✅": "#22C55E", "⚠️": "#EF4444", "➡️": "#F59E0B"} + + for r in results: + s = r["signals"] + cpci_val = r["cpci"] + label = ( + "Strong Performer" if cpci_val >= 70 + else ("Average Performer" if cpci_val >= 45 else "Needs Improvement") + ) + cc = cpci_color(cpci_val) + + expander_title = ( + f"{r['name']} — CPCi {cpci_val} | " + f"Attn {s['attention_score']} | Mem {s['memory_score']} | " + f"Val {s['emotional_valence']:+.2f} | Load {s['cognitive_load']}" + ) + + with st.expander(expander_title, expanded=False): + explanation = generate_score_explanation(r) + + # Two-column grid: left = Attention + Memory, right = Valence + Load + left_col, right_col = st.columns(2) + + for col, keys in [(left_col, ["attention", "memory"]), + (right_col, ["valence", "load"])]: + with col: + for key, title, accent in METRIC_CONFIG: + if key not in keys: + continue + score_val = ( + s["attention_score"] if key == "attention" + else s["memory_score"] if key == "memory" + else s["emotional_valence"] if key == "valence" + else s["cognitive_load"] + ) + score_str = ( + f"{score_val}/100" if key in ("attention", "memory") + else f"{score_val:+.3f}" if key == "valence" + else str(score_val) + ) + + st.markdown( + f""
+ f"{title} {score_str}
",
+ unsafe_allow_html=True,
+ )
+
+ for icon, text in explanation[key]:
+ icon_color = ICON_COLOR.get(icon, "#FFFFFF")
+ st.markdown(
+ f""
+ f"{icon}"
+ f"{text}
",
+ unsafe_allow_html=True,
+ )
+
+
+# ── Main UI ───────────────────────────────────────────────────────────────────
+
+# ── Landing screen ────────────────────────────────────────────────────────────
+if "app_entered" not in st.session_state:
+ st.session_state["app_entered"] = False
+
+if not st.session_state["app_entered"]:
+ st.markdown("""
+
+
+
+
+
+ """, unsafe_allow_html=True)
+
+ # ── Scientific Foundation panel (separate call — avoids Streamlit style-block issue) ──
+ st.markdown(
+ "
+ Cognitive Signal
Engine™ +
+
+ Engine™ +
Creative Intelligence Analyzer
+
+
+ Measure how creatives perform in the brain
— before media spend. +
+
+
+
+ — before media spend. +
+
+
+
+
+ Pre-bid creative scoring
+
+
+
+ Reduce wasted media spend
+
+
+
+ Faster creative decisions
+ "
+ "" # end border card
+ "
", # end max-width wrapper
+ unsafe_allow_html=True,
+ )
+
+ _lnd_gap, _lnd_cta, _lnd_demo, _lnd_gap2 = st.columns([3, 2, 2, 3], gap="small")
+
+ with _lnd_cta:
+ if st.button("Start Analysis", type="primary", use_container_width=True):
+ st.session_state["app_entered"] = True
+ st.rerun()
+
+ with _lnd_demo:
+ if st.button("View Demo", use_container_width=True):
+ st.session_state["app_entered"] = True
+ st.session_state["demo_mode"] = True
+ st.rerun()
+
+ st.markdown(
+ ""
+ "
",
+ unsafe_allow_html=True,
+ )
+ st.stop()
+
+_BRAIN_SVG = (
+ ""
+)
+# ── App header ───────────────────────────────────────────────────────────────
+_hdr_left, _hdr_right = st.columns([3, 2], gap="large")
+
+with _hdr_left:
+ st.markdown(
+ ""
+ "Cognitive Signal Engine™
"
+ "Creative Intelligence Analyzer
"
+ ""
+ "© Anil Pandit · ADVantage Insights"
+ "
"
+ ""
+ "
",
+ unsafe_allow_html=True,
+ )
+
+with _hdr_right:
+ # Guard: if demo mode exit was requested programmatically (from inside _render_demo_mode),
+ # apply it HERE — before any widget with key="demo_mode" is instantiated, so Streamlit
+ # doesn't raise StreamlitAPIException about modifying widget-bound state.
+ if st.session_state.pop("_exit_demo", False):
+ st.session_state["demo_mode"] = False
+ st.session_state["demo_step"] = 1
+ st.session_state["demo_creative"] = 0
+
+ st.markdown(""
+ "
"
+ ""
+ "
"
+ ""
+ "Cognitive Signal Engine™
"
+ "Creative Intelligence Analyzer
"
+ "", unsafe_allow_html=True)
+ _tog_a, _tog_b = st.columns(2, gap="small")
+ with _tog_a:
+ _expert_on = st.toggle(
+ "Expert Mode",
+ value=st.session_state.get("expert_mode", False),
+ key="expert_mode",
+ )
+ with _tog_b:
+ _demo_on = st.toggle(
+ "Demo Mode",
+ value=st.session_state.get("demo_mode", False),
+ key="demo_mode",
+ )
+ st.markdown("
", unsafe_allow_html=True)
+
+st.markdown(
+ "", + unsafe_allow_html=True, +) + +# ── Top-level tabs ──────────────────────────────────────────────────────────── +tab_analyzer, tab_science, tab_glossary = st.tabs([ + "🔬 Analyzer", + "🧠 Science & Methodology", + "📖 Glossary", +]) + +with tab_science: + show_science_tab() + +with tab_glossary: + show_glossary_tab() + +with tab_analyzer: + # ── Framework ───────────────────────────────────────────────────────────── + with st.expander("📐 Framework", expanded=False): + fw_left, fw_right = st.columns([3, 2], gap="large") + + with fw_left: + st.markdown( + "
"
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ with fw_right:
+ st.markdown(
+ ""
+ "Cognitive Signal Engine (CSE)
"
+
+ ""
+ "This system is built on the Cognitive Signal Engine — "
+ "a proprietary framework that models how advertising stimuli are processed "
+ "across four dimensions:"
+ "
"
+
+ ""
+
+ "
"
+
+ ""
+ "01"
+ "
"
+
+ "Attention"
+ " · Does it get noticed?
"
+ ""
+ "02"
+ "
"
+
+ "Memory"
+ " · Is it encoded?
"
+ ""
+ "03"
+ "
"
+
+ "Emotion"
+ " · Does it create affinity?
"
+ ""
+ "04"
+ "
"
+
+ "Cognitive Load"
+ " · Is it easy to process?
"
+ ""
+ "These signals are combined into "
+ "CPCi — a unified measure of "
+ "cognitive effectiveness before media spend."
+ "
"
+ ""
+
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(""
+ "Signal Architecture
"
+
+ ""
+
+ "
"
+ ""
+ "Layer"
+ "Source"
+ "
"
+
+ ""
+ "Attention"
+ "Contrast · Face · Clutter"
+ "
"
+
+ ""
+ "Memory"
+ "Composition · Text density"
+ "
"
+
+ ""
+ "Emotion"
+ "Colour · Face warmth"
+ "
"
+
+ ""
+ "Cognitive Load"
+ "Objects · Entropy · Text %"
+ "
"
+
+ ""
+ "
"
+
+ "Output
"
+ "CPCi Score
"
+ ""
+ "Weighted composite · 0–100 · Use-case calibrated
"
+ "", unsafe_allow_html=True) + + # ── Why CPCi? ───────────────────────────────────────────────────────────── + with st.expander("⚡ Why CPCi?", expanded=False): + st.markdown( + "
"
+
+ # — Full form + one-liner ——————————————————————————————————————————
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(""
+ "CPCi"
+ " · "
+ "Cost Per Cognitive Impression"
+ "
"
+
+ # — The contrast argument ——————————————————————————————————————————
+ ""
+ "A single, pre-spend measure of how effectively an ad creative engages "
+ "the human brain — across attention, memory, emotion, and processing ease."
+ "
"
+ ""
+
+ "
"
+
+ # — Benchmark rationale ————————————————————————————————————————————
+ ""
+ "
"
+
+ ""
+ "Traditional metrics
"
+ ""
+ "CTR, CVR, ROAS — measured after exposure.
" + "They tell you what happened. They do not tell you why.
" + "By the time you have the data, budget has already been spent on creative " + "that failed at the first cognitive gate." + "
"
+ "" + "They tell you what happened. They do not tell you why.
" + "By the time you have the data, budget has already been spent on creative " + "that failed at the first cognitive gate." + "
"
+ "
"
+
+ ""
+ "CPCi
"
+ ""
+ "Measured before exposure — at the visual signal layer.
" + "Models what happens in the first 1–3 seconds: does the brain notice, " + "encode, and respond positively?
" + "Evaluate creative effectiveness before media spend. " + "Kill weak creatives before they consume budget." + "
"
+ "" + "Models what happens in the first 1–3 seconds: does the brain notice, " + "encode, and respond positively?
" + "Evaluate creative effectiveness before media spend. " + "Kill weak creatives before they consume budget." + "
"
+ "
"
+
+ ""
+ "How the benchmarks were set
"
+
+ ""
+
+ "
"
+ ""
+ "
"
+
+ "70+
"
+ ""
+ "Scale-ready
"
+ ""
+ "All three signals (attention, memory, emotion) clear their individual "
+ "thresholds. Cognitive Load Theory suggests low-load creative at these "
+ "levels is processed fluently — the necessary precondition for action."
+ "
"
+ ""
+ "
"
+
+ "40–69
"
+ ""
+ "Optimise first
"
+ ""
+ "Mixed signal profile — at least one dimension is below the encoding "
+ "floor. Paivio's Dual-Coding research indicates partial encoding leads "
+ "to poor recall and weak brand linkage over time."
+ "
"
+ ""
+ "
"
+
+ "<40
"
+ ""
+ "Do not scale
"
+ ""
+ "Insufficient cognitive engagement. Consistent with attention research "
+ "showing creatives below contrast and salience minimums are processed "
+ "at near-zero depth — spend is wasted before the message lands."
+ "
"
+ "", unsafe_allow_html=True) + + # ── What is CPCi? ───────────────────────────────────────────────────────── + with st.expander("💡 What is CPCi? — Click to learn how scoring works", expanded=False): + col_a, col_b, col_c, col_d = st.columns(4) + col_a.markdown(""" +
+
""", unsafe_allow_html=True)
+ col_b.markdown("""
+ What is CPCi?
+
+ CPCi is produced by the Cognitive Signal Engine —
+ a system that models how advertising creative is processed by the human brain,
+ before any click or conversion occurs.
+ Higher CPCi = stronger cognitive processing = better media efficiency. +
+ + Higher CPCi = stronger cognitive processing = better media efficiency. +
+
""", unsafe_allow_html=True)
+ col_c.markdown("""
+ 🎯
+ Attention
+
+ Does it stop the scroll?
+ Driven by visual contrast, face presence, and how clean or cluttered the image is. +
+ + Driven by visual contrast, face presence, and how clean or cluttered the image is. +
+
""", unsafe_allow_html=True)
+ col_d.markdown("""
+ 🧠
+ Memory
+
+ Will the brand be remembered?
+ Simple compositions and balanced text leave a stronger memory trace. +
+ + Simple compositions and balanced text leave a stronger memory trace. +
+
""", unsafe_allow_html=True)
+ st.markdown("""
+ ❤️
+ Emotional Valence
+
+ Does it create a positive response?
+ Warm colours and human faces drive positive valence. +
+ + Warm colours and human faces drive positive valence. +
+ How weights work:
+ CPCi formula is adjusted per use case — brand campaign prioritises memory,
+ performance campaign prioritises attention. See the 🧠 Science tab for the full formula.
+
""", unsafe_allow_html=True)
+
+ # ── Resolve mode flags from header toggles ───────────────────────────────
+ client_mode = not st.session_state.get("expert_mode", False)
+ demo_mode = st.session_state.get("demo_mode", False)
+
+ st.markdown("", unsafe_allow_html=True) + + # ── Use-case selector ───────────────────────────────────────────────────── + uc_col, info_col = st.columns([1, 2]) + with uc_col: + selected_uc = st.selectbox( + "🎯 Select Use Case", + options=list(USE_CASES.keys()), + index=1, + help="Changes CPCi weights to match your campaign objective", + ) + uc_cfg = USE_CASES[selected_uc] + uc_weights = uc_cfg["weights"] + with info_col: + w = uc_weights + penalty_note = " · Load Penalty Active" if uc_cfg["load_penalty"] else "" + st.markdown( + f"
"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(""
+ f"{uc_cfg['icon']} {selected_uc}"
+ f"{uc_cfg['description']}
"
+ f""
+ f"Weights: "
+ f"Attention {int(w['attention']*100)}% · "
+ f"Memory {int(w['memory']*100)}% · "
+ f"Emotion {int(w['emotion']*100)}%"
+ f"{penalty_note}
"
+ f""
+ f"{uc_cfg['rationale']}
", unsafe_allow_html=True) + + # ── Demo Mode — full guided walkthrough experience ──────────────────────── + if demo_mode: + _render_demo_mode(client_mode) + st.stop() + + # ── CTA "Analyze Your Creative" — clear cached results and scroll up ──── + if st.session_state.pop("_cta_new_analysis", False): + for _k in ("cached_results", "analyzed_files", "all_results", "elapsed"): + st.session_state.pop(_k, None) + st.toast("Upload a new creative below ↓", icon="🧠") + + # ── File uploader ───────────────────────────────────────────────────────── + uploaded_files = st.file_uploader( + "📁 Upload ad creatives — Images (JPG, PNG) or Videos (MP4, MOV, AVI, WEBM) · 1 file for analysis, 2–5 for comparison", + type=["jpg", "jpeg", "png", "mp4", "mov", "avi", "webm", "m4v"], + accept_multiple_files=True, + ) + + if uploaded_files: + n = len(uploaded_files) + if n > 5: + st.error("⚠️ Maximum 5 creatives at once. Please remove some files and try again.") + st.stop() + + st.markdown( + f"
"
+ f"{'1 creative — full analysis mode' if n == 1 else f'{n} creatives — comparison mode'}"
+ f" · {uc_cfg['icon']} {selected_uc}"
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ _VIDEO_EXTS_UI = {".mp4", ".mov", ".avi", ".webm", ".m4v"}
+ thumb_cols = st.columns(min(n, 5))
+ for col, uf in zip(thumb_cols, uploaded_files):
+ ext = os.path.splitext(uf.name)[1].lower()
+ if ext in _VIDEO_EXTS_UI:
+ col.video(uf)
+ col.caption(f"🎬 {short_name(uf.name, 22)}")
+ else:
+ col.image(uf, caption=short_name(uf.name, 22), use_container_width=True)
+
+ st.markdown("", unsafe_allow_html=True) + _has_video = any( + os.path.splitext(uf.name)[1].lower() in _VIDEO_EXTS_UI + for uf in uploaded_files + ) + _est_low = n * 3 if _has_video else n + _est_high = n * 8 if _has_video else n * 2 + analyze_btn = st.button( + f"🔬 {'Analyze Creative' if n == 1 else f'Compare {n} Creatives'} [{selected_uc}]", + type="primary", + use_container_width=True, + ) + st.markdown( + f"
" + f"~{_est_low}–{_est_high}s · No GPU · Attn {int(uc_weights['attention']*100)}% · " + f"Mem {int(uc_weights['memory']*100)}% · " + f"Emo {int(uc_weights['emotion']*100)}%" + f"{' · 🎬 Video: 6-frame sampling' if _has_video else ''}
", + unsafe_allow_html=True, + ) + + # ── Restore cached results ──────────────────────────────────────────── + cached_names = st.session_state.get("analyzed_files", []) + cached_uc = st.session_state.get("analyzed_uc", "") + current_names = [uf.name for uf in uploaded_files] + cache_valid = ( + "all_results" in st.session_state + and cached_names == current_names + and cached_uc == selected_uc + ) + if cache_valid: + cached = st.session_state["all_results"] + cached_sorted = sorted(cached, key=lambda x: x["cpci"], reverse=True) + if n == 1: + show_results(cached[0], st.session_state.get("elapsed"), selected_uc, client_mode) + else: + show_comparison(cached_sorted, selected_uc, client_mode) + + # ── Run analysis ────────────────────────────────────────────────────── + if analyze_btn: + all_results = [] + t0 = time.time() + progress_bar = st.progress(0, text="Starting analysis…") + for i, uf in enumerate(uploaded_files): + progress_bar.progress( + i / n, + text=f"Analyzing {uf.name} ({i+1}/{n})…", + ) + with st.spinner(f"🔬 Processing {short_name(uf.name)}…"): + result = run_pipeline( + uf, + weights=uc_weights, + apply_load_penalty=uc_cfg["load_penalty"], + use_case=selected_uc, + ) + all_results.append(result) + + progress_bar.progress(1.0, text="✅ All creatives analyzed.") + elapsed = time.time() - t0 + st.session_state["all_results"] = all_results + st.session_state["analyzed_files"] = [uf.name for uf in uploaded_files] + st.session_state["analyzed_uc"] = selected_uc + st.session_state["elapsed"] = elapsed + st.markdown( + f"⚡ {n} creative{'s' if n > 1 else ''} analyzed "
+ f"in {elapsed:.2f}s · {uc_cfg['icon']} {selected_uc}
",
+ unsafe_allow_html=True,
+ )
+ if n == 1:
+ show_results(all_results[0], elapsed, selected_uc, client_mode)
+ else:
+ sorted_results = sorted(all_results, key=lambda x: x["cpci"], reverse=True)
+ show_comparison(sorted_results, selected_uc, client_mode)
+
+
+# ── Global footer (visible on all tabs) ───────────────────────────────────────
+_FOOTER_SVG = (
+ ""
+)
+st.markdown(
+ f""
+ f"
",
+ unsafe_allow_html=True,
+)
diff --git a/science_tab.py b/science_tab.py
new file mode 100644
index 0000000..905f524
--- /dev/null
+++ b/science_tab.py
@@ -0,0 +1,984 @@
+"""
+science_tab.py
+--------------
+Renders two tabs:
+ - 🧠 Science & Methodology
+ - 📖 Glossary
+
+Content is drawn from:
+ - TRIBE v2 paper (Meta FAIR, d'Ascoli et al. 2025)
+ - Cognitive science literature cited in the pipeline
+ - CPCi methodology developed for this tool
+
+All content is pointer-style (no big paragraphs).
+"""
+
+import streamlit as st
+
+
+# ── Shared CSS ────────────────────────────────────────────────────────────────
+
+SCI_CSS = """
+
+"""
+
+
+def _ptr(arrow_color: str, bold: str, rest: str = "") -> str:
+ """Single pointer row HTML."""
+ return (
+ f""
+
+ # Left — logo + name
+ f"
"
+ f""
+ f"
"
+
+ # Centre — single clean line
+ f"{_FOOTER_SVG}
"
+ f""
+ f"
"
+ f"Cognitive Signal Engine™
"
+ f"Creative Intelligence Analyzer
"
+ f""
+ f"© Anil Pandit · ADVantage Insights · CPCi — Cost Per Cognitive Impression"
+ f"
"
+
+ # Right — tagline only
+ f""
+ f"Neuroscience → Cognitive signals → Media decisions."
+ f"
"
+
+ f""
+ f"→"
+ f"{bold}{' ' + rest if rest else ''}"
+ f"
"
+ )
+
+
+def _block(title: str, accent: str, content: str) -> str:
+ return (
+ f""
+ f"
"
+ )
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# TAB 1 — Science & Methodology
+# ══════════════════════════════════════════════════════════════════════════════
+
+def show_science_tab() -> None:
+ st.markdown(SCI_CSS, unsafe_allow_html=True)
+
+ st.markdown(
+ "{title}
"
+ f"{content}"
+ f"The Research Foundation
"
+ ""
+ "TRIBE v2 × Creative Intelligence
"
+ ""
+ "How a Meta brain-encoding model became the science behind your ad scores
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Key stats bar ─────────────────────────────────────────────────────────
+ s1, s2, s3, s4, s5 = st.columns(5)
+ for col, big, label, color in [
+ (s1, "720", "fMRI Subjects", "#40c4ff"),
+ (s2, "1,117h", "Brain Scan Hours", "#00e676"),
+ (s3, "20,484", "Cortical Vertices", "#ffb300"),
+ (s4, "#1", "Algonauts 2025 Rank", "#ffd700"),
+ (s5, "263", "Competing Teams", "#ff80ab"),
+ ]:
+ col.markdown(
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown("{big}
"
+ f"{label}
"
+ f"", + unsafe_allow_html=True) + + # ── Section A: What is TRIBE v2 ─────────────────────────────────────────── + st.markdown( + "
A · What Is TRIBE v2
",
+ unsafe_allow_html=True,
+ )
+
+ col_l, col_r = st.columns([3, 2])
+
+ with col_l:
+ st.markdown(_block("The Model", "#40c4ff",
+ _ptr("#40c4ff", "Full name:", "Tri-modal Brain Imaging Encoding model v2") +
+ _ptr("#40c4ff", "Origin:", "Meta FAIR (Fundamental AI Research), 2025") +
+ _ptr("#40c4ff", "Authors:", "d'Ascoli, Rapin, Benchetrit, King et al.") +
+ _ptr("#40c4ff", "Paper:", "\"A foundation model of vision, audition, and language for in-silico neuroscience\"") +
+ _ptr("#40c4ff", "Type:", "Tri-modal transformer encoder — processes video + audio + text simultaneously")
+ ), unsafe_allow_html=True)
+
+ st.markdown(_block("What It Does", "#00e676",
+ _ptr("#00e676", "Core task:", "Predict human brain activity (fMRI) from any audio, visual, or language stimulus") +
+ _ptr("#00e676", "Input modalities:", "Video (V-JEPA embeddings) · Audio (W2V-BERT embeddings) · Text (LLaMA embeddings)") +
+ _ptr("#00e676", "Output:", "BOLD signal across 20,484 cortical + 8,802 subcortical brain locations") +
+ _ptr("#00e676", "Key innovation:", "One model — all stimuli types, all brain regions, zero-shot generalisation to new subjects")
+ ), unsafe_allow_html=True)
+
+ with col_r:
+ st.markdown(_block("Training Scale", "#ffb300",
+ _ptr("#ffb300", "Subjects:", "720 healthy volunteers") +
+ _ptr("#ffb300", "Sessions:", "5,094 scan sessions") +
+ _ptr("#ffb300", "fMRI hours:", "1,117 hours of brain recordings") +
+ _ptr("#ffb300", "Video:", "121 hours of stimulus video") +
+ _ptr("#ffb300", "Audio:", "142 hours of stimulus audio") +
+ _ptr("#ffb300", "Text sentences:", "71,000 transcribed sentences") +
+ _ptr("#ffb300", "Training GPU:", "128 × V100 GPUs for feature extraction")
+ ), unsafe_allow_html=True)
+
+ st.markdown(
+ ""
+ "\"By aligning the representations of AI systems to those of the human brain, "
+ "we demonstrate that a single architecture can integrate a vast range "
+ "of fMRI responses… moving from the fragmented mapping of isolated cognitive tasks "
+ "toward a unified, predictive foundation model.\""
+ "
— d'Ascoli et al., Meta FAIR 2025" + "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Section B: How Brain Encoding Connects to Ads ─────────────────────────
+ st.markdown("— d'Ascoli et al., Meta FAIR 2025" + "
", + unsafe_allow_html=True) + st.markdown( + "
B · From Brain Science to Ad Intelligence
",
+ unsafe_allow_html=True,
+ )
+
+ # Pipeline steps
+ st.markdown(
+ "How your ad image becomes a CPCi score:
",
+ unsafe_allow_html=True,
+ )
+ st.markdown("""
+
+
""", unsafe_allow_html=True)
+
+ b1, b2, b3 = st.columns(3)
+
+ with b1:
+ st.markdown(_block("Step 1 — Visual Feature Extraction", "#40c4ff",
+ _ptr("#40c4ff", "Tool:", "OpenCV + Tesseract OCR") +
+ _ptr("#40c4ff", "Object count:", "Canny edge detection + contour analysis") +
+ _ptr("#40c4ff", "Face detection:", "Haar Cascade classifier (< 200ms)") +
+ _ptr("#40c4ff", "Text density:", "Tesseract PSM 11 sparse-text mode") +
+ _ptr("#40c4ff", "Contrast:", "Std deviation of grayscale pixel values") +
+ _ptr("#40c4ff", "Colours:", "K-means clustering (k=3) on 100×100 downsample") +
+ _ptr("#40c4ff", "Speed:", "< 2 seconds total · No GPU required")
+ ), unsafe_allow_html=True)
+
+ with b2:
+ st.markdown(_block("Step 2 — Cognitive Signal Mapping", "#ff80ab",
+ _ptr("#ff80ab", "Attention:", "Contrast × 0.5 + Face boost + Clutter penalty") +
+ _ptr("#ff80ab", "Memory:", "Simplicity score + Dual-coding text factor") +
+ _ptr("#ff80ab", "Valence:", "HSV colour psychology + Face warmth component") +
+ _ptr("#ff80ab", "Cog. Load:", "Object count + text density composite (Low / Medium / High)") +
+ _ptr("#ff80ab", "TRIBE basis:", "Signal thresholds calibrated against TRIBE v2 visual cortex encoding patterns") +
+ _ptr("#ff80ab", "Transparency:", "All thresholds named as constants — no black box")
+ ), unsafe_allow_html=True)
+
+ with b3:
+ st.markdown(_block("Step 3 — CPCi Computation", "#ffb300",
+ _ptr("#ffb300", "Formula:", "w_attn × Attention + w_mem × Memory + w_emo × Valence_norm") +
+ _ptr("#ffb300", "Valence norm:", "(Valence + 1) / 2 × 100 → maps −1/+1 to 0/100 scale") +
+ _ptr("#ffb300", "Load penalty:", "−0 / −5 / −12 for Low / Medium / High (Retail Media only)") +
+ _ptr("#ffb300", "Use-case weights:", "FMCG: 20/50/30 · Performance: 50/30/20 · Retail: 40/30/30") +
+ _ptr("#ffb300", "Score range:", "0 → 100 · < 40 weak · 40–70 average · > 70 strong") +
+ _ptr("#ffb300", "Clamp:", "max(0, min(100, raw)) — never negative or over 100")
+ ), unsafe_allow_html=True)
+
+ # ── Section B2: From Brain Science to Business Decisions ──────────────────
+ st.markdown("📁 UploadJPG / PNG
+ →
+ 👁 VisionOpenCV scan
+ →
+ 🧬 SignalsCognitive map
+ →
+ 🧠 TRIBEBrain basis
+ →
+ 📊 CPCiWeighted score
+ →
+ 📝 ReportStrategy
+ ", + unsafe_allow_html=True) + st.markdown( + "
B2 · Architecture
"
+ ""
+ "From Brain Science to Business Decisions
"
+ ""
+ "Two layers — one system. TRIBE v2 predicts brain activation. "
+ "CPCi converts those signals into a single business-ready score.
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Two-layer architecture diagram ───────────────────────────────────────
+ lay_l, lay_mid, lay_r = st.columns([5, 1, 5])
+
+ with lay_l:
+ st.markdown(
+ ""
+ # Badge
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ with lay_mid:
+ st.markdown(
+ ""
+ "
"
+ # Role
+ "LAYER 1
"
+ "TRIBE v2
"
+ ""
+ "Brain activation prediction model trained on 720 subjects and 1,117 hours of fMRI scans. "
+ "Given any visual, audio, or language stimulus, TRIBE v2 predicts which brain regions fire "
+ "— and at what intensity."
+ "
"
+ # Pointer list
+ + _ptr("#3B82F6", "Input:", "Ad creative (image, video, or text)")
+ + _ptr("#3B82F6", "Process:", "Tri-modal transformer — V-JEPA · W2V-BERT · LLaMA")
+ + _ptr("#3B82F6", "Output:", "Predicted BOLD activation across 20,484 cortical vertices")
+ + _ptr("#3B82F6", "Key regions:", "V1–V7 visual cortex · FaceBody area · Language areas · Limbic")
+ + _ptr("#3B82F6", "Performance:", "#1 Algonauts 2025 benchmark — 263 competing teams")
+ +
+ ""
+ "What it tells us: "
+ "Which features of a creative cause the human brain to activate — "
+ "contrast, faces, text, emotional tone — and by how much."
+ "
"
+ ""
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ with lay_r:
+ st.markdown(
+ "→
"
+ "converts to
"
+ ""
+ # Badge
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Tagline callout ───────────────────────────────────────────────────────
+ st.markdown(
+ ""
+ "
"
+ # Role
+ "LAYER 2
"
+ "CPCi
"
+ "Cost Per Cognitive Impression
"
+ ""
+ "CPCi takes TRIBE v2's brain-region activation patterns and converts them into four "
+ "measurable signals — each one a direct media performance lever."
+ "
"
+ # Signal pills with contribution arrows
+ ""
+
+ # Attention
+ "
"
+ ""
+ "
"
+
+ # Memory
+ ""
+ "Attention
"
+ ""
+ "Visual cortex activation → stopping power in feed
"
+ ""
+ "
"
+
+ # Emotion
+ ""
+ "Memory
"
+ ""
+ "Language area activity → brand recall after exposure
"
+ ""
+ "
"
+
+ # Load
+ ""
+ "Emotion
"
+ ""
+ "Limbic/subcortical response → valence and purchase intent
"
+ ""
+ "
"
+
+ # Business score callout
+ ""
+ "Load
"
+ ""
+ "Working memory saturation → processing penalty
"
+ ""
+ "
"
+
+ ""
+ "
"
+ ""
+ "Business
Score
"
+ "Score
"
+ "CPCi 0–100
" + "Weighted composite · Use-case calibrated
" + "Single number a CMO can act on" + "
"
+ "" + "Weighted composite · Use-case calibrated
" + "Single number a CMO can act on" + "
"
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Section C: The Brain Regions That Matter for Ads ──────────────────────
+ st.markdown(""
+ "This system translates neuroscience into actionable media decisions."
+ "
"
+ ""
+ "TRIBE v2 answers: which brain regions respond to this creative? · "
+ "CPCi answers: should you spend media budget on it?"
+ "
"
+ "", + unsafe_allow_html=True) + st.markdown( + "
C · Brain Regions That Drive Ad Response
",
+ unsafe_allow_html=True,
+ )
+
+ c1, c2, c3, c4 = st.columns(4)
+ for col, region, role, signals, color in [
+ (c1, "V1 – V7\nVisual Cortex",
+ "Primary visual processing — contrast, edges, motion",
+ "→ Contrast score\n→ Object detection\n→ Attention score", "#40c4ff"),
+ (c2, "FaceBody Area\n(Lateral Cortex)",
+ "Face and body detection — activates in < 13ms, involuntary",
+ "→ Face count\n→ Attention boost\n→ Valence warmth", "#ff80ab"),
+ (c3, "Language Areas\n(Left Hemisphere)",
+ "Text and verbal processing — competes with visual memory trace",
+ "→ Text density\n→ Memory encoding\n→ Cognitive load", "#ffb300"),
+ (c4, "Limbic / Emotional\n(Subcortical)",
+ "Colour, arousal, reward — determines whether content is engaging",
+ "→ Emotional valence\n→ Colour psychology\n→ Purchase intent", "#00e676"),
+ ]:
+ col.markdown(
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # Paper note
+ st.markdown(
+ "{region}
"
+ f"{role}
"
+ + "".join(
+ f"→"
+ f"{s.replace('→ ', '')}
"
+ for s in signals.split("\n")
+ ) +
+ f""
+ "TRIBE v2 predicts responses across all of these regions simultaneously. "
+ "The cognitive signal thresholds in this tool are calibrated against TRIBE's "
+ "encoding score patterns — the same patterns that showed V1–V7 responding "
+ "to contrast and edges, the FaceBody area responding to faces, and language areas "
+ "competing with visual processing for working memory resources."
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Section D: The Cognitive Science Frameworks ───────────────────────────
+ st.markdown("", + unsafe_allow_html=True) + st.markdown( + "
D · Cognitive Science Frameworks Used
",
+ unsafe_allow_html=True,
+ )
+
+ d1, d2 = st.columns(2)
+ with d1:
+ st.markdown(_block("Dual-Coding Theory — Paivio (1971)", "#c084fc",
+ _ptr("#c084fc", "Core claim:", "The brain has two separate memory channels — visual and verbal") +
+ _ptr("#c084fc", "How it works:", "Images stored in visual memory · words/text in verbal memory") +
+ _ptr("#c084fc", "Key finding:", "Content encoded in BOTH channels is 2× more likely to be recalled") +
+ _ptr("#c084fc", "In this tool:", "Text density 5–25% = dual-coding sweet spot · < 5% = verbal channel unused · > 25% = verbal drowns visual") +
+ _ptr("#c084fc", "Ad implication:", "A single 5–8 word tagline + strong visual is more memorable than text-only or image-only")
+ ), unsafe_allow_html=True)
+
+ st.markdown(_block("Russell Circumplex Model of Affect (1980)", "#ff80ab",
+ _ptr("#ff80ab", "Core claim:", "All emotions can be mapped on two axes: Valence (positive/negative) + Arousal (excited/calm)") +
+ _ptr("#ff80ab", "Why it matters:", "Emotional valence is the single strongest predictor of long-term brand equity") +
+ _ptr("#ff80ab", "In this tool:", "Valence scored −1.0 (aversive) → +1.0 (rewarding)") +
+ _ptr("#ff80ab", "Colour mapping:", "Warm hues (red/orange/yellow) → positive arousal · Cool/dark → lower valence") +
+ _ptr("#ff80ab", "Face contribution:", "Each face detected adds up to +0.25 valence (affiliative warmth)")
+ ), unsafe_allow_html=True)
+
+ with d2:
+ st.markdown(_block("Cognitive Load Theory — Sweller (1988)", "#ffb300",
+ _ptr("#ffb300", "Core claim:", "Working memory has a fixed capacity (~7±2 items)") +
+ _ptr("#ffb300", "Three load types:", "Intrinsic (task complexity) · Extraneous (visual noise) · Germane (learning)") +
+ _ptr("#ffb300", "Ad relevance:", "Extraneous load = clutter = objects + excess text competing for attention") +
+ _ptr("#ffb300", "In this tool:", "< 4 objects = Low load · 4–8 = Medium · > 8 = High") +
+ _ptr("#ffb300", "Cost of High load:", "Saturated working memory → brand message not encoded → wasted impressions") +
+ _ptr("#ffb300", "Retail Media:", "High load penalised −12 CPCi points (clutter compounds with environment)")
+ ), unsafe_allow_html=True)
+
+ st.markdown(_block("Miller's Law (1956) + Pre-attentive Processing", "#40c4ff",
+ _ptr("#40c4ff", "Miller's Law:", "Short-term memory holds 7 ± 2 'chunks' of information simultaneously") +
+ _ptr("#40c4ff", "Why it caps objects:", "More than 7 objects → chunking fails → viewer samples randomly") +
+ _ptr("#40c4ff", "Pre-attentive:", "The brain processes certain features (contrast, colour, motion) in < 200ms — before conscious attention") +
+ _ptr("#40c4ff", "Face reflex:", "Face detection activates in < 13ms — the fastest involuntary attention trigger available") +
+ _ptr("#40c4ff", "Implication:", "Ads that pass the pre-attentive filter don't need to 'ask' for attention — they capture it automatically")
+ ), unsafe_allow_html=True)
+
+ # ── Section E: CPCi Score Interpretation ─────────────────────────────────
+ st.markdown("", + unsafe_allow_html=True) + st.markdown( + "
E · CPCi Score Zones
",
+ unsafe_allow_html=True,
+ )
+
+ e1, e2, e3 = st.columns(3)
+ for col, zone, score, color, points in [
+ (e1, "NEEDS IMPROVEMENT", "0 – 39", "#ff5252", [
+ "Likely scrolled past in cold-audience feeds",
+ "Weak attention + memory = low platform Quality Score",
+ "High CPM inflation — algorithm penalises low engagement",
+ "Do not scale. Fix at least 1 dimension before spending",
+ "Action: redesign the creative, not just the copy",
+ ]),
+ (e2, "AVERAGE PERFORMER", "40 – 69", "#ffb300", [
+ "Will deliver in warm/retargeted audiences",
+ "Moderate recall — needs 6–8 impressions to build salience",
+ "Safe for mid-funnel, not efficient for cold prospecting",
+ "Gap to top-quartile is closeable with 1–2 targeted changes",
+ "Action: run A/B test before committing full budget",
+ ]),
+ (e3, "STRONG PERFORMER", "70 – 100", "#00e676", [
+ "Above-average thumb-stop rate in social feed formats",
+ "Strong memory trace — brand recall lifts in 3–5 impressions",
+ "Suitable for broad reach and top-of-funnel investment",
+ "Correlates with 3–5pt brand lift in campaign measurement",
+ "Action: scale budget 20–30%, cap frequency at 7",
+ ]),
+ ]:
+ col.markdown(
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ st.markdown(
+ "{zone}
"
+ f"{score}
"
+ + "".join(
+ f"→"
+ f"{p}
"
+ for p in points
+ ) +
+ f""
+ "CPCi = (w_attention × Attention) + (w_memory × Memory) + (w_emotion × ((Valence + 1) / 2 × 100))"
+ "
[ − Load Penalty if use case = Retail Media ]" + "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Section F: Provenance & Attribution ───────────────────────────────────
+ st.markdown("[ − Load Penalty if use case = Retail Media ]" + "
", + unsafe_allow_html=True) + st.markdown( + "
F · Provenance & Attribution
"
+ ""
+ "Exactly which numbers come from Meta TRIBE v2, and which were designed by Anil Pandit for CPCi
",
+ unsafe_allow_html=True,
+ )
+
+ # Two-column overview cards
+ fa, fb = st.columns(2)
+
+ with fa:
+ st.markdown(
+ ""
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ with fb:
+ st.markdown(
+ ""
+ "
"
+ "META FAIR
"
+ "TRIBE v2 Contribution
"
+ ""
+ "TRIBE v2 (d'Ascoli et al., Meta FAIR 2025) is a multimodal brain encoding model trained on "
+ "720 subjects · 1,117h fMRI · 121h video stimuli. "
+ "It maps AI representations onto cortical brain activity, achieving rank #1 at Algonauts 2025 "
+ "(263 competing teams) with a mean encoding score of 0.2146.
" + "The TRIBE v2 brain data established which visual features activate which brain regions — " + "and at what magnitudes. This is the neuroscience foundation for the signal thresholds, " + "clutter penalties, face boosts, and text density curves in CPCi." + "
"
+ "" + "The TRIBE v2 brain data established which visual features activate which brain regions — " + "and at what magnitudes. This is the neuroscience foundation for the signal thresholds, " + "clutter penalties, face boosts, and text density curves in CPCi." + "
"
+ + _ptr("#3B82F6", "V1–V7 visual cortex", "validates contrast as the primary pre-attentive driver")
+ + _ptr("#3B82F6", "FaceBody area (lateral cortex)", "fires in <13ms — justifies face attention boost of +22 pts")
+ + _ptr("#3B82F6", "Language areas (left hemisphere)", "competes with visual memory — basis for text density sweet spot")
+ + _ptr("#3B82F6", "Limbic / subcortical", "colour and face affect — basis for emotional valence scoring")
+ + "
"
+ ""
+ "Published: d'Ascoli S, Rapin J, Benchetrit Y, King J-R et al. · Meta FAIR 2025 · "
+ "Paper · "
+ "Weights (HuggingFace) · "
+ "License: CC BY-NC 4.0"
+ "
"
+ ""
+ "
",
+ unsafe_allow_html=True,
+ )
+
+ # ── Detailed provenance table ─────────────────────────────────────────────
+ st.markdown(
+ ""
+ "
"
+ "COGNITIVE SIGNAL ENGINE™
"
+ "Anil Pandit / CPCi Contribution
"
+ ""
+ "Anil Pandit designed the CPCi framework to translate TRIBE v2's neuroscience insights "
+ "into a fast, practical, pre-bid ad scoring system. "
+ "This includes the computer vision pipeline (OpenCV + OCR), all scoring constants, "
+ "the weighted CPCi formula, use-case tuning, the load penalty system, "
+ "and the narrative intelligence engine."
+ "
"
+ ""
+ + _ptr("#EF4444", "Creative vision pipeline", "OpenCV + Tesseract OCR — feature extraction in <2s")
+ + _ptr("#EF4444", "CPCi formula + weights", "w_attn × Attn + w_mem × Mem + w_emo × Val_norm")
+ + _ptr("#EF4444", "Use-case weight system", "FMCG 20/50/30 · Performance 50/30/20 · Retail 40/30/30")
+ + _ptr("#EF4444", "Cognitive load penalty", "−0 / −5 / −12 pts for Low / Medium / High (Retail Media)")
+ + _ptr("#EF4444", "Narrative engine", "Rule + Claude AI narrative · strategy recommendations")
+ + "
"
+ ""
+ "Cognitive Signal Engine™ — Proprietary framework · © Anil Pandit · All rights reserved"
+ "
"
+ "Constant-Level Provenance — Every Number, Every Source
",
+ unsafe_allow_html=True,
+ )
+
+ prov_rows = [
+ # (Constant / Signal, Value, Source, Neuroscience Basis)
+ ("Contrast → Attention weight", "0.50 (50 pts max)",
+ "TRIBE v2 + CPCi",
+ "V1–V7 visual cortex encodes luminance contrast edges as the primary pre-attentive signal; TRIBE v2 encoding scores confirm contrast as the strongest low-level visual driver"),
+ ("Face attention boost — 1 face", "+22 pts",
+ "TRIBE v2 (FaceBody area)",
+ "FaceBody lateral cortex activates in <13ms; TRIBE v2 predicts the highest encoding scores in this region for face-containing stimuli vs. all other image types"),
+ ("Face attention boost — 2 faces", "+14 pts (diminishing)",
+ "TRIBE v2 + CPCi",
+ "TRIBE v2 face encoding shows diminishing incremental activation when multiple faces compete; Anil Pandit calibrated the step-down to 14 pts based on this pattern"),
+ ("Face attention boost — 3+ faces","+8 pts",
+ "CPCi (calibrated on TRIBE v2)",
+ "Beyond 2 faces, faces create attention fragmentation; Anil Pandit set the cap at +8 based on FaceBody saturation pattern observed in TRIBE v2 multi-face stimuli"),
+ ("Clutter penalty — mild (4–7 obj)","−4 pts per object",
+ "Miller's Law + CPCi",
+ "Miller (1956): working memory holds 7±2 items. Anil Pandit calibrated the per-object penalty to exhaust the attention budget at ~7 objects, consistent with TRIBE v2 visual cortex saturation"),
+ ("Clutter penalty — severe (8+ obj)","−2 pts per object (cap −30)",
+ "CPCi",
+ "Diminishing penalty beyond severe threshold — attention is already fragmented; cap prevents negative scores. Anil Pandit's design decision"),
+ ("Text density sweet spot", "5%–25% of image area",
+ "Dual-Coding (Paivio 1986) + TRIBE v2",
+ "TRIBE v2 language area encoding peaks when verbal content is present but not dominant; Paivio's dual-coding theory (1971) defines the verbal/visual balance — Anil Pandit mapped both to the 5–25% text density range"),
+ ("Text overload threshold", ">50% → memory collapses",
+ "Sweller CLT + CPCi",
+ "Cognitive Load Theory (Sweller 1988): dual-channel saturation causes disengagement. TRIBE v2 language vs. visual cortex competition patterns support the 50% collapse point"),
+ ("Emotional valence — face boost", "+0.25 per face (cap +0.30)",
+ "TRIBE v2 (Limbic) + Russell (1980)",
+ "TRIBE v2 subcortical encoding shows positive affect response to faces via limbic activation; Russell circumplex maps face presence to the high-valence arousal quadrant"),
+ ("Colour valence — warm hues", "Red/Orange: +0.30 to +0.40",
+ "Russell Circumplex + CPCi",
+ "Russell's two-dimensional affect model places warm hues in the high-valence zone. Anil Pandit mapped HSV hue ranges to valence scores, scaled by saturation"),
+ ("Colour valence — dark/achromatic","≤ −0.25 (dark) / 0.0 (gray)",
+ "TRIBE v2 (Limbic) + CPCi",
+ "TRIBE v2 subcortical encoding shows reduced positive affect for low-luminance stimuli; dark images correlate with negative valence in limbic regions"),
+ ("CPCi formula weights", "Varies by use case",
+ "CPCi",
+ "Marketing science judgment: Performance ads need attention most (50%), FMCG needs memory (50%), Retail needs balance. Anil Pandit's proprietary use-case tuning"),
+ ("Cognitive load penalty", "−0/−5/−12 (Low/Med/High)",
+ "CPCi",
+ "Retail Media context amplifies load effects (cluttered screen environment). Anil Pandit's penalty system; not derived from TRIBE v2 directly"),
+ ("Score zone thresholds", "<40 weak · 40–70 avg · >70 strong",
+ "CPCi",
+ "CPCi score bands designed to align with typical creative performance quartiles in paid media. Anil Pandit's proprietary calibration"),
+ ]
+
+ # Table header
+ st.markdown(
+ "",
+ unsafe_allow_html=True,
+ )
+
+ rows_html = ""
+ st.markdown(rows_html, unsafe_allow_html=True)
+
+ st.markdown(
+ ""
+ "Note on methodology: "
+ "TRIBE v2 provides the neuroscience foundation — it tells us which brain regions respond to "
+ "contrast, faces, and text, and at what relative magnitudes. "
+ "Anil Pandit's CPCi translates those brain-level insights into a fast, deterministic scoring system "
+ "using OpenCV + OCR features — no GPU required, no fMRI needed. "
+ "The signal thresholds and formula constants were calibrated against TRIBE v2's published encoding "
+ "scores and brain parcel activations, then validated against marketing effectiveness benchmarks. "
+ "CPCi does not run TRIBE v2 inference directly — it uses TRIBE v2's brain data as its calibration reference."
+ "
",
+ unsafe_allow_html=True,
+ )
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# TAB 2 — Glossary
+# ══════════════════════════════════════════════════════════════════════════════
+
+GLOSSARY = {
+ "Neuroscience & TRIBE": [
+ ("TRIBE v2",
+ "Tri-modal Brain Imaging Encoding model v2. A foundation model from Meta FAIR that predicts fMRI brain activity in response to video, audio, and text. Used as the neuroscience basis for CPCi signal calibration.",
+ "#40c4ff",
+ ["Meta FAIR 2025", "720 subjects", "1,117h fMRI", "#1 Algonauts 2025"]),
+
+ ("fMRI",
+ "Functional Magnetic Resonance Imaging. Measures changes in blood oxygenation across the brain. When a brain region is more active, it consumes more oxygen — fMRI detects this as a BOLD signal change.",
+ "#40c4ff",
+ ["Blood oxygen measurement", "~2s temporal resolution", "Whole-brain coverage"]),
+
+ ("BOLD Signal",
+ "Blood-Oxygen-Level-Dependent signal. The raw measurement from fMRI. Higher BOLD = higher neuronal activity. TRIBE v2 predicts BOLD across 20,484 cortical vertices and 8,802 subcortical voxels.",
+ "#40c4ff",
+ ["Neuronal activity proxy", "TRIBE predicts this", "20,484 cortical points"]),
+
+ ("Encoding Model",
+ "A model that predicts brain activity from sensory inputs. TRIBE v2 is an encoding model — it takes video/audio/text and outputs the expected BOLD signal. Encoding score = Pearson correlation between predicted and actual brain response.",
+ "#40c4ff",
+ ["Input → brain output", "Pearson correlation score", "Used in Algonauts"]),
+
+ ("Encoding Score",
+ "The accuracy metric for brain encoding models. Measured as Pearson correlation (r) between the model's predicted BOLD signal and the participant's actual fMRI signal. TRIBE v2 achieved rank #1 with mean score 0.2146 ± 0.0312.",
+ "#40c4ff",
+ ["Pearson correlation", "TRIBE: 0.2146 mean", "Higher = better prediction"]),
+
+ ("Cortical Vertices / Parcellation",
+ "The brain's surface is divided into 20,484 measurement points (vertices). The HCP atlas groups these into 360 functional parcels (brain regions) including visual cortex V1–V7, face-body areas, language regions, and subcortical zones.",
+ "#40c4ff",
+ ["360 HCP parcels", "V1–V7 visual regions", "FaceBody, Language areas"]),
+
+ ("Foundation Model",
+ "A large pre-trained AI model that can be applied to many downstream tasks without retraining from scratch. TRIBE v2 is a foundation model for neuroscience — one model predicts brain responses across all stimulus types and experimental conditions.",
+ "#40c4ff",
+ ["Pre-trained at scale", "Zero-shot generalisation", "One model, many tasks"]),
+
+ ("ICA (Independent Component Analysis)",
+ "A statistical technique to separate a multi-dimensional signal into independent components. Used in the TRIBE v2 paper to reveal that the model learned neuroscientifically meaningful brain patterns without being explicitly trained to do so.",
+ "#40c4ff",
+ ["Unsupervised decomposition", "Reveals latent structure", "Validates TRIBE learning"]),
+ ],
+
+ "Cognitive Science": [
+ ("Attention Score",
+ "A 0–100 measure of a creative's ability to capture and hold visual attention. Driven by visual contrast (50% weight), face presence (up to +36 pts), and clutter penalty (based on object count). Calibrated against V1–V7 visual cortex encoding.",
+ "#00e676",
+ ["> 60 = High Capture", "30–60 = Moderate", "< 30 = Scroll-Past Risk"]),
+
+ ("Memory Score",
+ "A 0–100 measure of how strongly a creative will be encoded into long-term memory. Based on composition simplicity (fewer objects = better) and dual-coding balance (text density 5–25% optimal). Maps to hippocampal encoding strength.",
+ "#00e676",
+ ["> 70 = Strong Signal", "40–70 = Moderate", "< 40 = Low Retention"]),
+
+ ("Emotional Valence",
+ "The positive/negative emotional charge a creative produces in the viewer. Measured −1.0 (strongly aversive) to +1.0 (strongly rewarding). Driven by face presence, dominant colour HSV properties, and composition warmth.",
+ "#00e676",
+ ["+1.0 = Rewarding", "0.0 = Neutral", "−1.0 = Aversive"]),
+
+ ("Cognitive Load",
+ "The total mental effort required to process a creative. Calculated as a composite of visual complexity (object count) and verbal load (text density). Low = effortless processing. High = working memory overload → brand message not retained.",
+ "#00e676",
+ ["Low = < 35 composite", "Medium = 35–60", "High = > 60 · −12 CPCi"]),
+
+ ("Pre-attentive Processing",
+ "Brain processing that happens automatically before conscious attention, typically within 200ms. Features processed pre-attentively: luminance contrast, colour, motion, face presence, orientation. Ads that pass this filter don't 'ask' for attention.",
+ "#00e676",
+ ["< 200ms response", "Before conscious choice", "Contrast + face = strongest"]),
+
+ ("Dual-Coding Theory",
+ "Allan Paivio's (1971) theory that the brain stores verbal information (text) and visual information (images) in separate memory systems. Content encoded in both systems is 2× more memorable. Source of the 5–25% text density guideline.",
+ "#00e676",
+ ["Paivio 1971", "Two memory channels", "5–25% text = sweet spot"]),
+
+ ("Cognitive Load Theory",
+ "John Sweller's (1988) theory that working memory has a fixed capacity. Extraneous load (visual clutter, excess copy) consumes that capacity, leaving less room for germane load (brand message encoding). Basis for the object-count thresholds.",
+ "#00e676",
+ ["Sweller 1988", "7 ± 2 items limit", "Clutter = capacity waste"]),
+
+ ("Russell Circumplex",
+ "James Russell's (1980) two-dimensional model of affect: Valence (pleasant/unpleasant) × Arousal (activated/deactivated). Emotional valence in this tool maps to the horizontal valence axis. Used to explain why colour and faces shift emotional response.",
+ "#00e676",
+ ["Russell 1980", "Valence + Arousal axes", "Predicts purchase intent"]),
+
+ ("Miller's Law",
+ "George Miller's (1956) finding that short-term memory holds 7 ± 2 chunks simultaneously. In ad creative, each distinct visual object is a 'chunk'. Beyond 7 objects, viewers sample randomly — the brand message may not be what gets sampled.",
+ "#00e676",
+ ["Miller 1956", "7 ± 2 chunks", "Object threshold basis"]),
+ ],
+
+ "Visual Detection": [
+ ("Object Detection (Contour Analysis)",
+ "TRIBE pipeline step that counts distinct visual objects using Canny edge detection, dilation, and contour analysis. Threshold: a contour must cover ≥ 0.1% of total image area to count. Outputs object_count.",
+ "#ffb300",
+ ["OpenCV Canny", "0.1% area threshold", "Proxy for visual clutter"]),
+
+ ("Face Detection (Haar Cascade)",
+ "OpenCV's Haar Cascade classifier detects frontal human faces. Settings: scaleFactor=1.1, minNeighbors=5, minSize=30×30px. Runs in ~50–200ms. Face presence is the single highest-return attention variable in ad creative.",
+ "#ffb300",
+ ["OpenCV Haar", "50–200ms", "+22 pts attention per face"]),
+
+ ("Text Density (OCR)",
+ "Tesseract OCR in PSM 11 sparse-text mode detects all text blocks regardless of layout. Text density = sum of text bounding box areas ÷ total image area. Confidence threshold ≥ 40% to filter noise.",
+ "#ffb300",
+ ["Tesseract PSM 11", "Confidence ≥ 40%", "0.0–1.0 ratio"]),
+
+ ("Contrast Score",
+ "Computed as the standard deviation of grayscale pixel values, normalised to 0–100 (max std = 127.5 for an 8-bit image). Low std = flat/washed out. High std = strong light-dark variation = pre-attentive pop-out.",
+ "#ffb300",
+ ["Std dev / 127.5 × 100", "0 = flat", "100 = max contrast"]),
+
+ ("Dominant Colours (K-means)",
+ "K-means clustering (k=3) on a 100×100 downscaled image identifies the 3 most dominant colours by pixel count. Sorted by frequency. Converted to RGB hex strings. Used for valence calculation via HSV colour psychology.",
+ "#ffb300",
+ ["K-means k=3", "100×100 downsample", "Sorted by frequency"]),
+
+ ("HSV Colour Space",
+ "Hue-Saturation-Value colour representation. Used for emotion classification instead of RGB because HSV separates colour identity (hue) from brightness (value) more naturally. Warm hues (0–60°) = positive valence. Dark (V < 0.20) = negative.",
+ "#ffb300",
+ ["Hue 0–360°", "Saturation 0–1", "Value 0–1 (brightness)"]),
+ ],
+
+ "Media & Advertising": [
+ ("CPCi (Creative Performance Composite Index)",
+ "A 0–100 weighted score combining Attention, Memory, and Emotional Valence, calibrated to the specific cognitive demands of a given use case. Higher CPCi = stronger cognitive impact = better predicted media efficiency.",
+ "#ff80ab",
+ ["0–100 scale", "Use-case weighted", "Predicts media ROI"]),
+
+ ("Thumb-Stop Rate",
+ "The percentage of users who stop scrolling when they encounter an ad. Directly correlated with Attention Score. Low attention ads produce low thumb-stop rates, which the platform algorithm interprets as low quality, increasing effective CPM.",
+ "#ff80ab",
+ ["Attention proxy", "Algorithm quality signal", "Determines CPM cost"]),
+
+ ("Brand Salience",
+ "How quickly and easily a brand comes to mind in buying situations. Built through consistent memory encoding over multiple exposures. High Memory Score creatives build salience faster and with fewer exposures required.",
+ "#ff80ab",
+ ["Byron Sharp concept", "Built via Memory Score", "Drives shelf recognition"]),
+
+ ("Effective CPM",
+ "The true cost per 1,000 impressions accounting for placement quality. Low-attention creatives inflate effective CPM because the platform algorithm bids them into lower-quality inventory with lower engagement.",
+ "#ff80ab",
+ ["True cost metric", "Rises with low attention", "CPCi predicts direction"]),
+
+ ("Brand Lift",
+ "An increase in brand awareness, preference, or purchase intent measured by surveys after campaign exposure. CPCi scores above 70 historically correlate with 3–5 percentage point brand lift per campaign.",
+ "#ff80ab",
+ ["Survey-measured", "CPCi > 70 = 3–5pt lift", "Gold standard KPI"]),
+
+ ("Frequency Capping",
+ "Setting a maximum number of times a user sees the same ad. High Memory Score creatives need lower frequency (3–5 impressions) to achieve the same recall as low-memory creatives (6–9 impressions needed). Impacts media budget efficiency.",
+ "#ff80ab",
+ ["3–5 for high memory", "6–9 for low memory", "Controls wear-out"]),
+
+ ("Cognitive Load Penalty",
+ "A CPCi deduction applied in Retail Media contexts only: −0 for Low load, −5 for Medium, −12 for High. Applied because retail environments already impose high cognitive load on shoppers — an ad that adds to it will not convert.",
+ "#ff80ab",
+ ["Retail Media only", "−0 / −5 / −12", "Reflects real-world clutter"]),
+
+ ("Quality Score",
+ "The ad quality metric used by platforms (Google, Meta) that determines ad auction ranking and CPM. Creatives with high engagement (driven by attention and positive emotion) receive better Quality Scores, lowering cost per click.",
+ "#ff80ab",
+ ["Platform auction metric", "Attention → higher score", "Lowers CPC directly"]),
+ ],
+}
+
+
+def show_glossary_tab() -> None:
+ st.markdown(SCI_CSS, unsafe_allow_html=True)
+
+ st.markdown(
+ ""
+ "📖 Glossary of Terms
"
+ ""
+ "Every technical term used in the reports, scores, and methodology — explained for marketers.
",
+ unsafe_allow_html=True,
+ )
+
+ for category, terms in GLOSSARY.items():
+ with st.expander(f"{'🔬' if 'Neuro' in category else '🧩' if 'Cognitive' in category else '👁' if 'Visual' in category else '📢'} {category} — {len(terms)} terms", expanded=False):
+ cols = st.columns(2)
+ for idx, (term, definition, color, tags) in enumerate(terms):
+ tag_html = " ".join(f"{t}" for t in tags)
+ cols[idx % 2].markdown(
+ f""
+ f"
",
+ unsafe_allow_html=True,
+ )
+
+ # Quick-reference cheat sheet
+ st.markdown("{term}
"
+ f"{definition}
"
+ f"{tag_html}
"
+ f"", + unsafe_allow_html=True) + st.markdown( + "
⚡ Quick-Reference Cheat Sheet
",
+ unsafe_allow_html=True,
+ )
+
+ qs_rows = [
+ ("You see...", "It means...", "Action"),
+ ("Attention < 30", "Ad will be ignored before consciously seen", "Add face or boost contrast first"),
+ ("Memory < 40", "Brand won't be remembered after exposure", "Add tagline or simplify layout"),
+ ("Valence < −0.1", "Subtle aversion — silently kills brand love", "Warm up palette or add a face"),
+ ("Cognitive Load = High", "Working memory saturated — message lost", "Remove objects, cut copy"),
+ ("CPCi < 40", "Do not scale — fix creative first", "A/B test before spending"),
+ ("CPCi 40–70", "Potential there, but limited", "Identify weakest signal and fix it"),
+ ("CPCi > 70", "Ready to scale — strong cognitive impact", "Increase budget 20–30%"),
+ ("Text density > 25%", "Verbal channel drowning visual", "Cut copy to one key message"),
+ ("Text density < 5%", "No verbal anchor — recall will fade", "Add 5–10 word tagline"),
+ ("Faces = 0", "Missing fastest attention + emotion driver", "Add human face to primary zone"),
+ ("Contrast < 45", "Won't pop in feed — washed out pre-attention","Increase contrast in post"),
+ ]
+
+ header, *rows = qs_rows
+ header_html = (
+ ""
+ )
+ st.markdown(header_html, unsafe_allow_html=True)
+
+ rows_html = ""
+ st.markdown(rows_html, unsafe_allow_html=True)