v3.4.1: hybrid tanh normalization - preserve dimension signals

Replace v3.4 per-dimension re-centering with hybrid approach:
tanh(z_score * 0.15) on raw z-scores. Preserves absolute z-score
levels (strong Computation signal, AUC=0.768) while eliminating
hard ceiling effects from v3.3 clamp.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

app.py

@@ -54,13 +54,13 @@ def compute_consciousness(
 ) -> ConsciousnessResult:
     """Compute consciousness score from hidden state tensor.
 
-    v3.4: Per-dimension adaptive normalization.
-    Uses the full sequence to compute per-dimension z-score statistics,
-    then re-normalizes each dimension against its own baseline.
-    Replaces v3.3 hard clamp with tanh for smooth bounding.
+    v3.4.1 hybrid: z-score + tanh(z * 0.15) for smooth bounding.
+    Preserves absolute z-score levels (strong dimension-level signals)
+    while eliminating hard ceiling effects from v3.3 clamp.
     """
     import math
     start_time = time.time()
+    TANH_SCALE = 0.15  # tanh(z*0.15): z=3→0.42, z=5→0.64, z=8→0.83, z=10→0.91
 
     # Remap dimensions if needed
     if hidden_dim != REFERENCE_HIDDEN_DIM:
@@ -69,54 +69,32 @@ def compute_consciousness(
     else:
         dims = CONSCIOUS_DIMS_V2_1
 
-    # Get full sequence hidden states
+    # Get last token hidden state
     if hidden_state.dim() == 3:
-        h_seq = hidden_state[0].float()  # [seq_len, hidden_dim]
+        h = hidden_state[0, -1, :]  # [hidden_dim]
     elif hidden_state.dim() == 2:
-        h_seq = hidden_state.float()     # [seq_len, hidden_dim]
+        h = hidden_state[-1, :]
     else:
-        # Single vector fallback (no sequence context)
-        h_seq = hidden_state.float().unsqueeze(0)
-
-    seq_len = h_seq.shape[0]
-    tanh_scale = 0.5
-
-    # Pass 1: Compute z-scores for each consciousness dim across all positions
-    dim_z_raw = {info["name"]: [] for info in dims.values()}
-    for pos in range(seq_len):
-        h = h_seq[pos]
-        h_mean = h.mean().item()
-        h_std = h.std().item()
-        for dim_idx, info in dims.items():
-            if dim_idx < len(h):
-                z = (h[dim_idx].item() - h_mean) / (h_std + 1e-8)
-            else:
-                z = 0.0
-            dim_z_raw[info["name"]].append(z)
-
-    # Pass 2: Per-dimension re-normalization + tanh bounding
-    # Use last token for the final score, but normalize against
-    # the dimension's distribution across the whole sequence
+        h = hidden_state
+
+    h = h.float()
+
+    # Z-score normalize against full hidden state
+    h_mean = h.mean().item()
+    h_std = h.std().item()
+
+    # Compute contributions with tanh smooth bounding
     contributions = {}
     weighted_sum = 0.0
 
     for dim_idx, info in dims.items():
-        name = info["name"]
-        z_vals = dim_z_raw[name]
-        z_mean = sum(z_vals) / len(z_vals)
-        z_var = sum((z - z_mean) ** 2 for z in z_vals) / len(z_vals)
-        z_std = max(math.sqrt(z_var), 0.1)  # Floor to prevent noise amplification
-
-        # Last token: re-normalize against this dimension's sequence baseline
-        z_last = z_vals[-1]
-        renormed = (z_last - z_mean) / z_std
-        # Smooth bounding with tanh (no hard ceiling)
-        bounded = math.tanh(renormed * tanh_scale)
-
-        activation = bounded
-        contribution = activation * info["weight"] * info["polarity"]
-        weighted_sum += contribution
-        contributions[name] = activation * info["polarity"]
+        if dim_idx < len(h):
+            z = (h[dim_idx].item() - h_mean) / (h_std + 1e-8)
+            # Smooth bounding: preserves absolute level, no hard ceiling
+            activation = math.tanh(z * TANH_SCALE)
+            contribution = activation * info["weight"] * info["polarity"]
+            weighted_sum += contribution
+            contributions[info["name"]] = activation * info["polarity"]
 
     # Final score
     raw_score = baseline + weighted_sum * 0.15