transformerless_lm: v79 refined self-awareness (#1 + #2 + #3)

v78 self-eval was binary + single-EMA + reactive only. v79 adds
three layers of refined self-awareness:

#1 Continuous insight scale [0, ~2]:
   insight = surprise_factor * real_word_factor * (1 - rep_factor)
   - surprise_factor: surprise / pi*log(phi), capped at 2
   - real_word_factor: 1.0 if word, 0.3 if char
   - rep_factor: 1.0 if token in last F(7)=13 emissions, 0 if novel
   Replaces binary 0/1.

#2 Two-tier momentum (tactical + strategic):
   momentum_short: 1/F(3)=0.5 weight EMA -- responds in 2 steps
   momentum_long: 1/F(7)=0.077 weight EMA -- responds in 13 steps
   Decisions split: short drives sharpen/flatten (per-token tactic),
   long drives reserve scaling (strategic frame).

#3 Entropy override ("am I stuck?" signal):
   Local entropy of last F(5)=5 emissions.
   If H < log(2) ~ 0.69 -> force flatten regardless of momentum.
   The model detects its own repetition through entropy, not just
   momentum magnitude.

Three layers of self-awareness: emission quality (continuous insight),
temporal pattern (short + long momentum), and structural diversity
(entropy override). All pure substrate (F-tier EMAs, log thresholds).

Author: claude

experiments/transformerless_lm/train_self_recursive.py

@@ -1325,28 +1325,61 @@ def _omniweight_apply(base_probs: torch.Tensor,
 
 
 def _self_eval_insight(base_probs: torch.Tensor, emitted_tid: int,
-                          n_chars: int = 65) -> float:
-    """Compute self-evaluation insight signal for a just-emitted token.
+                          n_chars: int = 65,
+                          recent_tokens: list = None) -> float:
+    """Continuous insight score in [0, ~2].
 
-    insight = 1 if:
-      - emitted token is a real word (rank >= n_chars), AND
-      - surprise (-log p_emitted) >= pi*log(phi) ~ 1.51 (substrate threshold)
-    insight = 0 otherwise.
+    insight = surprise_factor * real_word_factor * (1 - repetition_factor)
 
-    Recursive substrate self-monitoring: model rates its own emissions
-    against its own distribution.
+    surprise_factor: surprise / (pi*log(phi)) capped at 2.
+      surprise = -log p_emitted under model's distribution.
+    real_word_factor: 1.0 if word-region (rank >= n_chars), 0.3 if char.
+    repetition_factor: 1.0 if token in last F(7)=13 emissions, 0 if novel.
+
+    Continuous scale (v79+) replaces binary insight (v77/v78).
+    Substrate-pure: phi/pi/F-tier thresholds.
     """
-    if emitted_tid < n_chars:
-        return 0.0
-    V = base_probs.shape[0]
-    if not (0 <= emitted_tid < V):
+    if emitted_tid < 0 or emitted_tid >= base_probs.shape[0]:
         return 0.0
     p = float(base_probs[emitted_tid].item())
     if p <= 0.0:
         return 0.0
     surprise = -math.log(p + 1e-12)
     threshold = math.pi * math.log(_PHI_FOR_SAMPLING)
-    return 1.0 if surprise >= threshold else 0.0
+    surprise_factor = min(surprise / threshold, 2.0)
+    real_word_factor = 1.0 if emitted_tid >= n_chars else 0.3
+    rep_factor = 0.0
+    if recent_tokens:
+        for tid in recent_tokens[-13:]:
+            if tid == emitted_tid:
+                rep_factor = 1.0
+                break
+    return surprise_factor * real_word_factor * (1.0 - rep_factor)
+
+
+def _local_entropy(recent_tokens: list, window: int = 5) -> float:
+    """Shannon entropy over last `window` (F(5)=5) emissions.
+
+    Low entropy = model is concentrating on few tokens (stuck).
+    High entropy = exploring diversity.
+
+    Returns H in nats; max for distinct tokens = log(window).
+    """
+    if not recent_tokens:
+        return 0.0
+    last = recent_tokens[-window:]
+    counts = {}
+    for t in last:
+        counts[t] = counts.get(t, 0) + 1
+    total = sum(counts.values())
+    if total == 0:
+        return 0.0
+    H = 0.0
+    for c in counts.values():
+        p = c / total
+        if p > 0:
+            H -= p * math.log(p)
+    return H
 
 
 def _omniweight_apply_split(base_probs: torch.Tensor,
@@ -1421,8 +1454,10 @@ def autoregressive_generate(model, prompt: torch.Tensor, n_new: int,
         char_run = 0
         recent_pairs = []   # (prev_tok, current_tok) bigram history
         last_content_ends_s = False
-        creative_momentum = 0.0   # self-eval EMA register
-        momentum_history = []     # recent momentum values, F(7)=13 deep
+        # v79: two-tier momentum (refined self-awareness).
+        momentum_short = 0.0   # F(3)=2 step EMA -- tactical
+        momentum_long = 0.0    # F(7)=13 step EMA -- strategic
+        momentum_history = []   # recent momentum_short values
         if vocab is not None:
             prompt_list = seq[0].tolist()
             for idx_pl, tid in enumerate(prompt_list):
@@ -1542,28 +1577,33 @@ def autoregressive_generate(model, prompt: torch.Tensor, n_new: int,
                     p = substrate_subject_threading(
                         seq_list, vocab, base, is_sentence_start=True)
                     lang_delta += _omniweight_delta(base, p)
-            # Apply split-brain mixer with momentum-modulated reserve.
+            # Apply split-brain mixer; STRATEGIC momentum (long) drives reserve.
             probs = _omniweight_apply_split(
                 base, math_delta, lang_delta,
-                momentum=creative_momentum).unsqueeze(0)
-            # A. Three-mode behavior based on momentum sign.
-            if creative_momentum > 0.5:
-                # Exploit: sharpen distribution.
+                momentum=momentum_long).unsqueeze(0)
+            # Local entropy of last F(5)=5 emissions (refined self-awareness).
+            recent_emitted = seq[0, -_FIB_NUMS_FOR_BIGRAM[5]:].tolist()
+            local_H = _local_entropy(recent_emitted, window=_FIB_NUMS_FOR_BIGRAM[5])
+            entropy_threshold = math.log(2.0)  # F(3)=2 distinct tokens
+            stuck = (local_H < entropy_threshold)
+            # A. TACTICAL momentum (short) drives sharpen/flatten.
+            if stuck:
+                # Entropy override: force flatten regardless of momentum.
+                p = probs[0] ** (1.0 / _PHI_FOR_SAMPLING)
+                probs[0] = p / (p.sum() + 1e-8)
+            elif momentum_short > 0.5:
                 p = probs[0] ** _PHI_FOR_SAMPLING
                 probs[0] = p / (p.sum() + 1e-8)
-            elif creative_momentum < -0.5:
-                # Escape: flatten distribution.
+            elif momentum_short < -0.5:
                 p = probs[0] ** (1.0 / _PHI_FOR_SAMPLING)
                 probs[0] = p / (p.sum() + 1e-8)
-            # B. Backtrack-on-collapse: if recent momentum dropped
-            # >F(3)=2 mass over last F(5)=5 steps AND current is
-            # negative, force newline boost (substrate reset).
+            # B. Backtrack-on-collapse on momentum_short history.
             collapsed = False
             if (len(momentum_history) >= _FIB_NUMS_FOR_BIGRAM[5]
                     and newline_mask is not None):
                 recent_window = momentum_history[-_FIB_NUMS_FOR_BIGRAM[5]:]
-                drop = max(recent_window) - creative_momentum
-                if drop > 0.3 and creative_momentum < -0.2:
+                drop = max(recent_window) - momentum_short
+                if drop > 0.3 and momentum_short < -0.2:
                     collapsed = True
             if collapsed and newline_mask is not None:
                 nm = newline_mask.to(probs[0].device).to(probs[0].dtype)
@@ -1613,13 +1653,20 @@ def autoregressive_generate(model, prompt: torch.Tensor, n_new: int,
                     recent_pairs.append((prev_for_pair, nid))
                     if len(recent_pairs) > 13:
                         recent_pairs = recent_pairs[-13:]
-                # Self-evaluation: update creative momentum EMA.
-                insight = _self_eval_insight(base, nid, n_chars_local)
-                inv_phi = 1.0 / _PHI_FOR_SAMPLING
-                creative_momentum = (inv_phi * creative_momentum
-                                       + (1.0 - inv_phi) * insight)
-                # Track momentum history for backtrack detection.
-                momentum_history.append(creative_momentum)
+                # Self-evaluation: continuous insight + two-tier momentum.
+                recent_emitted_list = seq[0, -13:].tolist()
+                insight = _self_eval_insight(
+                    base, nid, n_chars_local,
+                    recent_tokens=recent_emitted_list)
+                # Tactical short EMA: 1/F(3)=0.5 weight.
+                w_short = 1.0 / float(_FIB_NUMS_FOR_BIGRAM[3])
+                momentum_short = ((1.0 - w_short) * momentum_short
+                                    + w_short * insight)
+                # Strategic long EMA: 1/F(7)=0.077 weight.
+                w_long = 1.0 / float(_FIB_NUMS_FOR_BIGRAM[7])
+                momentum_long = ((1.0 - w_long) * momentum_long
+                                   + w_long * insight)
+                momentum_history.append(momentum_short)
                 if len(momentum_history) > 13:
                     momentum_history = momentum_history[-13:]
     model.train()