File size: 5,994 Bytes
448d6a5 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 | """Mind supernet + topic-aware controller (Sec 4.2 / 4.3).
Mind supernet M (Def 4.3): layer-wise operator inclusion probabilities
pi_l(O) = p(O | Pi_<l, x_t) in (0,1).
Controller Q_phi (Eq. 10) samples a flow G layer by layer; the joint over flows
is the product of per-operator Bernoullis (Eq. 7). Optimised by REINFORCE
(Eq. 13). We parameterise pi_l(O | x_t) = sigmoid(w_{l,O} . e(x_t) + b_{l,O})
with e(x_t) a frozen sentence embedding of the topic -> genuinely topic-aware,
small and optimisable.
"""
from __future__ import annotations
import threading
import numpy as np
import torch
import torch.nn as nn
from functools import lru_cache
from .operators import REFINE_OPS, EXIT, OPERATORS, OP_COST
CTRL_OPS = REFINE_OPS + [EXIT] # operators the controller decides per layer
OP_INDEX = {o: i for i, o in enumerate(CTRL_OPS)}
# Hard cap on the number of refinement operators in a flow. Without it, REINFORCE
# drives inclusion probabilities up and flows grow unbounded (runtime + cost blow up).
# The paper's flows (Fig. 3) are ~3-5 operators; we cap total refine ops accordingly.
MAX_FLOW_OPS = 5
MAX_OPS_PER_LAYER = 2
_embedder = None
_embedder_lock = threading.Lock()
_encode_lock = threading.Lock()
def get_embedder():
global _embedder
if _embedder is None:
with _embedder_lock: # thread-safe single load (avoid concurrent init segfault)
if _embedder is None:
from sentence_transformers import SentenceTransformer
_embedder = SentenceTransformer("sentence-transformers/all-MiniLM-L6-v2")
return _embedder
def encode(texts, normalize=True):
"""Single choke-point for all SentenceTransformer encodes. Serialized with a
lock because concurrent torch forwards from worker threads segfault on macOS."""
with _encode_lock:
return get_embedder().encode(list(texts), normalize_embeddings=normalize)
@lru_cache(maxsize=4096)
def embed_topic(topic: str):
e = encode([topic])[0]
return tuple(float(x) for x in e)
class MindSupernet(nn.Module):
def __init__(self, emb_dim=384, n_layers=3, init_bias=-0.4, seed=0):
super().__init__()
self.n_layers = n_layers
self.n_ops = len(CTRL_OPS)
g = torch.Generator().manual_seed(seed)
# topic-conditioned linear head per (layer, op)
self.W = nn.Parameter(0.02 * torch.randn(n_layers, self.n_ops, emb_dim, generator=g))
# bias: modest prior to include refine ops, discourage early Exit
b = torch.full((n_layers, self.n_ops), float(init_bias))
b[:, OP_INDEX[EXIT]] = -1.0
self.b = nn.Parameter(b)
def logits(self, e_x: torch.Tensor) -> torch.Tensor:
# e_x: [emb_dim] -> [n_layers, n_ops]
return torch.einsum("lod,d->lo", self.W, e_x) + self.b
def probs(self, topic: str) -> torch.Tensor:
e = torch.tensor(embed_topic(topic), dtype=torch.float32)
return torch.sigmoid(self.logits(e)) # [L, n_ops] in (0,1)
# ---- stochastic sampling (training) -------------------------------------
def sample_flow(self, topic, rng: np.random.Generator, temperature=1.0):
"""Sample a thinking flow. Returns (op_sequence, layers) where op_sequence is
the linear execution order of refinement operators (Generate is prepended by
the executor); layers is list of per-layer chosen CTRL_OPS subsets."""
p = self.probs(topic).detach().numpy()
if temperature != 1.0:
# temperature on the odds
p = 1.0 / (1.0 + ((1 - p) / np.clip(p, 1e-6, 1)) ** (1.0 / temperature))
layers, seq = [], []
for l in range(self.n_layers):
chosen = [o for o in CTRL_OPS if rng.random() < p[l, OP_INDEX[o]]]
layers.append(chosen) # full Bernoulli sample -> used by log_prob (Eq. 7)
exit_here = EXIT in chosen
# execution order: top ops by prob, capped per-layer and by total flow length
refine = sorted([o for o in chosen if o != EXIT], key=lambda o: -p[l, OP_INDEX[o]])
refine = refine[:MAX_OPS_PER_LAYER][: max(0, MAX_FLOW_OPS - len(seq))]
seq.extend(refine)
if exit_here or len(seq) >= MAX_FLOW_OPS:
break
return seq, layers
# ---- deterministic top-p rollout (deployment / eval) --------------------
def rollout_flow(self, topic, threshold=0.6):
p = self.probs(topic).detach().numpy()
layers, seq = [], []
for l in range(self.n_layers):
order = sorted(CTRL_OPS, key=lambda o: -p[l, OP_INDEX[o]])
cum, chosen = 0.0, []
for o in order:
chosen.append(o)
cum += p[l, OP_INDEX[o]]
if cum >= threshold:
break
layers.append(chosen)
exit_here = EXIT in chosen
refine = [o for o in chosen if o != EXIT][:MAX_OPS_PER_LAYER][: max(0, MAX_FLOW_OPS - len(seq))]
seq.extend(refine)
if exit_here or len(seq) >= MAX_FLOW_OPS:
break
return seq, layers
# ---- log Q_phi(G | x) (Eq. 7 / 10) --------------------------------------
def log_prob(self, topic, layers) -> torch.Tensor:
e = torch.tensor(embed_topic(topic), dtype=torch.float32)
logit = self.logits(e) # [L, n_ops]
logp = torch.tensor(0.0)
used = len(layers)
for l in range(used):
chosen = set(layers[l])
for o in CTRL_OPS:
pi = torch.sigmoid(logit[l, OP_INDEX[o]])
pi = torch.clamp(pi, 1e-6, 1 - 1e-6)
if o in chosen:
logp = logp + torch.log(pi)
else:
logp = logp + torch.log(1 - pi)
return logp
def flow_cost(self, seq):
return float(sum(OP_COST.get(o, 1.0) for o in seq)) + 1.0 # +1 for Generate
def flow_signature(seq):
return "Generate -> " + (" -> ".join(seq) if seq else "(exit)")
|