Update app.py

app.py

@@ -347,7 +347,7 @@ PIANO_HTML = """
     <button id="mm-piano-btn">▶ Let the Modular Mind play</button>
     <span id="mm-piano-note">♪</span>
   </div>
-  <div id="mm-piano-lbl">specialists firing for each chord — Bass / Tenor / Soprano own a register; Sustain / Onset / Phrase are modulators that only write to the shared latent</div>
+  <div id="mm-piano-lbl">specialists firing for each chord - Bass / Tenor / Soprano own a register; Sustain / Onset / Phrase are modulators that only write to the shared latent</div>
   <div id="mm-piano-specs"></div>
   <div id="mm-piano-latent" title="RecursiveLink shared latent"></div>
 </div>
@@ -370,7 +370,7 @@ HEAD = (
 
 INTRO = """
 # 🍄 Quazim0t0's Thousand Token Wood Entry
-A mini **Dark-Souls-style** duel where the boss is controlled by a **Modular Mind** — six tiny
+A mini **Dark-Souls-style** duel where the boss is controlled by a **Modular Mind** - six tiny
 specialist networks that communicate through a **shared latent** (RecursiveLink) and a coordinator
 that picks each move. The brain was **trained by self-play reinforcement learning**, not scripted.
 Watch the right-hand panel: every boss decision shows which specialists fired and how the modulators
@@ -386,7 +386,7 @@ TECH_MD = r"""
 ## 🧠 How the model works (technical breakdown)
 
 The boss brain is a faithful, **specialist-scale** implementation of the Modular Mind
-architecture — small enough (~**4,500 parameters**, pure-NumPy inference) to decide in
+architecture - small enough (~**4,500 parameters**, pure-NumPy inference) to decide in
 well under a millisecond on a free CPU, yet structurally identical to the big idea:
 **many small domain specialists that communicate through one shared latent.**
 
@@ -399,43 +399,43 @@ well under a millisecond on a free CPU, yet structurally identical to the big id
   | **Survivor** | `RETREAT` | reset spacing when it can't swing |
   | **Baiter** | `IDLE` | wait / bait a whiff |
   | **Defender** | `BLOCK` | guard the player's melee when it can't punish |
-  | **Punisher** | — *(modulator)* | detects "the player is open / recovering" |
-  | **Enrage** | — *(modulator)* | detects "we're low on HP → go berserk" |
-- **`RecursiveLink`** — a ReGLU + residual block that merges the six latents into **one shared latent** (the "bridge").
-- **Coordinator** — a linear read-out of the shared latent that nudges every action's score.
+  | **Punisher** | - *(modulator)* | detects "the player is open / recovering" |
+  | **Enrage** | - *(modulator)* | detects "we're low on HP → go berserk" |
+- **`RecursiveLink`** - a ReGLU + residual block that merges the six latents into **one shared latent** (the "bridge").
+- **Coordinator** - a linear read-out of the shared latent that nudges every action's score.
 
 ### What every specialist is doing *at one moment* (a single decision tick)
 A souls boss commits to one move at a time, so the brain only fires when the boss is free
 (~2–4 times/second). In that one forward pass, **all six specialists run in parallel**:
 
-1. **Perceive** — the live game state is compressed to a **10-D feature vector** (distance, in-range?, boss HP, player HP, cooldown ready?, is the player attacking / recovering / blocking?).
-2. **Specialise** — each specialist computes `h = tanh(W₁·features)` and emits a **latent vector** `zᵢ` (its "opinion"); the four action-owners also emit a scalar **drive** for their move.
-3. **Communicate** — the six latents are summed and pushed through the **`RecursiveLink`** to form the **shared latent** `s`. This is the only channel the **modulators** have: *Punisher* writes "player is open" and *Enrage* writes "HP is low" into `s` — they cast no direct vote.
-4. **Coordinate** — the **coordinator** reads `s` and produces a **modulation** added to each action's score. So `score(action) = (owner's drive) + (coordinator modulation)`. This is where "the player is open" turns *Aggressor's* CLEAVE up, or "we're low HP" makes the boss commit harder.
-5. **Act** — the boss takes the top-scoring legal action (CLEAVE is masked while on cooldown). A small per-difficulty *mistake rate* adds the easy/normal/hard feel.
+1. **Perceive** - the live game state is compressed to a **10-D feature vector** (distance, in-range?, boss HP, player HP, cooldown ready?, is the player attacking / recovering / blocking?).
+2. **Specialise** - each specialist computes `h = tanh(W₁·features)` and emits a **latent vector** `zᵢ` (its "opinion"); the four action-owners also emit a scalar **drive** for their move.
+3. **Communicate** - the six latents are summed and pushed through the **`RecursiveLink`** to form the **shared latent** `s`. This is the only channel the **modulators** have: *Punisher* writes "player is open" and *Enrage* writes "HP is low" into `s` - they cast no direct vote.
+4. **Coordinate** - the **coordinator** reads `s` and produces a **modulation** added to each action's score. So `score(action) = (owner's drive) + (coordinator modulation)`. This is where "the player is open" turns *Aggressor's* CLEAVE up, or "we're low HP" makes the boss commit harder.
+5. **Act** - the boss takes the top-scoring legal action (CLEAVE is masked while on cooldown). A small per-difficulty *mistake rate* adds the easy/normal/hard feel.
 
-That whole loop is the **4-bar specialist panel + shared-latent strip** you see updating in the game — a live X-ray of the model thinking.
+That whole loop is the **4-bar specialist panel + shared-latent strip** you see updating in the game - a live X-ray of the model thinking.
 
 ### How it learned
 Trained by **self-play REINFORCE** (policy gradient + value baseline) in a headless duel
 simulator: reward = *damage dealt − damage taken*, plus shaping that rewards pressuring in
 range and punishes stalling. Over ~700 batches the win-rate climbed against a near-optimal
-dodging opponent and the tactics — spacing, punishing recovery frames, blocking your punish,
-enraging at low HP — **emerged**; none of it is hand-scripted. The **difficulty tiers are the
+dodging opponent and the tactics - spacing, punishing recovery frames, blocking your punish,
+enraging at low HP - **emerged**; none of it is hand-scripted. The **difficulty tiers are the
 same trained brain at different decision-noise levels** (Easy makes more exploitable mistakes,
 Hard plays sharp ≈0.95 win vs the dodger).
 
 ### Why the structure matters
-- **Modular** — you can retrain or swap one specialist without touching the others (e.g. the **Defender/BLOCK** specialist was added later and the rest were untouched).
-- **Explainable** — at any instant you can read *which* specialist drove the decision and how the modulators bent it.
-- **Cheap** — specialists are small and run in parallel; the latent bridge is one tiny matmul.
+- **Modular** - you can retrain or swap one specialist without touching the others (e.g. the **Defender/BLOCK** specialist was added later and the rest were untouched).
+- **Explainable** - at any instant you can read *which* specialist drove the decision and how the modulators bent it.
+- **Cheap** - specialists are small and run in parallel; the latent bridge is one tiny matmul.
 
 ### It finetunes from *your* fights (online learning)
-Because the model is tiny, a gradient step is microseconds — so the boss can learn
+Because the model is tiny, a gradient step is microseconds - so the boss can learn
 from real play **on this CPU**. Every HARD-tier fight is logged (state, action, HP per
 decision) and sent to a `/learn` endpoint; we rebuild the per-decision rewards (damage
 dealt − taken, + kill / − death), compute REINFORCE returns, and take **one Adam step**
-that nudges the HARD brain toward what worked against real humans — the backprop is
+that nudges the HARD brain toward what worked against real humans - the backprop is
 hand-written in numpy and verified against PyTorch to ~1e-8. A frozen copy of the
 sim-trained weights is an **anchor** (gentle pull-back) so it can't drift into nonsense,
 and with a `HF_TOKEN` + `MM_DATASET_REPO` secret the adapted weights persist to a
@@ -446,28 +446,28 @@ stays on-policy.)
 USES_MD = r"""
 ## 🌍 Three real-world applications of this architecture
 
-The reusable idea isn't "a boss" — it's **small, independently-trainable specialists that
+The reusable idea isn't "a boss" - it's **small, independently-trainable specialists that
 coordinate through a shared latent instead of through brittle hand-written rules or one giant
 monolithic model.** That pattern transfers well beyond games:
 
 **1. On-device / edge robotics & IoT control.**
 A drone, robot arm, or wearable can't run a huge policy. Give it a handful of tiny specialists
-— *balance*, *obstacle-avoidance*, *navigation*, *battery/thermal management* — each cheap
+- *balance*, *obstacle-avoidance*, *navigation*, *battery/thermal management* - each cheap
 enough for a microcontroller, coordinating through one shared latent. You can **add or replace
 a specialist** (e.g., a new sensor) without retraining the whole stack, and the latent bridge
-fuses their context in a single cheap step — exactly what this boss does at 2–4 Hz on a CPU.
+fuses their context in a single cheap step - exactly what this boss does at 2–4 Hz on a CPU.
 
 **2. Explainable, designer-tunable AI for games & simulations.**
 Studios want NPC/boss/crowd AI that's *steerable and inspectable*, not a black box. With this
 pattern a designer can tune or hot-swap one behavior specialist (more aggressive, more cautious)
-and **see exactly which specialist fired** for any decision — the same live panel shown here.
+and **see exactly which specialist fired** for any decision - the same live panel shown here.
 That makes balancing, debugging, and difficulty tuning tractable in ways a single end-to-end
 policy isn't.
 
 **3. Modular AI agents / mixture-of-specialists that talk in latent space.**
 The original Modular Mind motivation: instead of an "agent chain" that re-serializes everything
-to **text** at every hop (lossy, slow), let domain specialists — *math*, *code*, *retrieval*,
-*safety/policy* — communicate through a **latent bridge** (`RecursiveLink` + a residual highway
+to **text** at every hop (lossy, slow), let domain specialists - *math*, *code*, *retrieval*,
+*safety/policy* - communicate through a **latent bridge** (`RecursiveLink` + a residual highway
 for deep chains). A small language model can consult a math or tool specialist **without
 flattening to tokens**, each specialist is trained/upgraded independently, and the system stays
 auditable. Useful for cost-sensitive assistants, industrial decisioning (risk + liquidity +
@@ -476,14 +476,14 @@ fraud specialists), or clinical triage (modular diagnostic experts) where you mu
 
 
 PIANO_INTRO = """
-### 🎹 Bonus: a self-playing piano — same Modular Mind method, trained on a song
+### 🎹 Bonus: a self-playing piano - same Modular Mind method, trained on a song
 Under the boss fight, the *same architecture* (tiny specialists → `RecursiveLink` → a coordinator)
 applied to **playing piano in chords**. It was trained by **multi-note next-frame prediction** on a
 *polyphonic* transcription of a song: six specialists (Bass / Tenor / Soprano registers + Sustain /
 Onset / Phrase modulators) emit latents, the bridge merges them, and the coordinator picks the **set
 of notes** to play next. It plays itself with **real recorded acoustic-piano samples**. Press **play**
 and watch the keys + specialists light up.
-<sub>Rough by design — one song, a tiny model, crude polyphonic transcription — the *method carrying over* is the point.</sub>
+<sub>Rough by design - one song, a tiny model, crude polyphonic transcription - the *method carrying over* is the point.</sub>
 """
 
 with gr.Blocks(theme=gr.themes.Base(), title="Quazim0t0's 🍄 Thousand Token Wood Entry", head=HEAD) as demo: