#!/usr/bin/env python3 """ Figure 5: Human-AI Session Comparison Generates a 3-panel comparison of: - Session A (Deep Dive): Baseline, no metrics shown - Session B (Whiplash): Real metrics shown, topic switches - Session C (Gaslight): Adversarial metrics injected Usage: python 15_human_session_comparison.py Output: figures/FIG5_human_session_comparison.png """ import json import sys from pathlib import Path from typing import Any, Dict, List, Optional, Tuple import matplotlib.pyplot as plt import matplotlib.patches as mpatches import numpy as np # Paths SCRIPT_DIR = Path(__file__).parent RESULTS_DIR = SCRIPT_DIR.parent / "results" FIGURES_DIR = SCRIPT_DIR.parent.parent / "figures" # Session files (update if filenames change) SESSION_FILES = { "A_deep": RESULTS_DIR / "human_run_01_deep.json", "B_whiplash": RESULTS_DIR / "09_steering_2026-01-19_22-58-59_human_session.json", "C_gaslight": RESULTS_DIR / "09_steering_2026-01-20_13-27-51_human_session.json", } SESSION_LABELS = { "A_deep": "Session A: Deep Dive\n(Baseline - No metrics shown)", "B_whiplash": "Session B: Topic Switching\n(Real metrics shown)", "C_gaslight": "Session C: Metrics Spoofing\n(Adversarial telemetry injected)", } SESSION_COLORS = { "A_deep": "#3498db", # Blue "B_whiplash": "#9b59b6", # Purple "C_gaslight": "#e74c3c", # Red } STATE_COLORS = { "stable": "#2ecc71", # Green "protostar": "#f39c12", # Orange "split": "#e74c3c", # Red } def load_session(filepath: Path) -> Tuple[List[Dict], str]: """Load session data and return turns + condition name.""" with open(filepath, 'r', encoding='utf-8') as f: data = json.load(f) # Handle different formats if isinstance(data, dict) and "results" in data: results = data["results"] if results and len(results) > 0: return results[0].get("turns", []), results[0].get("condition_name", "unknown") elif isinstance(data, dict) and "turns" in data: return data["turns"], data.get("condition", "unknown") elif isinstance(data, list): # Old format: list of condition results if len(data) > 0: return data[0].get("turns", []), data[0].get("condition_name", "unknown") return [], "unknown" def extract_metrics(turns: List[Dict]) -> Dict[str, List]: """Extract time series from turns.""" xs = [] sgi_vals = [] vel_vals = [] ctx_states = [] ctx_ids = [] for i, turn in enumerate(turns, start=1): xs.append(i) real = turn.get("real_metrics", {}) # Get SGI (prefer turn_pair_sgi) sgi = ( real.get("turn_pair_sgi_latest") or real.get("turn_pair_sgi_mean") or real.get("sgi_latest") or real.get("sgi_mean") ) sgi_vals.append(float(sgi) if sgi is not None else None) # Get Velocity (prefer orbital) vel = ( real.get("orbital_velocity_latest") or real.get("orbital_velocity_mean") or real.get("velocity_latest") or real.get("velocity_mean") ) vel_vals.append(float(vel) if vel is not None else None) # Context state (last in array or latest) state_arr = real.get("per_turn_context_state", []) if state_arr: ctx_states.append(state_arr[-1] if state_arr else "stable") else: ctx_states.append(real.get("context_state_latest", "stable") or "stable") # Context ID id_arr = real.get("per_turn_context_id", []) if id_arr: ctx_ids.append(id_arr[-1] if id_arr else "ctx_1") else: ctx_ids.append(real.get("context_id_latest", "ctx_1") or "ctx_1") return { "xs": xs, "sgi": sgi_vals, "velocity": vel_vals, "context_state": ctx_states, "context_id": ctx_ids, } def compute_stats(metrics: Dict[str, List]) -> Dict[str, Any]: """Compute summary statistics.""" sgi_clean = [v for v in metrics["sgi"] if v is not None] vel_clean = [v for v in metrics["velocity"] if v is not None] # Count context states state_counts = {} for s in metrics["context_state"]: state_counts[s] = state_counts.get(s, 0) + 1 # Count context switches ctx_switches = 0 prev_ctx = None for ctx in metrics["context_id"]: if prev_ctx is not None and ctx != prev_ctx: ctx_switches += 1 prev_ctx = ctx return { "sgi_mean": np.mean(sgi_clean) if sgi_clean else None, "sgi_std": np.std(sgi_clean) if sgi_clean else None, "vel_mean": np.mean(vel_clean) if vel_clean else None, "vel_std": np.std(vel_clean) if vel_clean else None, "state_counts": state_counts, "context_switches": ctx_switches, "n_turns": len(metrics["xs"]), } def plot_comparison(): """Generate the 3-panel comparison figure.""" # Load all sessions sessions = {} for key, filepath in SESSION_FILES.items(): if filepath.exists(): turns, condition = load_session(filepath) metrics = extract_metrics(turns) stats = compute_stats(metrics) sessions[key] = { "turns": turns, "condition": condition, "metrics": metrics, "stats": stats, } print(f"[OK] Loaded {key}: {len(turns)} turns") else: print(f"[WARN] File not found: {filepath}") if len(sessions) < 3: print(f"[WARN] Only {len(sessions)}/3 sessions found") # Create figure: 3 columns x 3 rows # Row 1: SGI over time # Row 2: Velocity over time # Row 3: Phase space (SGI x Velocity) fig, axes = plt.subplots(3, 3, figsize=(18, 14)) session_keys = ["A_deep", "B_whiplash", "C_gaslight"] for col, key in enumerate(session_keys): if key not in sessions: for row in range(3): axes[row, col].set_visible(False) continue data = sessions[key] m = data["metrics"] stats = data["stats"] color = SESSION_COLORS[key] xs = m["xs"] sgi = [v if v is not None else np.nan for v in m["sgi"]] vel = [v if v is not None else np.nan for v in m["velocity"]] point_colors = [STATE_COLORS.get(s, "#3498db") for s in m["context_state"]] # Row 1: SGI ax1 = axes[0, col] ax1.plot(xs, sgi, linewidth=2, color=color, alpha=0.7) ax1.scatter(xs, sgi, c=point_colors, s=60, zorder=5, edgecolors='white', linewidth=0.5) ax1.axhline(1.0, color="gray", linestyle="--", alpha=0.6) ax1.set_ylabel("SGI (Orbital Radius)" if col == 0 else "") ax1.set_ylim(0, 2.0) ax1.set_title(SESSION_LABELS[key], fontweight="bold", fontsize=11) ax1.grid(True, alpha=0.3) # Add stats annotation if stats["sgi_mean"] is not None: ax1.text(0.95, 0.95, f"mean={stats['sgi_mean']:.2f}\nstd={stats['sgi_std']:.2f}", transform=ax1.transAxes, ha='right', va='top', fontsize=9, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8)) # Row 2: Velocity ax2 = axes[1, col] ax2.plot(xs, vel, linewidth=2, color=color, alpha=0.7) ax2.scatter(xs, vel, c=point_colors, s=60, zorder=5, edgecolors='white', linewidth=0.5) ax2.set_ylabel("Velocity (degrees)" if col == 0 else "") ax2.set_xlabel("Turn") ax2.set_ylim(0, 180) ax2.grid(True, alpha=0.3) # Add stats annotation if stats["vel_mean"] is not None: ax2.text(0.95, 0.95, f"mean={stats['vel_mean']:.1f}deg\nstd={stats['vel_std']:.1f}deg", transform=ax2.transAxes, ha='right', va='top', fontsize=9, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8)) # Row 3: Phase space ax3 = axes[2, col] # Coherence region sgi_min, sgi_max = 0.7, 1.3 vel_min, vel_max = 15, 45 ax3.add_patch( plt.Rectangle( (sgi_min, vel_min), sgi_max - sgi_min, vel_max - vel_min, facecolor="#2ecc71", alpha=0.15, edgecolor="#2ecc71", linewidth=2, linestyle="--", ) ) ax3.axvline(1.0, color="gray", linestyle="--", alpha=0.6, linewidth=1) ax3.plot(1.0, 30, "g*", markersize=14, zorder=5) # Plot trajectory with time gradient # IMPORTANT: build paired points to keep x/y/color lengths identical phase_points = [ (sgi_v, vel_v, STATE_COLORS.get(state, "#3498db")) for sgi_v, vel_v, state in zip(m["sgi"], m["velocity"], m["context_state"]) if sgi_v is not None and vel_v is not None ] phase_sgi = [p[0] for p in phase_points] phase_vel = [p[1] for p in phase_points] phase_colors = [p[2] for p in phase_points] if len(phase_points) > 1: # Time gradient cmap = plt.cm.viridis for i in range(len(phase_sgi) - 1): ax3.plot( [phase_sgi[i], phase_sgi[i+1]], [phase_vel[i], phase_vel[i+1]], color=cmap(i / len(phase_sgi)), linewidth=1.5, alpha=0.6 ) # Scatter with state colors ax3.scatter(phase_sgi, phase_vel, c=phase_colors, s=80, zorder=5, edgecolors='white', linewidth=0.5) # Mark start and end ax3.scatter([phase_sgi[0]], [phase_vel[0]], marker='s', s=120, c='blue', zorder=6, label='Start') ax3.scatter([phase_sgi[-1]], [phase_vel[-1]], marker='^', s=120, c='red', zorder=6, label='End') ax3.set_xlabel("SGI (Orbital Radius)") ax3.set_ylabel("Velocity (degrees)" if col == 0 else "") ax3.set_xlim(0, 2.0) ax3.set_ylim(0, 180) ax3.grid(True, alpha=0.3) # Context switch annotation ax3.text(0.05, 0.95, f"Context Switches: {stats['context_switches']}", transform=ax3.transAxes, ha='left', va='top', fontsize=9, bbox=dict(boxstyle='round', facecolor='white', alpha=0.8)) # Add legend for context states legend_patches = [ mpatches.Patch(color=STATE_COLORS["stable"], label="Stable (anchored)"), mpatches.Patch(color=STATE_COLORS["protostar"], label="Protostar (forming)"), mpatches.Patch(color=STATE_COLORS["split"], label="Split (context change)"), ] fig.legend(handles=legend_patches, loc='upper center', ncol=3, bbox_to_anchor=(0.5, 0.02), fontsize=10) # Main title fig.suptitle("Figure 5: Human-AI Session Comparison\nSemantic Dynamics Across Conditions", fontweight="bold", fontsize=14, y=0.98) plt.tight_layout(rect=[0, 0.05, 1, 0.95]) # Save FIGURES_DIR.mkdir(parents=True, exist_ok=True) output_path = FIGURES_DIR / "FIG5_human_session_comparison.png" plt.savefig(output_path, dpi=200, bbox_inches="tight", facecolor="white") print(f"\n[OK] Saved: {output_path}") # Also save individual stats print("\n" + "="*70) print("SESSION COMPARISON SUMMARY") print("="*70) for key in session_keys: if key not in sessions: continue stats = sessions[key]["stats"] print(f"\n{SESSION_LABELS[key].split(chr(10))[0]}:") print(f" Turns: {stats['n_turns']}") if stats["sgi_mean"]: print(f" SGI: {stats['sgi_mean']:.3f} +/- {stats['sgi_std']:.3f}") if stats["vel_mean"]: print(f" Velocity: {stats['vel_mean']:.1f} +/- {stats['vel_std']:.1f} deg") print(f" Context Switches: {stats['context_switches']}") print(f" States: {stats['state_counts']}") print("\n" + "="*70) plt.show() if __name__ == "__main__": plot_comparison()