File size: 2,688 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 | """Tournament-based relative-ranking optimization of the mind supernet (Sec 4.4).
For each query, sample K flows from the controller, execute them, rank the K ideas
with the anchor-based tournament, convert ranks -> quantile rewards (Eq 11) ->
standardized advantages (Eq 12), and update the controller by REINFORCE (Eq 13).
"""
from __future__ import annotations
import numpy as np
import torch
from .flow import execute_flow
from .tournament import tournament_rank, pointwise_scores
from . import llm
def make_context(topic, related, limit=5):
rw = "\n".join(f"- {r}" for r in (related or [])[:limit]) or "(none)"
return f"Topic: {topic}\nRelated works:\n{rw}"
def _execute_group(flows, topic, related, gen_model, base_seed, workers=6):
def run(k):
seq = flows[k][0]
idea, _ = execute_flow(seq, topic, related, model=gen_model, seed=base_seed + k * 97)
return idea
return llm.parallel_map(run, list(range(len(flows))), workers=workers)
def train_step(net, opt, query, K, gen_model, judge_model, rng, lam=0.02, seed=0,
reward_mode="tournament", workers=6):
topic, related = query["topic"], query["related"]
ctx = make_context(topic, related)
flows = [net.sample_flow(topic, rng) for _ in range(K)]
ideas = _execute_group(flows, topic, related, gen_model, seed, workers=workers)
costs = np.array([net.flow_cost(seq) for seq, _ in flows], dtype=float)
cost_norm = costs / max(costs.max(), 1.0)
if reward_mode == "tournament":
ranks, scores = tournament_rank(ideas, ctx, model=judge_model, seed=seed)
r = 1.0 - np.array(ranks, dtype=float) / max(K - 1, 1) - lam * cost_norm
quality = 1.0 - np.array(ranks, dtype=float) / max(K - 1, 1) # rank-quality for logging
else: # pointwise scalar reward baseline (judgment collapse)
ps = np.array(pointwise_scores(ideas, ctx, model=judge_model, seed=seed), dtype=float)
r = ps / 10.0 - lam * cost_norm
quality = ps / 10.0
adv = (r - r.mean()) / (r.std() + 1e-6)
# REINFORCE update
opt.zero_grad()
loss = torch.tensor(0.0)
for k in range(K):
logp = net.log_prob(topic, flows[k][1])
loss = loss - float(adv[k]) * logp
loss = loss / K
loss.backward()
torch.nn.utils.clip_grad_norm_(net.parameters(), 5.0)
opt.step()
return {
"loss": float(loss.item()),
"reward_mean": float(r.mean()),
"reward_std": float(r.std()),
"quality_mean": float(quality.mean()),
"quality_spread": float(quality.max() - quality.min()),
"flows": [flows[k][0] for k in range(K)],
"ideas": ideas,
"ctx": ctx,
}
|