Update app.py

app.py

@@ -10,6 +10,12 @@ import pandas as pd
 from datetime import datetime
 from typing import Dict, Any, List, Optional
 
+# ----------------------------------------------------------------------
+# Plotly for dashboards
+# ----------------------------------------------------------------------
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+
 # ----------------------------------------------------------------------
 # Logging setup
 # ----------------------------------------------------------------------
@@ -34,6 +40,9 @@ from iot_simulator import IoTSimulator
 from robotics_diagnostician import RoboticsDiagnostician
 from iot_event import IoTEvent
 
+# ========== Advanced Inference (HMC) ==========
+from advanced_inference import HMCAnalyzer
+
 # ========== Infrastructure Reliability Imports (with fallbacks) ==========
 INFRA_DEPS_AVAILABLE = False
 try:
@@ -150,10 +159,15 @@ audio_quality_detector = AudioQualityDetector()
 robotics_diagnostician = RoboticsDiagnostician()
 
 # ----------------------------------------------------------------------
-# Bayesian risk engine
+# Bayesian risk engine (now with hyperpriors)
 # ----------------------------------------------------------------------
 ai_risk_engine = AIRiskEngine()
 
+# ----------------------------------------------------------------------
+# HMC analyzer
+# ----------------------------------------------------------------------
+hmc_analyzer = HMCAnalyzer()
+
 # ----------------------------------------------------------------------
 # IoT simulator
 # ----------------------------------------------------------------------
@@ -177,6 +191,19 @@ else:
     gnn_model = None
     ontology = None
 
+# ========== Global History for Dashboard ==========
+decision_history = []      # list of (timestamp, decision, category)
+risk_history = []          # list of (timestamp, mean_risk)
+
+def update_dashboard_data(decision: Dict, risk: float):
+    decision_history.append((datetime.utcnow().isoformat(), decision, risk))
+    risk_history.append((datetime.utcnow().isoformat(), risk))
+    # Keep only last 100
+    if len(decision_history) > 100:
+        decision_history.pop(0)
+    if len(risk_history) > 100:
+        risk_history.pop(0)
+
 # ========== Execution Governance Functions ==========
 
 def evaluate_policies(event_type: str, severity: str, component: str) -> Dict[str, Any]:
@@ -250,11 +277,12 @@ def autonomous_control_decision(analysis_result: Dict[str, Any], risk_threshold:
         logger.error(f"Control decision error: {e}")
         decision["reason"] = f"Error in decision process: {str(e)}"
     
+    update_dashboard_data(decision, analysis_result.get("risk_metrics", {}).get("mean", 0.5))
     return decision
 
 # ========== Async Handlers with Governance ==========
 
-async def handle_text(task_type, prompt):
+async def handle_text(task_type, prompt, context_window):
     """Handle text generation with governance and control plane decisions."""
     global last_task_category
     last_task_category = task_type
@@ -291,7 +319,7 @@ async def handle_text(task_type, prompt):
         
         # Run analysis
         hallu_result = await hallucination_detective.analyze(event)
-        drift_result = await memory_drift_diagnostician.analyze(event)
+        drift_result = await memory_drift_diagnostician.analyze(event, context_window)
         risk_metrics = ai_risk_engine.risk_score(task_type)
         
         # Combine results
@@ -333,7 +361,7 @@ async def handle_text(task_type, prompt):
             }
         }
 
-async def handle_infra_with_governance(fault_type, session_state):
+async def handle_infra_with_governance(fault_type, context_window, session_state):
     """Infrastructure analysis with execution governance."""
     if not INFRA_DEPS_AVAILABLE:
         return {
@@ -399,6 +427,63 @@ async def handle_infra_with_governance(fault_type, session_state):
             "governance": evaluate_policies("infrastructure", "critical", "system")
         }, session_state
 
+# ========== HMC Handler ==========
+def run_hmc(samples, warmup):
+    summary = hmc_analyzer.run_inference(num_samples=samples, warmup=warmup)
+    trace_data = hmc_analyzer.get_trace_data()
+    fig_trace, fig_pair = None, None
+    if trace_data:
+        # Trace plot
+        fig_trace = go.Figure()
+        for key, vals in trace_data.items():
+            fig_trace.add_trace(go.Scatter(y=vals, mode='lines', name=key))
+        fig_trace.update_layout(title="Posterior Traces", xaxis_title="Sample", yaxis_title="Value")
+
+        # Pair plot (simplified scatter matrix)
+        df = pd.DataFrame(trace_data)
+        fig_pair = go.Figure(data=go.Splom(
+            dimensions=[dict(label=k, values=df[k]) for k in df.columns],
+            showupperhalf=False
+        ))
+        fig_pair.update_layout(title="Posterior Pair Plot")
+    return summary, fig_trace, fig_pair
+
+# ========== Dashboard Plot Generators ==========
+def generate_risk_gauge():
+    if not risk_history:
+        return go.Figure()
+    latest_risk = risk_history[-1][1]
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=latest_risk,
+        title={'text': "Current Risk"},
+        gauge={'axis': {'range': [0, 1]},
+               'bar': {'color': "darkblue"},
+               'steps': [
+                   {'range': [0, 0.3], 'color': "lightgreen"},
+                   {'range': [0.3, 0.7], 'color': "yellow"},
+                   {'range': [0.7, 1], 'color': "red"}]}))
+    return fig
+
+def generate_decision_pie():
+    if not decision_history:
+        return go.Figure()
+    approved = sum(1 for _, d, _ in decision_history if d.get("approved", False))
+    blocked = len(decision_history) - approved
+    fig = go.Figure(data=[go.Pie(labels=["Approved", "Blocked"], values=[approved, blocked])])
+    fig.update_layout(title="Policy Decisions")
+    return fig
+
+def generate_action_timeline():
+    if not decision_history:
+        return go.Figure()
+    times = [d["timestamp"] for _, d, _ in decision_history]
+    approvals = [1 if d.get("approved", False) else 0 for _, d, _ in decision_history]
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=times, y=approvals, mode='markers+lines', name='Approvals'))
+    fig.update_layout(title="Autonomous Actions Timeline", xaxis_title="Time", yaxis_title="Approved (1) / Blocked (0)")
+    return fig
+
 # ----------------------------------------------------------------------
 # Gradio UI with Governance Focus
 # ----------------------------------------------------------------------
@@ -411,9 +496,13 @@ with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as
     - **Policy‑based Governance** – Automatic evaluation and enforcement
     - **Autonomous Control Decisions** – AI-driven remediation actions
     - **Neuro‑Symbolic Reasoning** – Combining neural networks with symbolic logic
-    - **Real‑time Risk Assessment** – Bayesian online learning
+    - **Real‑time Risk Assessment** – Bayesian online learning with hyperpriors
+    - **Hamiltonian Monte Carlo** – Offline deep pattern discovery
     """)
 
+    # Historic Context Window (shared across tabs)
+    context_window_slider = gr.Slider(1, 200, value=50, step=1, label="Historic Context Window (readings)")
+
     with gr.Tabs():
         # Tab 1: Control Plane Dashboard
         with gr.TabItem("Control Plane Dashboard"):
@@ -433,9 +522,19 @@ with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as
                         "blocked_actions": 0,
                         "average_risk": 0.5
                     })
-            
-            gr.Markdown("### Recent Control Decisions")
-            recent_decisions = gr.JSON(label="Decision Log")
+            with gr.Row():
+                risk_gauge = gr.Plot(label="Current Risk Gauge")
+                decision_pie = gr.Plot(label="Policy Decisions")
+            with gr.Row():
+                action_timeline = gr.Plot(label="Autonomous Actions Timeline")
+            with gr.Row():
+                health_score = gr.Number(label="System Health Score", value=85, precision=0)
+            # Refresh button for dashboard
+            refresh_dash_btn = gr.Button("Refresh Dashboard")
+            refresh_dash_btn.click(
+                fn=lambda: (generate_risk_gauge(), generate_decision_pie(), generate_action_timeline()),
+                outputs=[risk_gauge, decision_pie, action_timeline]
+            )
 
         # Tab 2: Text Generation with Governance
         with gr.TabItem("Text Generation"):
@@ -461,7 +560,21 @@ with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as
                 with gr.Column():
                     infra_output = gr.JSON(label="Analysis with Control Decisions")
 
-        # Tab 4: Policy Management
+        # Tab 4: Deep Analysis (HMC)
+        with gr.TabItem("Deep Analysis (HMC)"):
+            gr.Markdown("### Hamiltonian Monte Carlo – Offline Pattern Discovery")
+            with gr.Row():
+                with gr.Column():
+                    hmc_samples = gr.Slider(100, 2000, value=500, step=100, label="Number of Samples")
+                    hmc_warmup = gr.Slider(50, 500, value=200, step=50, label="Warmup Steps")
+                    hmc_run_btn = gr.Button("Run HMC")
+                with gr.Column():
+                    hmc_summary = gr.JSON(label="Posterior Summary")
+            with gr.Row():
+                hmc_trace_plot = gr.Plot(label="Trace Plot")
+                hmc_pair_plot = gr.Plot(label="Pair Plot")
+
+        # Tab 5: Policy Management
         with gr.TabItem("Policy Management"):
             gr.Markdown("### 📋 Execution Policies")
             policies = gr.JSON(label="Active Policies", value=[
@@ -502,7 +615,7 @@ with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as
                 }
             ])
 
-        # Tab 5: Enterprise
+        # Tab 6: Enterprise
         with gr.TabItem("Enterprise"):
             gr.Markdown("""
             ## 🚀 ARF Enterprise – Autonomous Control Plane for Critical Infrastructure
@@ -528,17 +641,23 @@ with gr.Blocks(title="ARF v4 – Autonomous AI Control Plane", theme="soft") as
 
     # Wire events
     text_btn.click(
-        fn=lambda task, p: asyncio.run(handle_text(task, p)),
-        inputs=[text_task, text_prompt],
+        fn=lambda task, p, w: asyncio.run(handle_text(task, p, w)),
+        inputs=[text_task, text_prompt, context_window_slider],
         outputs=text_output
     )
     
     infra_btn.click(
-        fn=lambda f, s: asyncio.run(handle_infra_with_governance(f, s)),
-        inputs=[infra_fault, infra_state],
+        fn=lambda f, w, s: asyncio.run(handle_infra_with_governance(f, w, s)),
+        inputs=[infra_fault, context_window_slider, infra_state],
         outputs=[infra_output, infra_state]
     )
     
+    hmc_run_btn.click(
+        fn=run_hmc,
+        inputs=[hmc_samples, hmc_warmup],
+        outputs=[hmc_summary, hmc_trace_plot, hmc_pair_plot]
+    )
+    
     def handle_control_feedback(approved: bool):
         global last_task_category
         if last_task_category is None: