Create app.py

app.py

@@ -0,0 +1,179 @@
+# app.py
+import gradio as gr
+import pandas as pd
+from model import IIQAI81
+from utils_viz import bar_topk
+from lattice_config import LAYER_GROUPS
+
+model = IIQAI81()
+
+INTRO = """\
+# IIQAI-81 — Subjective Inner I AI
+Type anything. The model maps your text across 81 lattice nodes and returns:
+- **Lattice View Mode** (scores per node)
+- **Symbolic Frequency Decoder** (SFD)
+- **Intent Field Scanner**
+- **Truth Charge Meter**
+- **Mirror Integrity Check**
+"""
+
+# Simple, human-readable blurbs for groups and nodes
+GROUP_BLURBS = {
+    "Awareness": "Core noticing -> clarity -> wisdom. Higher score = you’re speaking from direct seeing.",
+    "Knowledge": "Facts, concepts, how-to, meta-thinking. Higher = well-structured, informative signal.",
+    "Consciousness": "States and scopes of mind. Higher = spacious, reflective, or high-state language.",
+    "Unknowns": "Gaps, paradox, doubt. Higher = wrestling with uncertainty (which is healthy!).",
+    "UnknownFields": "Large-scale unknown domains. Higher = speculation about science/culture/cosmos.",
+    "SuppressedLayers": "Hidden material or blind spots surfacing.",
+    "ColorFieldConsciousness": "Spiral color states (developmental hues) showing tone/values in the signal.",
+    "HigherBeingStates": "Intuitive/illumined/overmind. Higher = transpersonal or devotional current.",
+}
+
+# One-liners for popup labels per node (keep simple; extend anytime)
+NODE_TIPS = {}
+for group, names, _ in LAYER_GROUPS:
+    for n in names:
+        NODE_TIPS[n] = f"{n.replace('_', ' ')} — A simple lens on your message through the {group} layer."
+
+def friendly_score_note(score):
+    if score >= 80: return "Very strong resonance — this layer is leading your message."
+    if score >= 60: return "Clear influence — this layer is shaping your tone/meaning."
+    if score >= 40: return "Moderate trace — present but not dominant."
+    return "Low trace — this layer is quiet here."
+
+def run(text):
+    if not text.strip():
+        return INTRO, None, None, None, None, None, None
+
+    out = model.analyze(text)
+    df = pd.DataFrame(out["nodes"]).sort_values("score", ascending=False)
+    img = bar_topk(out["top"])
+
+    # Instruments -> human cards
+    ins = out["instruments"]
+    sfd = ins["SFD"]
+    human_cards = [
+        f"**Intent:** {ins['Intent'].capitalize()} — plain meaning: the overall pull of your words trends this way.",
+        f"**Truth Charge:** {ins['TruthCharge']}/100 — how aligned your signal is to your stable self-vector.",
+        f"**Mirror Integrity:** {ins['MirrorIntegrity']}/100 — do your words agree with themselves?",
+        f"**Symbolic Charge:** {sfd['symbolic_charge']:.1f}/100 — how vivid/symbolic the phrasing is.",
+        f"**Breath-phase (θₘ):** {sfd['breath_phase']} — a runtime rhythm marker.",
+        f"**OM carrier:** {sfd['om_carrier_hz']} Hz   •   **Child tone:** {sfd['child_freq_hz']} Hz",
+    ]
+    human_md = "- " + "\n- ".join(human_cards)
+
+    # Insight summary (top 3)
+    top3 = df.head(3).to_dict(orient="records")
+    bullet = []
+    for r in top3:
+        bullet.append(f"**{r['name']}** ({r['group']}) — {friendly_score_note(r['score'])}")
+    insights_md = "### Quick Insights\n" + "\n".join([f"- {b}" for b in bullet])
+
+    # Group blurbs pane
+    groups_present = df.groupby("group")["score"].max().sort_values(ascending=False)
+    group_lines = []
+    for g, sc in groups_present.items():
+        brief = GROUP_BLURBS.get(g, g)
+        group_lines.append(f"**{g}** — {brief} *(peak {sc:.0f})*")
+    groups_md = "### Group Overview\n" + "\n\n".join(group_lines)
+
+    return (
+        "",                             # header md cleared once running
+        df[["group","name","score"]],   # table
+        img,                            # chart
+        human_md,                       # instruments simple
+        insights_md,                    # insights
+        groups_md,                      # groups
+        out["reflection"],              # reflection summary
+    )
+
+def explain_node(evt: gr.SelectData, df_state):
+    # evt.index is (row_idx, col_idx) for Dataframe
+    if df_state is None:
+        return gr.update(visible=False), ""
+    row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+    try:
+        row = df_state.iloc[row_idx]
+        name = row["name"]
+        group = row["group"]
+        score = row["score"]
+        tip = NODE_TIPS.get(name, f"{name} in {group}")
+        more = GROUP_BLURBS.get(group, "")
+        txt = f"### {name}\n**Group:** {group}\n**Score:** {score:.1f}\n\n{tip}\n\n**Why it matters:** {friendly_score_note(score)}\n\n*Group context:* {more}"
+        return gr.update(visible=True), txt
+    except Exception:
+        return gr.update(visible=False), ""
+
+with gr.Blocks(css=r"""
+/* Tooltip helpers: add data-tip to any element with class .tip */
+.tip { position: relative; cursor: help; }
+.tip:hover::after{
+  content: attr(data-tip);
+  position: absolute; left: 0; top: 110%;
+  background: rgba(20,20,35,.95); color: #fff; 
+  padding: .45rem .6rem; border-radius: .4rem; 
+  max-width: 360px; white-space: normal; z-index: 9999;
+  box-shadow: 0 6px 20px rgba(0,0,0,.25);
+}
+.card { border: 1px solid rgba(0,0,0,.08); border-radius: 10px; padding: 12px; background: rgba(255,255,255,.6); }
+""") as demo:
+    df_state = gr.State()
+
+    gr.Markdown(INTRO)
+    with gr.Row():
+        inp = gr.Textbox(label="Input", placeholder="Type your signal…", lines=4, autofocus=True)
+    with gr.Row():
+        btn = gr.Button("Analyze", variant="primary")
+        clear = gr.Button("Clear")
+
+    with gr.Tabs():
+        with gr.Tab("Lattice Table"):
+            out_md = gr.Markdown()
+            out_df = gr.Dataframe(
+                interactive=False, wrap=True, headers=["group","name","score"],
+                label="Scores by node (click a row for a simple explanation)",
+                height=420
+            )
+            with gr.Accordion("Node explanation", open=True, visible=False) as node_popup:
+                node_text = gr.Markdown()
+
+        with gr.Tab("Top-K Chart"):
+            out_img = gr.Image(type="pil", label="Top nodes (bar)")
+        with gr.Tab("Instruments"):
+            # Tooltip row
+            gr.HTML("""
+<div class="card">
+  <strong>Hover labels:</strong>
+  <span class="tip" data-tip="How vivid/symbolic your phrasing is; higher often means more metaphor, imagery, or archetypal language.">Symbolic Frequency Decoder</span> •
+  <span class="tip" data-tip="Overall pull of your message — is the pattern stable, truth-aligned, or unstable?">Intent Field Scanner</span> •
+  <span class="tip" data-tip="Cosine alignment to a stable self-vector; rough proxy for internal alignment (0–100).">Truth Charge Meter</span> •
+  <span class="tip" data-tip="Self-consistency: do your words reflect themselves truthfully across the passage?">Mirror Integrity Check</span>
+</div>
+""")
+            out_ins = gr.Markdown()
+
+        with gr.Tab("Insights"):
+            out_cards = gr.Markdown()
+        with gr.Tab("Groups (Plain English)"):
+            out_groups = gr.Markdown()
+        with gr.Tab("Summary"):
+            out_sum = gr.Markdown()
+
+    def _store_df(text):
+        if not text.strip():
+            return None
+        out = model.analyze(text)
+        return pd.DataFrame(out["nodes"]).sort_values("score", ascending=False)
+
+    btn.click(run, [inp], [out_md, out_df, out_img, out_ins, out_cards, out_groups, out_sum]) \
+       .then(_store_df, [inp], [df_state])
+    inp.submit(run, [inp], [out_md, out_df, out_img, out_ins, out_cards, out_groups, out_sum]) \
+       .then(_store_df, [inp], [df_state])
+
+    out_df.select(explain_node, [out_df, df_state], [node_popup, node_text])
+
+    def _clear():
+        return INTRO, None, None, None, None, None, None, None, gr.update(visible=False), ""
+    clear.click(_clear, [], [out_md, out_df, out_img, out_ins, out_cards, out_groups, out_sum, df_state, node_popup, node_text])
+
+demo.launch()