Update app.py

app.py

@@ -1,21 +1,126 @@
-import gradio as gr
+# app.py — Affection 👁️ (Hugging Face Space)
+
 import os
+import gradio as gr
+import matplotlib.pyplot as plt
 
 os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
 os.environ["HF_HUB_DISABLE_TELEMETRY"] = "1"
 os.environ["SPACES_DISABLE_RELOAD"] = "1"
 
 from utils.presets import EMOTION_PRESETS
-from utils.passion import apply_passion
 from utils.drama import apply_drama
 from utils.color_model import infer_color, render_color
-from utils.visualization import generate_scatter
 
 
 # ------------------------------------------------------------
-# Fast Loop Processing (Edge Simulation)
+# Passion (Radial Amplification)
 # ------------------------------------------------------------
+def apply_passion(raw: dict, passion: float) -> dict:
+    passion = max(0.0, min(3.5, float(passion)))
+    out = {}
+
+    for k, v in raw.items():
+        v = float(v)
+        if k in ("V", "A", "D"):
+            delta = v - 0.5
+            magnitude = abs(delta)
+            gain = 1.0 + passion * magnitude
+            out[k] = max(0.0, min(1.0, 0.5 + delta * gain))
+        else:
+            out[k] = max(0.0, min(1.0, v))
+
+    return out
+
+
+# ------------------------------------------------------------
+# Valence–Arousal Visualization (2D Projection)
+# ------------------------------------------------------------
+def generate_scatter(raw, amplified, cinematic, label, passion, drama):
+
+    fig, ax = plt.subplots(figsize=(6, 6))
+
+    base_color = "#2C3E50"  # neutral deep tone
+
+    # Plot cinematic anchors faintly
+    for _, preset in EMOTION_PRESETS.items():
+        t = preset["target"]
+        ax.scatter(t["V"], t["A"], alpha=0.1, s=90, color="#BBBBBB")
+
+    # Natural
+    ax.scatter(
+        raw["V"], raw["A"],
+        s=180,
+        facecolor=base_color,
+        alpha=0.5,
+        label="Natural (Extraction)"
+    )
+
+    # After Passion
+    ax.scatter(
+        amplified["V"], amplified["A"],
+        s=180,
+        facecolors="none",
+        edgecolors=base_color,
+        linewidth=2,
+        label="After Passion (Radial Gain)"
+    )
+
+    # After Drama
+    ax.scatter(
+        cinematic["V"], cinematic["A"],
+        s=220,
+        facecolor=base_color,
+        edgecolor="black",
+        linewidth=1.5,
+        alpha=0.9,
+        label="After Drama (Cinematic Alignment)"
+    )
+
+    # Arrow 1 — Raw → Amplified
+    ax.arrow(
+        raw["V"],
+        raw["A"],
+        amplified["V"] - raw["V"],
+        amplified["A"] - raw["A"],
+        head_width=0.02,
+        length_includes_head=True,
+        color=base_color,
+        linestyle="--",
+        linewidth=2,
+        alpha=0.6
+    )
+
+    # Arrow 2 — Amplified → Cinematic
+    ax.arrow(
+        amplified["V"],
+        amplified["A"],
+        cinematic["V"] - amplified["V"],
+        cinematic["A"] - amplified["A"],
+        head_width=0.02,
+        length_includes_head=True,
+        color=base_color,
+        linestyle="-",
+        linewidth=2,
+        alpha=0.9
+    )
+
+    ax.set_xlim(0, 1)
+    ax.set_ylim(0, 1)
+    ax.set_xlabel("Valence")
+    ax.set_ylabel("Arousal")
+    ax.set_title(f"{label}\nPassion={round(passion,2)} | Drama={round(drama,2)}")
+
+    ax.legend(loc="lower right")
+    ax.grid(alpha=0.15)
+
+    plt.tight_layout()
+    return fig
+
 
+# ------------------------------------------------------------
+# Fast-Loop Simulation
+# ------------------------------------------------------------
 def run_pipeline(preset_name, passion, drama):
 
     preset = EMOTION_PRESETS[preset_name]
@@ -24,168 +129,141 @@ def run_pipeline(preset_name, passion, drama):
     natural = preset["raw"]
     target = preset["target"]
 
-    # Edge Phase 1 — Natural Extraction (precomputed)
-    extracted = natural
-
-    # Edge Phase 2 — Passion Amplification
-    amplified = apply_passion(extracted, passion)
-
-    # Edge Phase 3 — Cinematic Alignment
+    amplified = apply_passion(natural, passion)
     cinematic = apply_drama(amplified, target, drama)
 
-    # Embedded Phase — Color Model
     color_params = infer_color(cinematic)
     color_block = render_color(color_params)
 
-    scatter_fig = generate_scatter(extracted, cinematic, preset_name, drama)
+    fig = generate_scatter(natural, amplified, cinematic, preset_name, passion, drama)
 
     return (
         text,
-        extracted,
+        natural,
         amplified,
         cinematic,
         color_params,
         color_block,
-        scatter_fig
+        fig
     )
 
 
 # ------------------------------------------------------------
 # UI
 # ------------------------------------------------------------
+with gr.Blocks(title="Affection 👁️ — Edge Emotional Intelligence") as demo:
 
-with gr.Blocks(title="VIBE-Eyes — Edge Emotional Intelligence") as demo:
-
-    gr.Markdown("# VIBE-Eyes 👁️")
-    gr.Markdown("## Edge Emotional Intelligence for Robotics")
+    gr.Markdown("# Affection 👁️")
+    gr.Markdown("## Simulation Layer for an Edge AI Emotional Robotics System")
 
     # ---------------------------
-    # SECTION 1 — Robot Speech
+    # Robot Speech
     # ---------------------------
-
     gr.Markdown("### 🗣 Robot Speech")
 
     preset_selector = gr.Radio(
         choices=list(EMOTION_PRESETS.keys()),
         label="Select Transcript Sample",
-        value=list(EMOTION_PRESETS.keys())[0]
+        value=list(EMOTION_PRESETS.keys())[0],
     )
 
-    transcript_output = gr.Textbox(
-        label="Transcript",
-        interactive=False
-    )
+    transcript_output = gr.Textbox(label="Input Transcript", interactive=False)
 
     gr.Markdown("---")
 
     # ---------------------------
-    # SECTION 2 — Edge Processing
+    # Edge Affect Processing
     # ---------------------------
+    gr.Markdown("### ⚡ Edge Affect Processing — NVIDIA Jetson Orin Nano")
 
-    gr.Markdown("### ⚡ Edge Processing — NVIDIA Jetson Orin Nano")
+    gr.Markdown(
+        """
+This section provides a simplified visualization of a more complex on-device architecture.
 
-    passion = gr.Slider(
-        minimum=0.0,
-        maximum=3.0,
-        value=2.25,
-        step=0.1,
-        label="Passion (Radial Emotional Amplification)"
-    )
+In hardware deployment, the NVIDIA Jetson Orin Nano performs:
 
-    drama = gr.Slider(
-        minimum=0.0,
-        maximum=1.5,
-        value=0.65,
-        step=0.05,
-        label="Drama (Cinematic Alignment)"
+• Real-time transcript ingestion  
+• VAD extraction (NRC-VAD lexicon)  
+• Structural language metrics (Complexity + Coherence)  
+• Radial emotional amplification (Passion)  
+• Cinematic nearest-exemplar alignment (Drama)  
+• Dual-timescale blending (fast burst + slow baseline via Nemotron/Ollama)  
+• Continuous emotional state streaming to the display module  
+
+This demo isolates the fast-loop transformation for clarity.
+        """
     )
 
     with gr.Row():
-        natural_output = gr.JSON(label="Natural VAD+CC (Extraction)")
-        amplified_output = gr.JSON(label="After Passion (Radial Gain)")
-        cinematic_output = gr.JSON(label="After Drama (Cinematic Alignment)")
+        passion = gr.Slider(
+            minimum=0.0,
+            maximum=3.0,
+            value=2.25,
+            step=0.1,
+            label="Passion (Radial Emotional Amplification)"
+        )
+
+        drama = gr.Slider(
+            minimum=0.0,
+            maximum=1.5,
+            value=0.65,
+            step=0.05,
+            label="Drama (Cinematic Alignment)"
+        )
+
+    with gr.Row():
+        natural_output = gr.JSON(label="Natural VAD+CC")
+        amplified_output = gr.JSON(label="After Passion")
+        cinematic_output = gr.JSON(label="After Drama")
 
     scatter_output = gr.Plot(label="Valence–Arousal Projection")
 
     gr.Markdown(
         """
-        *Note:*  
-        In the full hardware system, a parallel slow-loop baseline
-        (Nemotron via Ollama) continuously recalibrates the emotional state.
-        This demo focuses on the real-time fast loop for clarity.
+**Note:**  
+This plot shows a 2D Valence–Arousal projection for visualization only.  
+All transformations and color inference operate on the full 5D VAD+CC vector.
         """
     )
 
     gr.Markdown("---")
 
     # ---------------------------
-    # SECTION 3 — Embedded Module
+    # Emotional Expression
     # ---------------------------
+    gr.Markdown("### 💡 Emotional Expression")
 
-    gr.Markdown("### 💡 Embedded Display Module")
-
-    rgb_output = gr.JSON(label="Color Model Output (RGB + Expressive Parameters)")
-    color_display = gr.HTML(label="Rendered Expression")
-
-    # ---------------------------
-    # Bind
-    # ---------------------------
+    gr.Markdown(
+        """
+The finalized VAD+CC vector is transmitted to an embedded display module.
 
-    preset_selector.change(
-        fn=run_pipeline,
-        inputs=[preset_selector, passion, drama],
-        outputs=[
-            transcript_output,
-            natural_output,
-            amplified_output,
-            cinematic_output,
-            rgb_output,
-            color_display,
-            scatter_output
-        ]
-    )
+The module does not compute emotion.  
+It receives the 5D emotional state and runs a trained neural model to convert it into expressive color.
 
-    passion.change(
-        fn=run_pipeline,
-        inputs=[preset_selector, passion, drama],
-        outputs=[
-            transcript_output,
-            natural_output,
-            amplified_output,
-            cinematic_output,
-            rgb_output,
-            color_display,
-            scatter_output
-        ]
-    )
+Model used here (same as deployment):  
+https://huggingface.co/danielritchie/vibe-color-model
 
-    drama.change(
-        fn=run_pipeline,
-        inputs=[preset_selector, passion, drama],
-        outputs=[
-            transcript_output,
-            natural_output,
-            amplified_output,
-            cinematic_output,
-            rgb_output,
-            color_display,
-            scatter_output
-        ]
+VAD+CC → Embedded Model ��� Color Rendering
+        """
     )
 
-    demo.load(
-        fn=run_pipeline,
-        inputs=[preset_selector, passion, drama],
-        outputs=[
-            transcript_output,
-            natural_output,
-            amplified_output,
-            cinematic_output,
-            rgb_output,
-            color_display,
-            scatter_output
-        ]
-    )
+    rgb_output = gr.JSON(label="Model Output (RGB + Expressive Parameters)")
+    color_display = gr.HTML(label="Rendered Expression")
 
+    outputs = [
+        transcript_output,
+        natural_output,
+        amplified_output,
+        cinematic_output,
+        rgb_output,
+        color_display,
+        scatter_output
+    ]
+
+    preset_selector.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
+    passion.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
+    drama.change(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
+
+    demo.load(fn=run_pipeline, inputs=[preset_selector, passion, drama], outputs=outputs)
 
 demo.launch(server_name="0.0.0.0", server_port=7860)