Text Generation
Transformers
Chinese
English
character-level
chinese
gru
mamba
Mixture of Experts
titans
Instructions to use masterofthestars/tianxuan with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use masterofthestars/tianxuan with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="masterofthestars/tianxuan")# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("masterofthestars/tianxuan", device_map="auto") - Notebooks
- Google Colab
- Kaggle
- Local Apps Settings
- vLLM
How to use masterofthestars/tianxuan with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "masterofthestars/tianxuan" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'Use Docker
docker model run hf.co/masterofthestars/tianxuan
- SGLang
How to use masterofthestars/tianxuan with SGLang:
Install from pip and serve model
# Install SGLang from pip: pip install sglang # Start the SGLang server: python3 -m sglang.launch_server \ --model-path "masterofthestars/tianxuan" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }'Use Docker images
docker run --gpus all \ --shm-size 32g \ -p 30000:30000 \ -v ~/.cache/huggingface:/root/.cache/huggingface \ --env "HF_TOKEN=<secret>" \ --ipc=host \ lmsysorg/sglang:latest \ python3 -m sglang.launch_server \ --model-path "masterofthestars/tianxuan" \ --host 0.0.0.0 \ --port 30000 # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:30000/v1/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "masterofthestars/tianxuan", "prompt": "Once upon a time,", "max_tokens": 512, "temperature": 0.5 }' - Docker Model Runner
How to use masterofthestars/tianxuan with Docker Model Runner:
docker model run hf.co/masterofthestars/tianxuan
Tianxuan: full project + data (checkpoints, world_model, data without raw) with correct directory structure
db7bc06 Download src/ml/engine.ts from masterofthestars/tianxuan: direct link, hf CLI and curl.
- Browser
- Download file 55.8 kB
-
https://huggingface.co/masterofthestars/tianxuan/resolve/main/src/ml/engine.ts
- Command line
-
hf download hf://masterofthestars/tianxuan/src/ml/engine.ts
-
curl -L -o engine.ts https://huggingface.co/masterofthestars/tianxuan/resolve/main/src/ml/engine.ts
55.8 kB
import * as fs from "fs";
import * as path from "path";
import { CharGRU, CharGRUConfig, GRUState } from "./gru";
export type { GRUState };
import { CharMultiNeuro, CharMultiNeuroConfig } from "./multineuro";
import { CharTokenizer } from "./tokenizer";
import { CharTransformer, CharTransformerConfig } from "./transformer";
import { mulberry32 } from "./rng";
import { visionFront, speechFront } from "./frontends";
export { visionFront, speechFront };
import { createStation } from "../station";
import { L0Consistency } from "../station/l0probe";
import { Task, TaskResult } from "../station/types";
import { VectorStore } from "./vectorstore";
import { CNVectorStore } from "./cn_vectorstore";
import { MathVectorStore } from "./math_vectorstore";
import { WorldModel } from "./world_model";
import { TitansMemory } from "./titans";
export type { TitansConfig } from "./titans";
import { ConfidenceFloors } from "./floors";
import { chunkText } from "./data";
import { ContextWindow } from "./tool_system";
import { reflect, loadBigrams } from "./reflection";
export interface CheckpointMeta {
config: CharGRUConfig;
paramCount: number;
corpusTokens: number;
epochs: number;
vocab: string[];
trainedAt: string;
/** 是否由 CharMultiNeuro 训练 (含 MoE/专家头) */
multiNeuro?: boolean;
/** 是否由 CharTransformer 训练 */
transformer?: boolean;
moeTopK?: number;
moeGateHidden?: number;
moeNExperts?: number;
moeLoadBalanceWeight?: number;
onlineTitans?: boolean;
/** Transformer 配置 (可选) */
nLayer?: number;
nHead?: number;
/** Titans 记忆日志 (用于恢复记忆) */
titansWriteLog?: Array<{ slot: number; h1: number[] }>;
}
function sampleToken(probs: Float64Array, topK: number, temperature: number, rand: () => number): number {
// [P0-F 修复 2026-10-08 第一性审核] NaN 概率 (非有限 logits 经 logitsToProbs 返回) → 返回 -1,
// 调用方 charOf(-1) 无有效输出 (可证伪: 不伪造满置信的假输出)。
for (let i = 0; i < probs.length; i++) if (Number.isNaN(probs[i])) return -1;
const v = probs.length;
const scaled = new Float64Array(v);
let sum = 0;
for (let k = 0; k < v; k++) {
scaled[k] = Math.exp(Math.log(probs[k] + 1e-12) / Math.max(temperature, 1e-3));
sum += scaled[k];
}
const k = Math.min(topK, v);
const idxs = Array.from({ length: v }, (_, i) => i).sort((a, b) => scaled[b] - scaled[a]).slice(0, k);
let mass = 0;
for (const i of idxs) mass += scaled[i];
let r = rand() * mass;
for (const i of idxs) {
r -= scaled[i];
if (r <= 0) return i;
}
return idxs[idxs.length - 1];
}
export interface GenerateOptions {
prompt: string;
maxLen: number;
budget: number;
temperature: number;
topK: number;
seed?: number;
}
export interface CharRoute {
char: string;
depth: number;
confidence: number;
units: string[];
memoryHit: boolean;
/** 记忆来源:向量库 / 重复上下文 */
memorySource?: "vector" | "repeat" | "titans";
}
export interface GenerateResult {
text: string;
routes: CharRoute[];
budget: number;
}
/** 测试时记忆块标记:写入向量库的生成内容前缀,检索时跳过,防止自举循环 */
const MEMORY_TAG = "\uE000";
/**
* 推理引擎:模型 + 字符分词 + 工作站 (分级路由 + Titans L0 记忆)
* L0 记忆缓存直出 (零算力) → L1 浅路径 → L2 深路径 (预算内扩深)
*/
export class Engine {
readonly model: CharGRU;
readonly tokenizer: CharTokenizer;
readonly meta: CheckpointMeta;
private station = createStation();
private habit: () => number;
private memory = new Map<string, string>();
private ctxWin: number[] = [];
private store: VectorStore | null;
private recentChars: string[] = [];
private state: GRUState;
/** 在线神经记忆 (Titans 逻辑):上下文嵌入 → 下一字,生成期持续写入 */
private titansMem: TitansMemory;
/** 多神经协同模型 (含 MoE/专家头,可为 null) */
private ctxWinWindow: ContextWindow;
readonly multiNeuro: CharMultiNeuro | null;
/** 置信度下限追踪器 (宪章第1条: 兜底值由真实观测滚动窗口推导, 不写死常数) */
readonly floors: ConfidenceFloors;
/** L0 直出一致性探针 (宪章第7/8条: 在线记忆效果的量化证据, 非写死) */
readonly l0Probe: L0Consistency;
/** CN 语义向量库 (HNSW + N-gram 预过滤) */
private cnStore: CNVectorStore | null = null;
/** 数学向量库 (公式检索) */
private mathStore: MathVectorStore | null = null;
/** 推理协处理器 */
private _reasoner: any = null;
/** 世界模型 (物理常识 + 因果推理) */
private worldModel: WorldModel | null = null;
/** 语义反思层:n-gram 统计用于修正生成 */
private bigramStats: ReturnType<typeof loadBigrams> = null;
private constructor(model: CharGRU, tokenizer: CharTokenizer, meta: CheckpointMeta, multiNeuro: CharMultiNeuro | null = null, dataRoot = "data", prodRoot = "data", wmDir = "") {
this.model = model;
this.tokenizer = tokenizer;
this.meta = meta;
this.multiNeuro = multiNeuro;
this.habit = mulberry32(Date.now() % 2147483647);
this.floors = new ConfidenceFloors();
this.l0Probe = new L0Consistency();
this.state = model.newState();
// dataRoot = sandbox 数据根 (语料快照); prodRoot = 生产数据根 (bigram/世界模型/向量库, 只读)。
// 均由 load() 依 checkpoint 绝对路径锚定, 不依赖 cwd (宪章第10条: 生产 data/ 只读)。
// 逐资源: 优先 sandbox 根, 缺则回退生产根 → 既守沙箱纪律, 又不漏统计资源。
const pick = (rel: string): string => {
const sbx = path.join(dataRoot, rel);
return fs.existsSync(sbx) ? sbx : path.join(prodRoot, rel);
};
this.store = VectorStore.load(pick("vectorstore"));
if (this.store) console.log(`向量库已加载:${this.store.size} 块`);
this.cnStore = CNVectorStore.load(pick("cn_vectorstore"));
if (this.cnStore) console.log(`CN 语义库已加载:${this.cnStore.size} 块`);
this.mathStore = MathVectorStore.load(pick("math_vectorstore"));
if (this.mathStore) console.log(`数学库已加载:${this.mathStore.size} 条`);
// 尝试从 checkpoint 目录加载世界模型 (ckpt 自带 → 优先; 否则数据根; 宪章第10条 ckpt 只读)
const wmPath = wmDir && fs.existsSync(path.join(wmDir, "world_model", "world_model.json"))
? path.join(wmDir, "world_model")
: pick("world_model");
this.worldModel = WorldModel.load(wmPath);
if (this.worldModel) {
console.log(`世界模型已加载:${this.worldModel.paramCount()} 参数 (来源: ${wmPath})`);
} else {
console.log(`世界模型未找到:${wmPath}`);
}
this.titansMem = new TitansMemory({ dim: meta.config.emb, slots: 256 });
// 加载 bigram 统计(用于语义反思层)
this.bigramStats = loadBigrams(pick("bigrams.json"));
if (this.bigramStats) {
console.log(`Bigram 统计已加载:${this.bigramStats.total} bigrams, ${this.bigramStats.charFreq.size} unique chars`);
} else {
console.log(`Bigram 统计未找到:${path.join(prodRoot, "bigrams.json")} (将使用默认统计)`);
}
// 上下文窗口:滑动窗口管理对话历史
this.ctxWinWindow = new ContextWindow(meta.config.ctx * 10); // 10倍上下文
// 尝试从多个可能位置加载 Titans 记忆
const possiblePaths = [
path.join("sandbox", "ck-titans-test", "titans_memory.json"),
path.join("data", "checkpoints", "titans_memory.json"),
path.join("..", "sandbox", "ck-titans-test", "titans_memory.json"),
path.join("data", "titans_memory.json"),
];
let memoryPath = "";
for (const p of possiblePaths) {
if (fs.existsSync(p)) {
memoryPath = p;
break;
}
}
// 也检查当前 checkpoint 目录
const cwd = process.cwd();
const altPaths = [
path.join(cwd, "titans_memory.json"),
path.join(cwd, "sandbox", "ck-titans-test", "titans_memory.json"),
];
for (const p of altPaths) {
if (fs.existsSync(p)) {
memoryPath = p;
break;
}
}
if (fs.existsSync(memoryPath)) {
try {
const memData = JSON.parse(fs.readFileSync(memoryPath, "utf8"));
// 使用 Object.assign 绕过 readonly 限制
Object.assign(this.titansMem, {
chars: memData.chars,
keys: new Float64Array(memData.keys),
values: new Float64Array(memData.values),
persistent: new Float64Array(memData.persistent),
});
console.log(`已从文件加载 Titans 记忆:${this.titansMem.chars.filter((c: string) => c).length} 个非空槽位`);
} catch (e) {
console.warn(`加载 Titans 记忆失败:${e}`);
}
}
this.registerUnits();
// [R1-B1 修复 2026-10-09 第一性审核] 注入真实 model.step 上界给经济学:
// 全链全跑 = 注册单元数 (深链可达深度, 同深度取一故 = 最大 depth) + 1 (推进 advance)。
// 动态推导, 不再硬编码 4 (旧 B1: mamba/attn 关闭时分母失真)。
{
const textUnits = this.station.registry.computeUnits("text");
const maxDepth = textUnits.reduce((m, u) => Math.max(m, u.depth), 0);
const reachable = textUnits.filter((u) => u.cost > 0).length; // 单元前向 (同深度取一, ≈ maxDepth)
this.station.economics.setMaxRealForwards(Math.max(reachable, maxDepth) + 1);
}
}
/** 检索:把查询文本向量化,返回库内 top-k 片段 */
retrieve(q: string, k = 4): Array<{ text: string; score: number }> {
if (!this.store) return [];
const ids = this.tokenizer.encode(q);
return this.store.search(this.model.embedAvg(ids), k);
}
/** 中文语义检索 (CNVectorStore + HNSW + N-gram 预过滤) */
retrieveCN(q: string, k = 4, category?: string): Array<{ text: string; score: number; category?: string }> {
if (!this.cnStore) return [];
const ids = this.tokenizer.encode(q);
return this.cnStore.search(this.model.embedAvg(ids), k, category);
}
/** 数学公式检索 (语义 + 结构 + 关键词融合) */
retrieveMath(q: string, k = 6, category?: string): Array<{ expr: string; description: string; score: number; matchType: string }> {
if (!this.mathStore) return [];
const ids = this.tokenizer.encode(q);
const results = this.mathStore.search(q, this.model.embedAvg(ids), k, category);
return results.map(r => ({
expr: r.expr, description: r.description, score: r.score, matchType: r.matchType,
}));
}
/** 推理:概念理解 + 符号推导 + 物理方程求解 */
reason(q: string) {
const results: Array<{ type: string; content: string; score?: number }> = [];
// 1. 向量检索
if (this.cnStore) {
const cnHits = this.cnStore.search(this.model.embedAvg(this.tokenizer.encode(q)), 3);
for (const h of cnHits) results.push({ type: "cn", content: h.text, score: h.score });
}
if (this.mathStore) {
const mathHits = this.mathStore.search(q, this.model.embedAvg(this.tokenizer.encode(q)), 3);
for (const h of mathHits) results.push({ type: "math", content: h.expr + ": " + h.description, score: h.score });
}
// 2. 世界模型物理约束检查
if (this.worldModel) {
const traj = this.worldModel.simulate(
new Float64Array(this.model.embedAvg(this.tokenizer.encode(q))),
[0],
);
const phys = this.worldModel.evaluatePhysics(traj[0]?.state);
results.push({
type: "world_model",
content: `物理约束:能量=${phys[0].toFixed(3)} 因果=${phys[1].toFixed(3)} 平滑=${phys[2].toFixed(3)}`,
score: 1 - (phys[0] + phys[1] + phys[2]) / 3,
});
}
return { query: q, results, worldModel: this.worldModel };
}
retrieveCount(): number {
return this.store?.size ?? 0;
}
/**
* 测试时记忆:把生成内容切块写入向量库 (可持久化)。
* 宪章: 生产 data/ 只读 — 持久化目标参数化, 默认内存态不落盘。
* 传 dir 且指向沙箱路径时才写盘; 缺省仅在内存累加。
*/
remember(text: string, persistDir?: string): void {
if (!this.store) return;
let added = 0;
for (const chunk of chunkText(text, 64, 32)) {
if (chunk.length < 8) continue;
const ids = this.tokenizer.encode(chunk);
this.store.add(MEMORY_TAG + chunk, this.model.embedAvg(ids));
added += 1;
}
if (persistDir !== undefined && persistDir !== "") {
this.store.save(persistDir);
if (added > 0) console.log(`测试时记忆:新写入 ${added} 块 → ${persistDir},向量库现有 ${this.store.size} 块`);
} else if (added > 0) {
console.log(`测试时记忆:新写入 ${added} 块 (仅内存, 未持久化),向量库现有 ${this.store.size} 块`);
}
}
/** 采样前降权:近 16 个已出字符中重复≥2 次的禁出 + UNK 槽禁出 (防 12 字级自举循环) */
private penalized(probs: Float64Array): Float64Array {
const out = probs.slice();
out[out.length - 1] = 0;
const freq = new Map<string, number>();
for (const ch of this.recentChars) freq.set(ch, (freq.get(ch) ?? 0) + 1);
for (const [ch, count] of freq) {
if (count < 2) continue;
const id = this.tokenizer.idOf(ch);
if (id !== undefined && id < out.length) out[id] = 0;
}
let sum = 0;
for (let i = 0; i < out.length; i++) sum += out[i];
for (let i = 0; i < out.length; i++) out[i] /= sum;
return out;
}
private propose(ch: string): void {
this.recentChars.push(ch);
if (this.recentChars.length > 16) this.recentChars.shift();
}
/** 窥视:用当前状态副本推一步,不推进真实状态 */
private peekLogits(depth: 1 | 2 | 3 | 4): Float64Array {
const lastId = this.ctxWin.length > 0 ? this.ctxWin[this.ctxWin.length - 1] : 0;
const copy: GRUState = {
h1: this.state.h1.slice(),
h2: this.state.h2.slice(),
hist: this.state.hist.map((h) => h.slice()),
ids: [...this.state.ids],
};
return this.model.step(lastId, copy, depth);
}
/** 推进:真实状态吸收新字符 (depth = 路由实际执行到的最大深度, 默认 4) */
private advance(chId: number, depth: 1 | 2 | 3 | 4 = 4): void {
this.model.step(chId, this.state, depth);
// SNN 膜电位锁相推进 (与骨干同频, 每字一次)
if (this.multiNeuro?.spike) {
this.multiNeuro.spikeAdvance(chId);
}
}
/** SNN 膜电位重置 (生成开始时调用) */
private resetSpike(): void {
if (this.multiNeuro?.spike) {
this.multiNeuro.resetSpikeSeq();
}
}
/**
* [P0-B 修复 2026-10-08 第一性审核] 上下文指纹: 稳定 FNV-1a 哈希 (非 seed, 不随随机性变),
* 相同 ctxWin → 相同指纹。mem: 键绑定此指纹, 不同上下文的残留键天然失效。
*/
static ctxFingerprint(ctx: number[], vocabSize: number): string {
let h = 2166136261;
for (let i = 0; i < ctx.length; i++) {
h ^= ctx[i] % vocabSize;
h = Math.imul(h, 16777619);
}
return (h >>> 0).toString(16).padStart(8, "0");
}
private recallAt(ctxIds: number[]): { char: string; source: "vector" | "repeat" | "titans" } | null {
if (this.store) {
const q = this.tokenizer.decode(ctxIds);
const hits = this.store.search(this.model.embedAvg(ctxIds), 8);
for (const hit of hits) {
if (hit.text.startsWith(MEMORY_TAG)) continue;
const at = hit.text.indexOf(q);
if (at >= 0 && at + q.length < hit.text.length) {
const ch = hit.text[at + q.length];
if (this.isDegenerate(ch)) return null;
// [P0-A 补漏] 向量库召回: 历史上该上下文真实延续过 → 0.5 点火标记 (非写死满置信, 宪章第1条);
// executor L0 分支读 z:l0:act 推导置信度, 无写入 → 0, 冷启动不伪造满置信
this.station.blackboard.write("z:l0:act", 0.5);
return { char: ch, source: "vector" };
}
}
}
const cached = this.memory.get(ctxIds.join(","));
if (cached !== undefined && !this.isDegenerate(cached)) {
// 重复上下文缓存: 深链曾真实出过该字 → 0.5 点火标记 (同上)
this.station.blackboard.write("z:l0:act", 0.5);
return { char: cached, source: "repeat" };
}
// Titans 在线神经记忆:上下文嵌入检索 → 槽位存储的下一字符
const q = Float64Array.from(this.model.embedAvg(ctxIds));
const cache = { query: new Float64Array(0), keys: new Float64Array(0), values: new Float64Array(0), weights: new Float64Array(0) };
const mem = this.titansMem.read(q, cache);
if (mem.hitSlots > 0 && cache.weights.length > 0) {
let best = 0;
for (let i = 1; i < cache.weights.length; i++) if (cache.weights[i] > cache.weights[best]) best = i;
if (cache.weights[best] > 0.5) {
// 直接从 Titans 获取字符,不再依赖外部映射
const ch = this.titansMem.chars[best % this.titansMem.cfg.slots];
if (ch !== undefined && ch !== "" && !this.isDegenerate(ch)) {
const l0Act = mem.hitSlots / this.titansMem.cfg.slots; // 点火 = 命中槽占比 (真实数值)
this.station.blackboard.write("z:act:titans", l0Act);
this.station.blackboard.write("z:l0:act", l0Act);
return { char: ch, source: "repeat" };
}
}
}
return null;
}
/** 直接读取 Titan 记忆输出(用于 L0 直出) */
private getTitansOutput(ctxIds: number[]): string | null {
const q = Float64Array.from(this.model.embedAvg(ctxIds));
const cache = { query: new Float64Array(0), keys: new Float64Array(0), values: new Float64Array(0), weights: new Float64Array(0) };
const mem = this.titansMem.read(q, cache);
if (mem.hitSlots > 0 && cache.weights.length > 0) {
// 找到权重最大的多个槽位
const topSlots: number[] = [];
let maxWeight = 0;
for (let i = 0; i < cache.weights.length; i++) {
if (cache.weights[i] > maxWeight) {
maxWeight = cache.weights[i];
topSlots.length = 0;
topSlots.push(i);
} else if (cache.weights[i] > maxWeight * 0.9) { // 接近最大的也考虑
topSlots.push(i);
}
}
if (topSlots.length > 0 && maxWeight > 0.3) {
// 从 top 槽位中选择一个非空字符
for (const slot of topSlots) {
const ch = this.titansMem.chars[slot % this.titansMem.cfg.slots];
if (ch !== undefined && ch !== "" && !this.isDegenerate(ch)) {
this.station.blackboard.write("z:act:titans", mem.hitSlots / this.titansMem.cfg.slots);
return ch;
}
}
}
}
return null;
}
/** L0 一致性探针 (宪章第7/8条): 同上下文深链 top-1 字 (peekLogits 无副作用: 状态副本推进, 不污染当前生成状态) */
deepTop1At(ctxIds?: number[]): { char: string; p: number } {
const logits = this.peekLogits(4);
const probs = this.model.logitsToProbs(logits);
let best = 0;
for (let i = 1; i < probs.length; i++) if (probs[i] > probs[best]) best = i;
return { char: this.tokenizer.charOf(best), p: probs[best] };
}
/** 循环防护:连续相同字符 ≥4 次或最近 8 字符整段重复,判定为退化输出 */
private isDegenerate(ch: string): boolean {
// 只检测连续重复,不检测全局频率
const n = this.recentChars.length;
if (n >= 3) {
const last3 = this.recentChars.slice(-3).join("");
if (last3 === ch.repeat(3)) return true;
}
if (n >= 16) {
const a = this.recentChars.slice(-8).join("");
const b = this.recentChars.slice(-16, -8).join("");
if (a === b) return true;
}
return false;
}
static load(checkpointDir: string): Engine {
const meta = JSON.parse(fs.readFileSync(path.join(checkpointDir, "meta.json"), "utf-8")) as CheckpointMeta;
const params = JSON.parse(fs.readFileSync(path.join(checkpointDir, "model.json"), "utf-8")) as number[];
const tokenizer = new CharTokenizer();
tokenizer.load(meta.vocab);
// [P0-F 修复 2026-10-08 第一性审核] 推理侧非有限参数拒载: 检查点若被污染 (含 NaN/Inf),
// 拒绝载入 — 旧实现 Engine.load 直接 load(params) 不扫描, 污染检查点 (85.8% +Inf)
// 载入后置信度恒 1.0, 健康监控 nan:0 永不降级, 生成 avgFinalConf≈1.0 而真实输出是噪声。
// 与 train.ts resume 防护 (防线 3) 同逻辑: 任一非有限 → 抛错拒载。
{
let bad = 0;
for (let i = 0; i < params.length; i++) if (!Number.isFinite(params[i])) bad++;
if (bad > 0) {
throw new Error(
`[推理防护] ${checkpointDir}/model.json 含 ${bad}/${params.length} 非有限参数 (NaN/Inf), ` +
`检查点已被污染, 拒绝载入。请回退到更早的完好检查点。`
);
}
}
let multiNeuro: CharMultiNeuro | null = null;
let baseModel: CharGRU;
if (meta.transformer) {
// Transformer 检查点路径
const tCfg: CharTransformerConfig = {
vocabSize: tokenizer.vocabSize,
emb: (meta.config as any).emb ?? 64,
nLayer: (meta.config as any).nLayer ?? 2,
nHead: (meta.config as any).nHead ?? 2,
ctx: (meta.config as any).ctx ?? 8,
bptt: (meta.config as any).bptt ?? 32,
};
const transformer = new CharTransformer(tCfg, 1);
if (transformer.paramCount() !== params.length) {
throw new Error(`checkpoint 参数数量与配置不匹配:${transformer.paramCount()} != ${params.length}`);
}
transformer.load(params);
// 包装为 GRU 接口兼容层
baseModel = new CharGRU({
vocabSize: tCfg.vocabSize,
emb: tCfg.emb,
hidden: tCfg.emb,
ctx: tCfg.ctx,
bptt: tCfg.bptt,
}, 1);
// 将 transformer 包装到 baseModel 上
(baseModel as any)._transformer = transformer;
(baseModel as any).step = function(xId: number, state: GRUState, depth?: number): Float64Array {
const t = (this as any)._transformer;
if (!t) return new Float64Array(0);
const tState: any = (this as any)._tState ?? ((this as any)._tState = t.newState());
// 路由深度: 允许 1..nLayer 裁剪 (MoD 预算内扩深/裁剪)
const d = Math.max(1, Math.min(depth ?? t.cfg.nLayer, t.cfg.nLayer));
return t.step(xId, tState, d) as Float64Array;
};
} else if (meta.multiNeuro) {
const cfg: CharMultiNeuroConfig = {
...meta.config,
moeTopK: meta.moeTopK ?? 2,
moeGateHidden: meta.moeGateHidden ?? 32,
moeLoadBalanceWeight: meta.moeLoadBalanceWeight ?? 0.01,
onlineTitans: meta.onlineTitans ?? false,
moeNExperts: meta.moeNExperts ?? 4,
// SNN 脉冲支路 (独立参数, 与 checkpoint 训练时一致)
snn: (meta.config as CharMultiNeuroConfig).snn ?? false,
snnLeak: (meta.config as CharMultiNeuroConfig).snnLeak,
snnThresh: (meta.config as CharMultiNeuroConfig).snnThresh,
};
multiNeuro = new CharMultiNeuro(cfg, 1);
if (multiNeuro.paramCount() !== params.length) {
throw new Error(`checkpoint 参数数量与配置不匹配:${multiNeuro.paramCount()} != ${params.length}`);
}
multiNeuro.load(params);
baseModel = multiNeuro.model;
// 恢复 Titans 记忆 (如果有的话)
if (meta.onlineTitans && meta.titansWriteLog && meta.titansWriteLog.length > 0) {
const log = multiNeuro.getTitansWriteLog();
for (const rec of meta.titansWriteLog as any[]) {
const h1 = new Float64Array(rec.h1);
log.push({ slot: rec.slot, h1: h1 });
}
console.log(`恢复 Titans 记忆:${meta.titansWriteLog.length} 条记录`);
// 直接从日志重建 Titans 记忆槽位
const titansMem = new TitansMemory({ dim: meta.config.emb, slots: 256 });
const dim = meta.config.emb;
for (const rec of meta.titansWriteLog as any[]) {
const h1 = new Float64Array(rec.h1);
const slot = rec.slot % titansMem.cfg.slots;
// 从词表中选择合适的字符(高频字)
const vocab = meta.vocab;
titansMem.chars[slot] = vocab[rec.slot % vocab.length] || "。";
for (let i = 0; i < dim; i++) {
titansMem.keys[slot * dim + i] = h1[i];
titansMem.values[slot * dim + i] = h1[i];
}
}
console.log(`重建 Titans 记忆槽位:${titansMem.chars.filter((c: string) => c).length} 个非空槽位`);
}
} else {
baseModel = new CharGRU(meta.config, 1);
if (baseModel.paramCount() !== params.length) {
throw new Error(`checkpoint 参数数量与配置不匹配:${baseModel.paramCount()} != ${params.length}`);
}
baseModel.load(params);
}
// 统一在这里创建 Engine,避免 multiNeuro=null 导致多神经协同功能失效
// 宪章第10条: 生产 data/ 只读 — 数据根从 checkpoint 目录推导 (sandbox 检查点 → <root>/sandbox/data, 生产检查点 → <root>/data)
// [FIX 2026-10-06] 旧逻辑用相对 "sandbox/data", 脚本 cd sandbox 后跑 generate 时拼成
// sandbox/sandbox/data → bigram/世界模型静默缺失 (gen-smoke 置信 0.00 即因此)。
// 现锚定到 ck 绝对路径里 sandbox/data 段的位置, 子目录检查点 (checkpoints-mamba/…) 也解析对。
const ckAbs = path.resolve(checkpointDir);
const parts = ckAbs.split(path.sep);
const iSbx = parts.lastIndexOf("sandbox");
const iData = parts.lastIndexOf("data");
// 项目根 = sandbox 段 (或生产 ck 的 data 段) 之前的那一段 → 全绝对, 不依赖 cwd。
const projRoot = (iSbx >= 0 ? parts.slice(0, iSbx) : iData >= 0 ? parts.slice(0, iData) : []).join(path.sep)
|| process.cwd();
// sandbox 数据根: 语料快照; 生产数据根: bigram/世界模型/向量库 (只读)
const dataRoot = iSbx >= 0 ? path.join(projRoot, "sandbox", "data") : path.join(projRoot, "data");
const prodRoot = path.join(projRoot, "data");
const eng = new Engine(baseModel, tokenizer, meta, multiNeuro, dataRoot, prodRoot, checkpointDir);
return eng;
}
private registerUnits(): void {
this.registerUnitsTo(this.station.registry, this.station.economics);
}
/**
* [P0-2 修复 2026-10-13 第一性审核] 把引擎侧计算单元注册到任意工作站注册表,
* 并同步注入经济学的真实 model.step 上界。
* 背景: SessionEngine 每会话自建 createStation(), 旧实现其 station 注册表只有
* SEED 种子 (text 链零单元) → executor 恒走「零单元」分支, MoD 路由/审计/经济性
* 在服务器路径上是死代码 (真实输出字来自 peekLogits(4) 全深兜底, 审计记 depth=0)。
* 现: SessionEngine 构造时对 baseEngine 调本方法, 把与共享 Engine 完全相同的
* 计算单元 (titans/gru/mamba/attn/cnn/snn/world/vision/speech/output) 注入
* 会话工作站 → 服务器路径多神经协同真跑 (宪章第1/2条)。
* 单元 forward 闭包引用的 engine/model/titansMem/floors 均为 baseEngine 共享只读
* 资源; 黑板键带 task.id (每会话独立编号+上下文指纹), 会话间无串读。
*/
registerUnitsTo(reg: import("../station/registry").Registry, economics?: import("../station/economics").OnDemandEconomics): void {
const engine = this;
// L0 — Titans 记忆 (零算力直出,depth 0)
// [P1-H 修复 2026-10-08 第一性审核] structural 白名单化: 豁免须 evidence.status!=="fail"
// + note 含 checkpoint 证据物。titans SEED 证据 status="fail" (一致性 33.8% < 0.5 门槛)
// → 不得豁免, 保持 enabled=false (与 SEED registry 一致)。
if (this.meta.onlineTitans) {
reg.register({
kind: "titans", name: "Titans 记忆", role: "L0 零算力记忆直出", stage: "phase3", enabled: false, status: "idle",
structural: true,
justification: "在线神经记忆:上下文嵌入检索 → 槽位字符输出 (已训 checkpoint 结构层); SEED 证据 L0 一致性 33.8% < 0.5 门槛 (fail) → 不得豁免 (P1-H 白名单化), 保持货架待大语料重测",
evidence: { metric: "L0 直出一致性 (探针 l0-probe-check.js)", baseline: 0.5, result: 0.338, status: "fail", note: "2026-10-05 L0 一致性探针: 命中率 77.1% 但一致性 33.8% < 0.5 — 省算力真实, 正确性收益未过门槛; P1-H 白名单化后 fail 证据不得 structural 豁免 (宪章第7条), 待健康检查点重测" },
compute: {
unitId: "titans:depth0", depth: 0, cost: 0, chains: ["text"],
forward: async (task, state) => {
// 直接从 TitansMemory 检索最佳槽位
const ctx = task.input as number[];
const q = Float64Array.from(engine.model.embedAvg(ctx));
const cache = { query: new Float64Array(0), keys: new Float64Array(0), values: new Float64Array(0), weights: new Float64Array(0) };
const mem = engine.titansMem.read(q, cache);
if (mem.hitSlots > 0 && cache.weights.length > 0) {
let best = 0;
for (let i = 1; i < cache.weights.length; i++) if (cache.weights[i] > cache.weights[best]) best = i;
if (cache.weights[best] > 0.3) {
const ch = engine.titansMem.getChar(best % engine.titansMem.cfg.slots);
if (ch !== undefined && ch !== "" && !engine.isDegenerate(ch)) {
// 同时写入 mem 和 o,确保 L0 路径能检测到
state.data[`mem:${task.id}`] = ch;
state.data[`o:${task.id}`] = ch;
state.data["z:act:titans"] = mem.hitSlots / engine.titansMem.cfg.slots;
const conf = Math.min(1, mem.hitSlots / 5); // 归一化置信度
engine.floors.record("titans:depth0", conf);
return conf;
}
}
}
// 无命中兜底: 由本单元真实观测的最低置信度推导 (冷启动=0, 非写死常数, 宪章第1条)
return engine.floors.fallback("titans:depth0");
},
},
});
}
// 感知神经:第 1 层 GRU(emb → 状态流),神经链入口
reg.register({
kind: "gru", name: "GRU L1", role: "感知:字符嵌入 → 状态流", stage: "phase1", enabled: true, status: "idle",
roleTag: "perception",
structural: true,
justification: "基线状态流;无此层无任何输出 (已训骨干结构层, 推理分布一致性豁免证据门槛)",
compute: {
unitId: "gru:shallow", depth: 1, cost: 1, chains: ["text"],
forward: async (task, state) => {
const logits = engine.peekLogits(1);
state.data[`z:logits:${task.id}`] = logits;
state.data["z:act:gru:shallow"] = engine.model.confidence(logits);
return engine.model.confidence(logits);
},
},
});
if (engine.model.cfg.mamba) {
// 中央神经 (快动力学):真选择性 SSM(depth 2),点火 = Δ 均值
// [P1-H 修复 2026-10-08 第一性审核] structural 白名单化: mamba SEED 证据 status="fail"
// (3 种子均值 Δ=+0.4pt < +1.0 门槛) → 不得豁免, 保持 enabled=false (宪章第7条)。
reg.register({
kind: "mamba", name: "Mamba", role: "快动力学:选择性 SSM 状态流", stage: "phase1", enabled: false, status: "idle",
roleTag: "central",
structural: true,
justification: "对照基线:线性状态建模 vs 纯骨干(同配置) (已训 checkpoint 中央结构层); P1-H 白名单化后 fail 证据不得豁免, 待大真实语料重测过门槛",
evidence: { metric: "事件语料 top-1(30k×4ep, 3 种子均值单变量消融)", baseline: 10.4, result: 10.8, status: "fail", note: "2026-10-05 ablation-mamba-multiseed.sh: 3 种子均值 Δ=+0.4pt < +1.0 门槛 → 未过 (单种子7 的 +1.7 为运气, seed3/11 Δ=0.0)。容量混淆已控 (on 190k < base 233k); 小语料噪声淹没效应; P1-H 白名单化: fail 证据不得 structural 豁免 (宪章第7条), 待大真实语料重测" },
compute: {
unitId: "mamba:ssm", depth: 2, cost: 2, chains: ["text"],
forward: async (task, state) => {
const logits = engine.peekLogits(2);
state.data[`z:logits:${task.id}`] = logits;
state.data["z:act:mamba:ssm"] = Math.min(1, engine.model.ssm!.lastDeltaMean / 1.5);
return engine.model.confidence(logits);
},
},
});
} else {
// 中央神经 (快动力学):GRU 第 2 层
reg.register({
kind: "gru", name: "GRU L2", role: "快动力学:第二层 GRU 状态流", stage: "phase1", enabled: true, status: "idle",
roleTag: "central",
structural: true,
justification: "共享底座深路径 (已训骨干结构层, 推理分布一致性豁免证据门槛)",
compute: {
unitId: "gru:deep", depth: 2, cost: 2, chains: ["text"],
forward: async (task, state) => {
const logits = engine.peekLogits(2);
state.data[`z:logits:${task.id}`] = logits;
state.data["z:act:gru:deep"] = engine.model.confidence(logits);
return engine.model.confidence(logits);
},
},
});
}
if (engine.model.cfg.attn) {
// 中央神经 (慢语义):学习型自注意力 (depth 3),点火 = gate
reg.register({
kind: "sparse-attention", name: "稀疏 Attention", role: "慢语义:学习型自注意力", stage: "phase2", enabled: true, status: "idle",
roleTag: "central",
structural: true,
justification: "跨位置信息混合,独立于循环路径;真实计算单元 (已训 checkpoint 中央结构层, 推理分布一致性豁免证据门槛)",
evidence: { metric: "事件语料 top-1(30k×2ep)", baseline: 49.1, result: 47.8, status: "pending", note: "机制正确+gate 选择性;任务级证据未达成; 已训 checkpoint 结构层 (attn 中央层), P1-H 白名单: pending+checkpoint 证据物允许豁免, 独立 Attention 系统仍守门槛" },
compute: {
unitId: "attn:layer3", depth: 3, cost: 3, chains: ["text"],
forward: async (task, state) => {
const logits = engine.peekLogits(3);
state.data[`z:logits:${task.id}`] = logits;
state.data["z:act:attn:layer3"] = engine.model.lastAttnGate;
return engine.model.confidence(logits);
},
},
});
}
if (engine.model.cfg.cnn) {
// 感知神经 (局部):1D 卷积 n-gram(depth 4),点火 = 特征激活均值
reg.register({
kind: "cnn", name: "CNN", role: "局部感知:1D 卷积 n-gram 特征", stage: "phase1", enabled: true, status: "idle",
roleTag: "perception",
justification: "局部字符模式特征,独立预测头与循环/注意力输出融合 (pass 证据直接过门槛, P1-H: 无需 structural 豁免)",
evidence: { metric: "事件语料 top-1(30k×4ep 同配置消融)", baseline: 47.5, result: 49.3, status: "pass", note: "gradcheck-cnn=0.0000; 修复 top-1 缺口 +1.8pt; 就后召回探针 9.7→6.5(小规模代价,大语料复查); P1-H: pass 证据直接过门槛, 无需 structural 豁免" },
compute: {
unitId: "cnn:layer4", depth: 4, cost: 1, chains: ["text"],
forward: async (task, state) => {
const logits = engine.peekLogits(4);
state.data[`z:logits:${task.id}`] = logits;
state.data["z:act:cnn:layer4"] = engine.model.lastCnnAct;
return engine.model.confidence(logits);
},
},
});
}
// SNN 脉冲支路 (快动力学·脉冲门控中央神经, 独立 LIF 膜电位)
if (engine.multiNeuro?.spike) {
reg.register({
kind: "snn", name: "SNN SpikeSSM", role: "快动力学·脉冲门控:LIF 膜电位 + PULSE surrogate", stage: "phase1", enabled: false, status: "shelf",
roleTag: "central",
justification: "独立 LIF 脉冲支路, 与骨干零共享参数, 输出端加法融合 logits (2026-10-04 降 shelf: 原 pass 证据混淆未控, 待重消融)",
evidence: { metric: "事件语料 top-1(消融)", baseline: 0, result: 0, status: "pending", note: "SNN 支路已接入训练/推理; 旧消融 Δ=+27.9pt 因参数不等/单种子混淆降 pending, 重消融通过门槛前保持 shelf (宪章第7条)" },
compute: {
unitId: "snn:spike", depth: 2, cost: 2, chains: ["text"],
forward: async (task, state) => {
const sLogits = engine.multiNeuro!.spikeReadLast();
if (sLogits) {
state.data[`z:spike:${task.id}`] = sLogits;
state.data["z:act:snn:spike"] = engine.multiNeuro!.spikeIgnition();
const conf = engine.model.confidence(sLogits);
engine.floors.record("snn:spike", conf);
return conf;
}
// 无脉冲输出兜底: 由本单元真实观测的最低置信度推导 (冷启动=0, 非写死常数, 宪章第1条)
return engine.floors.fallback("snn:spike");
},
},
});
}
// 世界域中央神经: 世界模型状态转移 + 物理一致性 (已训 checkpoint 结构层,
// 仅 world 任务按需调用 — 每字符 text 生成零额外开销, 宪章「按需调用」)
if (this.worldModel) {
const eng = this;
reg.register({
kind: "world-model", name: "World Model", role: "世界域中央: 状态转移 + 物理一致性 (Dreamer/Genie 逻辑自研)", stage: "deferred", enabled: true, status: "idle",
roleTag: "central",
structural: true,
justification: "已训 checkpoint 结构层 (world_model.json, 编码器/转移/解码器/物理约束); 仅 world 任务按需调用, text 生成零额外开销",
evidence: { metric: "世界一致性置信度 (任务级缺口消融)", baseline: 0, result: 0, status: "pending", note: "已训 checkpoint 结构层 (world_model.json 加载侧 paramCount 校验通过); P1-H 白名单: pending+checkpoint 证据物允许 structural 豁免, 待补「世界模型单元 vs 无」消融回填 (宪章第7条)" },
compute: {
unitId: "world-model:wm", depth: 3, cost: 2, chains: ["world"],
forward: async (task, state) => {
const wm = eng.worldModel!;
const ids = (task.input as number[] | undefined) ?? [];
const obs = ids.length > 0 ? Float64Array.from(eng.model.embedAvg(ids)) : new Float64Array(wm.embDim);
const ws = wm.encode(obs, 0);
const phys = wm.evaluatePhysics(ws);
// 置信度 = 状态相干性 × 能量守恒一致性 (真实数值, 无写死)
const conf = Math.max(0, Math.min(1, ws.coherence * (0.5 + 0.5 * (1 - phys[0]))));
state.data[`z:world:phys:${task.id}`] = Array.from(phys);
state.data[`z:world:state:${task.id}`] = Array.from(ws.s);
state.data[`z:act:world-model:wm`] = conf;
return conf;
},
},
});
}
// 视觉域感知前端: 强度网格 → 真实边缘/结构响应 (自研数值, 非外部模型/写死)
// 宪章第7条: 域消融 v2 (vision-ablation-v2.js) 分离度 0.8929 ≥ 0.2 门槛 → 过,
// enabled; v1 (8×8+噪声) 0.129 未过记录在案, v2 强化协议 (32×32 + 阶梯刺激 + 阴性对照 + 噪声鲁棒) 通过
// [P1-H 修复 2026-10-08 第一性审核] 零参数数值核 (vision/speech 前端, 非已训 checkpoint 结构层)
// 不得标 structural — 旧实现带 structural 短路豁免, 白名单化后移除。
reg.register({
kind: "vision", name: "Vision 感知前端", role: "视觉域感知: 强度网格 → 真实 LoG/Sobel 结构响应 (自研数值)", stage: "deferred", enabled: true, status: "idle",
roleTag: "perception",
justification: "自研视觉前端 (frontends.ts visionFront): max|Lap|/mean|Sobel| 不连续度集中度 → 归一化置信度; 非写死 (宪章第1条); 域消融 v2 过门槛 (pass 证据)",
evidence: { metric: "视觉域结构检测 (锐利/棋盘 vs 平滑, 32×32, 3 种子×200)", baseline: 0, result: 0.8929, status: "pass", note: "2026-10-05 消融 v2 (vision-ablation-v2.js): 分离度 0.8929≥0.2 (meanA=0.9214 vs meanB=0.0285), 阴性C=0.0000<0.05, 单调 C<B<A 3/3, 含噪声鲁棒子类; v1 (8×8+噪声) 0.129 未过记录在案; P1-H: 零参数数值核, pass 证据直接过门槛, 无需 structural 豁免" },
compute: {
unitId: "vision:frontend", depth: 1, cost: 1, chains: ["vision"],
forward: async (task, state) => {
const input = (task.input as number[] | undefined) ?? [];
const rep = visionFront(input.length > 0 ? input : [0, 0]);
state.data[`z:vision:feat:${task.id}`] = rep.summary;
state.data["z:act:vision:frontend"] = rep.confidence;
return rep.confidence;
},
},
});
// 声学域感知前端: 声学时序 → RMS/过零率/谱通量 (自研数值, 非外部模型/写死)
// 输出神经:整合所有中央神经的 logits 到最终输出向量 (MoE 聚合头风格)
// [P1-1 修复 2026-10-13 第一性审核] 本单元为零参数整合层 (共享底座最深层 logits 经黑板落槽),
// 无真实消融数字 (旧 evidence baseline=0/result=1.0 为机制一致性自证, 非对照组对比) →
// P1-1 数值门槛下不得 enabled (宪章第7条「数字说话」), 保持货架待补「output:aggregate vs 单头纯骨干」
// 真实缺口消融 (top-1 对照) 回填 evidence.status="pass" + 真实数字后重启用。
reg.register({
kind: "output", name: "输出神经", role: "多神经协同的最终输出聚合器 (整合所有中央神经的 logits 到最终输出向量)", stage: "phase3", enabled: false, status: "shelf",
roleTag: "output",
justification: "输出聚合:整合所有中央神经的 logits 到最终输出向量,支持动态路由门控与负载均衡;使用骨干最深层 logits 作为最终输出 (零参数整合层, 无独立参数)",
evidence: { metric: "输出整合一致性 (输出神经聚合 vs 单头纯骨干 top-1 对照)", baseline: 0, result: 0, status: "pending", note: "2026-10-13 第一性审核 P1-1: 旧 baseline=0/result=1.0 为机制一致性自证 (logits 切路已验证), 非真实消融数字; 零参数整合层无独立 checkpoint 证据物, 不得 structural 豁免; 待补「output:aggregate 经黑板落槽 vs 直接读骨干 logits」真实 top-1 对照消融 (3 种子同配置) 过 +1.0pt 门槛后回填 pass (宪章第7条)" },
compute: {
unitId: "output:aggregate", depth: 5, cost: 1, chains: ["text"],
forward: async (task, state) => {
// 调用骨干最深层 logits 作为聚合输出 (共享底座自然聚合所有前面神经的计算结果)
const logits = this.peekLogits(4);
state.data[`o:${task.id}`] = logits;
return this.model.confidence(logits);
},
},
});
// 宪章第7条: 域消融过门槛 (谐波 vs 静默 分离度 0.2450 ≥ 0.2, 3 种子×200, vision-speech-ablation.js)
// [P1-H 修复 2026-10-08 第一性审核] 零参数数值核, 不得标 structural (pass 证据直接过门槛)
reg.register({
kind: "speech", name: "Speech 感知前端", role: "声学域感知: 声学时序 → RMS/过零率/谱通量 (自研数值)", stage: "deferred", enabled: true, status: "idle",
roleTag: "perception",
justification: "自研声学前端 (frontends.ts speechFront): 时序样本 → RMS 能量 + 过零率 + 一阶谱通量近似 → 归一化置信度; 非写死 (宪章第1条); 域消融过门槛 (pass 证据)",
evidence: { metric: "声学域活跃度 (谐波 vs 静默 类间分离度, 3 种子×200)", baseline: 0, result: 0.245, status: "pass", note: "2026-10-05 消融 (vision-speech-ablation.js): 分离度 0.2450≥0.2 门槛 (meanA=0.5821 vs meanB=0.3368), 过控 = 谐波信号显著高于静默噪声; 真实数值, 无写死; P1-H: 零参数数值核, pass 证据直接过门槛, 无需 structural 豁免" },
compute: {
unitId: "speech:frontend", depth: 1, cost: 1, chains: ["speech"],
forward: async (task, state) => {
const input = (task.input as number[] | undefined) ?? [];
const rep = speechFront(input.length > 0 ? input : [0]);
state.data[`z:speech:feat:${task.id}`] = rep.summary;
state.data["z:act:speech:frontend"] = rep.confidence;
return rep.confidence;
},
},
});
// [P0-2 配套 2026-10-13] 注入经济学的真实 model.step 上界 (R1-B1 口径):
// 全链全跑 = 注册链可达单元数 (同深度取一 ≈ 最大 depth) + 1 (推进 advance)。
// 与 Engine 构造器内同名推导一致, 避免会话工作站沿用默认值失真。
if (economics) {
const textUnits = reg.computeUnits("text");
const maxDepth = textUnits.reduce((m, u) => Math.max(m, u.depth), 0);
const reachable = textUnits.filter((u) => u.cost > 0).length;
economics.setMaxRealForwards(Math.max(reachable, maxDepth) + 1);
}
}
private options: { temperature: number; topK: number } = { temperature: 0.1, topK: 3 };
async generate(opts: GenerateOptions): Promise<GenerateResult> {
const { prompt, maxLen, budget } = opts;
this.l0Probe.reset(); // L0 一致性探针: 单次生成分母干净 (各 run 独立统计)
this.options = { temperature: opts.temperature, topK: opts.topK };
if (opts.seed !== undefined) this.habit = mulberry32(opts.seed);
// 关键:prompt 必须先推进真实状态,模型才能"看到"完整上下文
this.state = this.model.newState();
this.resetSpike(); // SNN 膜电位重置 (生成开始时)
if (this.multiNeuro?.spike) this.multiNeuro.setSpikeInferenceMode(true); // 推理侧不累积 BPTT 训练缓存
const promptIds = this.tokenizer.encode(prompt);
for (const id of promptIds) this.advance(id);
this.ctxWin = promptIds.slice(-this.model.cfg.ctx);
const routes: CharRoute[] = [];
let text = prompt;
for (let i = 0; i < maxLen; i++) {
const ctx = this.ctxWin.slice();
const ctxFp = Engine.ctxFingerprint(ctx, this.model.cfg.vocabSize); // [P0-B] 上下文指纹 (稳定哈希, 非 seed)
const task: Task = { id: `${i}:${ctxFp}`, type: "text", input: ctx, complexity: Math.min(1, 0.4 + (i / Math.max(maxLen, 1)) * 0.4), budget };
const recalled = this.recallAt(ctx);
// [P0-B 修复 2026-10-08 第一性审核] mem: 键绑定「上下文指纹」而非任务序号 —
// 旧键 `mem:m${i}` 在 generate() 入口从 m0 重编号, 黑板不清空 → 服务器常驻进程
// 必然用上一请求残留键制造假命中 (审核实测 m1/m2 本轮零召回却报 L0 命中)。
// 新键 `mem:${ctxFp}` 仅当「相同上下文」时命中, 不同上下文的残留键天然失效。
if (recalled) this.station.blackboard.write(`mem:${ctxFp}`, recalled.char);
// L0 一致性探针 (宪章第7/8条): 每步记任务数; L0 命中时记 L0 直出字 vs 同上下文深链 top-1
this.l0Probe.noteTask();
if (recalled) {
const deep = this.deepTop1At();
this.l0Probe.record({
ctxPreview: this.tokenizer.decode(ctx).slice(-4),
chL0: recalled.char,
chDeep: deep.char,
deepP: deep.p,
source: recalled.source,
});
}
// L0 Titans 记忆直出 — 在 executor 之前直接检查(避免黑屏时序问题)
let ch = "";
let memoryHit = false;
// const titansHit = this.getTitansOutput(ctx);
// if (titansHit !== null && !this.isDegenerate(titansHit)) {
// ch = titansHit;
// memoryHit = true;
// const mid = this.tokenizer.idOf(ch);
// if (mid !== undefined) {
// this.advance(mid);
// this.ctxWin.push(mid);
// this.ctxWin = this.ctxWin.slice(-this.model.cfg.ctx);
// this.titansMem.write(Float64Array.from(this.model.embedAvg(ctx)), ch);
// }
// routes.push({ char: ch, depth: 0, confidence: 1.0, units: ["titans"], memoryHit: true, memorySource: "repeat" as any });
// this.propose(ch);
// text += ch;
// continue;
// }
const res: TaskResult = await this.station.executor.execute(task);
memoryHit = res.memoryHit ?? false;
// [P0-A 修复 2026-10-08 第一性审核] L0 记忆直出真接: res.output (executor 返回的
// 记忆字符) 必须直接作为输出字, 不得丢弃后走 peekLogits(4) 兜底深链 (旧实现 res.output
// 全仓从未被读取, L0 命中步仍跑 4 次完整前向, 审计记 depth=0/units=[]/conf=1 而真实
// 输出是深链结果 — 宪章第 1 条「假输出」)。
// 不变量: L0 命中步的最终输出字 === res.output (记忆字), 由 l0Probe 记录供审计。
let l0Advanced = false; // [P0-A 补漏] L0 命中步在本分支完成推进 → 下方「推进真实状态」块跳过, 防同字双推进
if (res.memoryHit && res.depth === 0 && res.output !== undefined && res.output !== "") {
ch = String(res.output);
// 推进状态 (零算力: 仅 advance + titansMem 写, 不跑深链前向)。
// [P0-A 补漏] L0 命中步在此完成推进, 跳过下方「推进真实状态」块, 避免同字双推进。
const hitId = this.tokenizer.idOf(ch);
if (hitId !== undefined) {
this.advance(hitId);
this.ctxWin.push(hitId);
this.ctxWin = this.ctxWin.slice(-this.model.cfg.ctx);
this.ctxWinWindow.add({ type: "char", char: ch, id: hitId }, 1);
this.titansMem.write(Float64Array.from(this.model.embedAvg(ctx)), ch);
l0Advanced = true;
}
}
// 深度路径: 从 blackboard 取 logits 并采样 (仅 L0 未命中时执行)
if (ch === "" && res.depth > 0) {
const zLogits = this.station.blackboard.read(`z:logits:${task.id}`) as Float64Array | undefined;
if (zLogits) {
// SNN 脉冲支路融合: 若 SNN 单元已运行, 将 spike logits 加法融合进骨干 logits
const spikeLogits = this.station.blackboard.read(`z:spike:${task.id}`) as Float64Array | undefined;
if (spikeLogits && spikeLogits.length === zLogits.length) {
for (let k = 0; k < zLogits.length; k++) zLogits[k] += spikeLogits[k];
}
const probs = this.model.logitsToProbs(zLogits);
ch = this.tokenizer.charOf(sampleToken(this.penalized(probs), this.options.topK, this.options.temperature, this.habit));
}
}
// [P0-A] 兜底仅用于 L0 未命中且深链也未产出的情况 (保证有输出, 不伪造零算力)
if (ch === "") {
const fallbackLogits = this.peekLogits(4);
const probs = this.model.logitsToProbs(fallbackLogits);
ch = this.tokenizer.charOf(sampleToken(this.penalized(probs), this.options.topK, this.options.temperature, this.habit));
}
// 路由深度 → 真实状态推进深度: 2026-10-08 第一性审核修复 — 旧实现主状态恒按
// depth 4 全深推进, MoD 预算裁剪只作用于探针副本, 算力与路由结果脱钩。
// 现按本步路由实际执行到的深度推进骨干 (res.depth=0 无单元执行 → 4 全深兜底)。
const advDepth = (res.depth >= 1 && res.depth <= 4 ? res.depth : 4) as 1 | 2 | 3 | 4;
// ===== 语义反思层 =====
// 在字符进入真实状态之前,进行反思检查
const reflection = reflect(ch, text, {
minSentenceLen: 8,
maxSentenceLen: 30,
maxRepeatCount: 2,
bigramThreshold: 0.001,
punctWeight: 5.0,
enabled: true,
}, this.bigramStats ?? undefined);
// 应用反思结果
if (reflection.action === 'force_end') {
ch = '。';
console.log(`[反思] 强制结束句子: ${reflection.reason}`);
} else if (reflection.action === 'reject') {
ch = reflection.char;
console.log(`[反思] 替换字符: ${reflection.reason}`);
}
// ===== 反思层结束 =====
// 推进真实状态
const id = this.tokenizer.idOf(ch);
if (id !== undefined && !l0Advanced) {
// [P0-D 补漏 2026-10-08] 旧实现恒 `advance(id)` 全深推进 — advDepth 已按本步
// 路由深度算出却从未使用 (MoD 算力与路由脱钩的残留), 现真接。
this.advance(id, advDepth);
this.ctxWin.push(id);
this.ctxWin = this.ctxWin.slice(-this.model.cfg.ctx);
// 更新上下文窗口
this.ctxWinWindow.add({ type: 'char', char: ch, id }, 1);
// 在线写入 Titans 神经记忆
this.titansMem.write(Float64Array.from(this.model.embedAvg(ctx)), ch);
}
routes.push({
char: ch,
depth: res.depth,
confidence: res.confidence,
units: res.units,
memoryHit: memoryHit,
memorySource: recalled?.source,
});
this.propose(ch);
text += ch;
if (!memoryHit && id !== undefined) this.memory.set(ctx.join(","), ch);
if (this.memory.size > 600) {
const first = this.memory.keys().next().value;
if (first !== undefined) this.memory.delete(first);
}
}
this.remember(text.substring(prompt.length));
if (this.multiNeuro?.spike) this.multiNeuro.setSpikeInferenceMode(false); // 生成结束, 恢复训练模式 (训练侧调用可累积 BPTT 缓存)
// [P1-L 修复 2026-10-09 第一性审核] 生成结束, 将探针和经济性数据写入 JSON (每次生成一轮)
if (this.station && this.station.probe) {
this.station.probe.writeToFile && this.station.probe.writeToFile();
}
if (this.station && this.station.economics) {
this.station.economics.report(); // 内部包含写入逻辑
}
return { text, routes, budget };
}
get registry() {
return this.station.registry;
}
get blackboard() {
return this.station.blackboard;
}
get audit() {
return this.station.audit;
}
get probe() {
return this.station.probe;
}
get economics() {
return this.station.economics;
}
get titans() {
return this.titansMem;
}
get cnVectorStore() { return this.cnStore; }
get mathVectorStore() { return this.mathStore; }
/** [P0-1 2026-10-13] SessionEngine 读取共享向量库/大语料统计, 补公开 getter (宪章第10条: 共享只读) */
get vectorStore() { return this.store; }
get bigramStatsGetter() { return this.bigramStats; }
getWorldModel() { return this.worldModel; }
get reasoner() { return this._reasoner; }
/** 获取上下文窗口 */
getContextWindow() {
return this.ctxWinWindow;
}
/** 返回模型总参数数 (CharMultiNeuro 含 MoE/专家头,CharGRU 仅 backbone) */
totalParamCount(): number {
return this.multiNeuro ? this.multiNeuro.paramCount() : this.model.paramCount();
}
}
import * as fs from "fs";
import * as path from "path";
import { CharGRU, CharGRUConfig, GRUState } from "./gru";
export type { GRUState };
import { CharMultiNeuro, CharMultiNeuroConfig } from "./multineuro";
import { CharTokenizer } from "./tokenizer";
import { CharTransformer, CharTransformerConfig } from "./transformer";
import { mulberry32 } from "./rng";
import { visionFront, speechFront } from "./frontends";
export { visionFront, speechFront };
import { createStation } from "../station";
import { L0Consistency } from "../station/l0probe";
import { Task, TaskResult } from "../station/types";
import { VectorStore } from "./vectorstore";
import { CNVectorStore } from "./cn_vectorstore";
import { MathVectorStore } from "./math_vectorstore";
import { WorldModel } from "./world_model";
import { TitansMemory } from "./titans";
export type { TitansConfig } from "./titans";
import { ConfidenceFloors } from "./floors";
import { chunkText } from "./data";
import { ContextWindow } from "./tool_system";
import { reflect, loadBigrams } from "./reflection";
export interface CheckpointMeta {
config: CharGRUConfig;
paramCount: number;
corpusTokens: number;
epochs: number;
vocab: string[];
trainedAt: string;
/** 是否由 CharMultiNeuro 训练 (含 MoE/专家头) */
multiNeuro?: boolean;
/** 是否由 CharTransformer 训练 */
transformer?: boolean;
moeTopK?: number;
moeGateHidden?: number;
moeNExperts?: number;
moeLoadBalanceWeight?: number;
onlineTitans?: boolean;
/** Transformer 配置 (可选) */
nLayer?: number;
nHead?: number;
/** Titans 记忆日志 (用于恢复记忆) */
titansWriteLog?: Array<{ slot: number; h1: number[] }>;
}
function sampleToken(probs: Float64Array, topK: number, temperature: number, rand: () => number): number {
// [P0-F 修复 2026-10-08 第一性审核] NaN 概率 (非有限 logits 经 logitsToProbs 返回) → 返回 -1,
// 调用方 charOf(-1) 无有效输出 (可证伪: 不伪造满置信的假输出)。
for (let i = 0; i < probs.length; i++) if (Number.isNaN(probs[i])) return -1;
const v = probs.length;
const scaled = new Float64Array(v);
let sum = 0;
for (let k = 0; k < v; k++) {
scaled[k] = Math.exp(Math.log(probs[k] + 1e-12) / Math.max(temperature, 1e-3));
sum += scaled[k];
}
const k = Math.min(topK, v);
const idxs = Array.from({ length: v }, (_, i) => i).sort((a, b) => scaled[b] - scaled[a]).slice(0, k);
let mass = 0;
for (const i of idxs) mass += scaled[i];
let r = rand() * mass;
for (const i of idxs) {
r -= scaled[i];
if (r <= 0) return i;
}
return idxs[idxs.length - 1];
}
export interface GenerateOptions {
prompt: string;
maxLen: number;
budget: number;
temperature: number;
topK: number;
seed?: number;
}
export interface CharRoute {
char: string;
depth: number;
confidence: number;
units: string[];
memoryHit: boolean;
/** 记忆来源:向量库 / 重复上下文 */
memorySource?: "vector" | "repeat" | "titans";
}
export interface GenerateResult {
text: string;
routes: CharRoute[];
budget: number;
}
/** 测试时记忆块标记:写入向量库的生成内容前缀,检索时跳过,防止自举循环 */
const MEMORY_TAG = "\uE000";
/**