079project 3.0.0 → 5.0.0

package/main_Serve.cjs

@@ -55,6 +55,71 @@ global.config = {
     peerServePorts: String(__args['peers'] || '').split(',').map(s => Number(s)).filter(n => Number.isFinite(n) && n > 0),
     isStudy: !!__args['study']
 };
+// ...existing code...
+const vm = require('vm'); // 新增：沙箱编译
+// ...existing code...
+
+// ==== 内置激活/传递函数注册表 + 安全编译工具 ====
+const BuiltinActivations = {
+    identity: (x) => x,
+    relu: (x) => (x > 0 ? x : 0),
+    leaky_relu: (x) => (x > 0 ? x : 0.01 * x),
+    tanh: (x) => Math.tanh(x),
+    sigmoid: (x) => 1 / (1 + Math.exp(-x)),
+    elu: (x) => (x >= 0 ? x : (Math.exp(x) - 1)),
+    softplus: (x) => Math.log(1 + Math.exp(x)),
+    // 近似 GELU
+    gelu: (x) => 0.5 * x * (1 + Math.tanh(Math.sqrt(2 / Math.PI) * (x + 0.044715 * Math.pow(x, 3))))
+};
+
+const BuiltinTransfers = {
+    // 线性衰减：next = value - decayK*weight*(dirMult)
+    linear: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value - (decayK * weight * dm);
+    },
+    // 指数衰减：next = value * exp(-decayK*weight*(dirMult))
+    exp: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value * Math.exp(-(decayK * weight * dm));
+    },
+    // 反比例：next = value / (1 + decayK*weight*(dirMult))
+    inverse: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        return value / (1 + (decayK * weight * dm));
+    },
+    // 截断线性：线性后下限截断为0，上限截断为value
+    capped: (value, weight, decayK, ctx) => {
+        const dm = ctx?.direction === 0 ? (ctx?.bidirectionalMultiplier ?? 1.2) : (ctx?.directionalMultiplier ?? 0.7);
+        const raw = value - (decayK * weight * dm);
+        return Math.max(0, Math.min(value, raw));
+    }
+};
+
+function compileCustomFunctionSafely(source, argNames, fallback) {
+    try {
+        const ctx = vm.createContext({ Math });
+        // 如果用户提供的是“表达式”，包一层 return
+        const body = source.includes('return') || source.includes('=>') || source.includes('function')
+            ? source
+            : `return (${source});`;
+
+        // 统一包成 function 体
+        const wrapper = `(function(${argNames.join(',')}) { "use strict"; ${body} })`;
+        const script = new vm.Script(wrapper, { timeout: 50 });
+        const fn = script.runInContext(ctx, { timeout: 50 });
+        if (typeof fn !== 'function') return fallback;
+        // 再包一层，避免传入异常导致抛出
+        return (...args) => {
+            try { return fn(...args); } catch (_e) { return fallback(...args); }
+        };
+    } catch (_e) {
+        return fallback;
+    }
+}
+// ...existing code...
+
+// 顶部 modelDefaults 增加参数（与本文件后半段的重复默认值保持一致）
 const modelDefaults = {
     decayFactor: 0.5,
     maxMemeWords: 100,
@@ -66,7 +131,12 @@ const modelDefaults = {
     decay: 1,
     decayK: 1,
     maxLen: 16,
-    edgeWeight: 1
+    edgeWeight: 1,
+    // 新增：激活/传递函数选择与自定义
+    activationType: 'relu',         // identity|relu|leaky_relu|tanh|sigmoid|elu|softplus|gelu|custom
+    transferType: 'linear',         // linear|exp|inverse|capped|custom
+    activationCustom: '',           // 自定义激活函数源码/表达式：f(x) 或 return ...
+    transferCustom: ''              // 自定义传递函数源码/表达式：f(value, weight, decayK, ctx) 或 return ...
 };
 const currentModelParams = { ...modelDefaults };
 // 反触发机制
@@ -1445,7 +1515,318 @@ class PartitionedGraphDB {
 // 说明：wordGraph 仍使用内存 GraphDB；模因图使用 PartitionedGraphDB
 
 // ...existing code...
+// ...existing code...
+
+// ===== Linear Algebra Backend (CSR + SpMM + Hash Embedding + PCA/UMAP) =====
+class CSR {
+    constructor(rowPtr, colIdx, values, nRows, nCols) {
+        this.rowPtr = rowPtr;       // Uint32Array length nRows+1
+        this.colIdx = colIdx;       // Uint32Array length nnz
+        this.values = values;       // Float32Array length nnz
+        this.nRows = nRows | 0;
+        this.nCols = nCols | 0;
+        this.nnz = this.values.length | 0;
+    }
+}
+
+class TensorEngine {
+    // y = A x  (A in CSR, x dense Float32Array)
+    spmm(csr, x, out = null) {
+        const { rowPtr, colIdx, values, nRows } = csr;
+        const y = out instanceof Float32Array && out.length === nRows ? out : new Float32Array(nRows);
+        for (let i = 0; i < nRows; i++) {
+            let s = 0.0;
+            const start = rowPtr[i], end = rowPtr[i + 1];
+            for (let p = start; p < end; p++) {
+                s += values[p] * x[colIdx[p]];
+            }
+            y[i] = s;
+        }
+        return y;
+    }
+
+    // x = a*x + b*y
+    axpby(a, x, b, y, out = null) {
+        const n = x.length | 0;
+        const z = out instanceof Float32Array && out.length === n ? out : new Float32Array(n);
+        for (let i = 0; i < n; i++) z[i] = a * x[i] + b * y[i];
+        return z;
+    }
+
+    l2NormalizeRows(mat, nRows, nCols) {
+        for (let i = 0; i < nRows; i++) {
+            let s = 0.0, base = i * nCols;
+            for (let j = 0; j < nCols; j++) { const v = mat[base + j]; s += v * v; }
+            s = Math.sqrt(s) || 1.0;
+            for (let j = 0; j < nCols; j++) mat[base + j] /= s;
+        }
+    }
+
+    dot(a, b) {
+        let s = 0.0;
+        for (let i = 0; i < a.length; i++) s += a[i] * b[i];
+        return s;
+    }
+
+    // 迭代式传播（不跟踪路径，面向速度）
+    // return Float32Array activation over rows
+    iteratePropagation(csr, seeds, steps, actFn, decayK, damp = 0.02) {
+        const n = csr.nRows | 0;
+        let x = new Float32Array(n);
+        for (const [row, v] of seeds) { if (row >= 0 && row < n) x[row] += v; }
+
+        let y = new Float32Array(n);
+        for (let t = 0; t < steps; t++) {
+            // y = A x
+            this.spmm(csr, x, y);
+            // x = act(x + y - decayK*damp*x)
+            for (let i = 0; i < n; i++) {
+                const raw = x[i] + y[i] - (decayK * damp * x[i]);
+                x[i] = actFn(raw);
+            }
+        }
+        return x; // final activation
+    }
+}
+
+// 词-模因hash嵌入：fixed-D feature hashing + L2 normalize
+class GraphTensorBridge {
+    constructor(runtime) {
+        this.rt = runtime;
+        this.rowIndex = new Map(); // memeID -> row
+        this.rows = [];            // row -> memeID
+        this.emb = null;           // Float32Array [N*D]
+        this.dim = 0;
+        this.csrAll = null;        // CSR (all directions)
+        this._multi = null;        // {all,bi,out,in, id2row, row2id}
+    }
+
+    static fnv1a32(str) {
+        let h = 0x811c9dc5;
+        for (let i = 0; i < str.length; i++) {
+            h ^= str.charCodeAt(i);
+            h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;
+        }
+        return h >>> 0;
+    }
+
+    // 构建行索引，只遍历当前窗口
+    rebuildRowIndex() {
+        this.rowIndex.clear();
+        this.rows.length = 0;
+        const pts = this.rt.graph.getAllPoints();
+        for (let i = 0; i < pts.length; i++) {
+            const id = pts[i].pointID;
+            this.rowIndex.set(id, i);
+            this.rows.push(id);
+        }
+        return pts.length;
+    }
+
+    // Hash embedding: D默认512
+    buildEmbeddings(D = 512) {
+        const N = this.rebuildRowIndex();
+        this.dim = D | 0;
+        this.emb = new Float32Array(N * D);
+        for (let r = 0; r < N; r++) {
+            const memeId = this.rows[r];
+            const words = this.rt.kvm.get(memeId) || [];
+            const base = r * D;
+            for (let k = 0; k < words.length; k++) {
+                const w = String(words[k] || '').toLowerCase();
+                const idx = GraphTensorBridge.fnv1a32(w) % D;
+                this.emb[base + idx] += 1.0;
+            }
+        }
+        this.rt.tensor.l2NormalizeRows(this.emb, N, D);
+        return { N, D };
+    }
+
+    // 构建多通道CSR（每行Top-K；all/bi/out，同时构建out的转置作为in）
+    buildMultiOrderCSR(topK = 64) {
+        const pts = this.rt.graph.getAllPoints();
+        const N = pts.length | 0;
+        const id2row = this.rowIndex;
+        const row2id = this.rows.slice();
+
+        const buildChannel = (filterFn) => {
+            const rows = new Array(N);
+            let nnz = 0;
+            for (let i = 0; i < N; i++) {
+                const conns = (pts[i].connect || []).filter(filterFn);
+                // 取Top-K（按权重大->小）
+                conns.sort((a, b) => b[0] - a[0]);
+                const pruned = conns.slice(0, topK);
+                const cols = [];
+                const vals = [];
+                for (const [w, tgt] of pruned) {
+                    const c = id2row.get(tgt);
+                    if (c === undefined) continue;
+                    cols.push(c);
+                    vals.push((typeof w === 'number' && isFinite(w)) ? w : 1.0);
+                }
+                rows[i] = { cols, vals };
+                nnz += cols.length;
+            }
+            const rowPtr = new Uint32Array(N + 1);
+            const colIdx = new Uint32Array(nnz);
+            const values = new Float32Array(nnz);
+            let p = 0;
+            for (let i = 0; i < N; i++) {
+                rowPtr[i] = p;
+                const { cols, vals } = rows[i];
+                for (let j = 0; j < cols.length; j++) {
+                    colIdx[p] = cols[j];
+                    values[p] = vals[j];
+                    p++;
+                }
+            }
+            rowPtr[N] = p;
+            return new CSR(rowPtr, colIdx, values, N, N);
+        };
+
+        const ALL = buildChannel(_ => true);
+        const BI  = buildChannel(([, , d]) => d === 0);
+        const OUT = buildChannel(([, , d]) => d === 2);
+
+        // IN = transpose(OUT)
+        const IN = this.transposeCSR(OUT);
+
+        this._multi = { all: ALL, bi: BI, out: OUT, in: IN, id2row, row2id };
+        this.csrAll = ALL;
+        return this._multi;
+    }
+
+    transposeCSR(A) {
+        const { nRows, nCols, rowPtr, colIdx, values } = A;
+        const nnz = values.length;
+        const counts = new Uint32Array(nCols);
+        for (let p = 0; p < nnz; p++) counts[colIdx[p]]++;
+        const rowPtrT = new Uint32Array(nCols + 1);
+        for (let i = 0; i < nCols; i++) rowPtrT[i + 1] = rowPtrT[i] + counts[i];
+        const colIdxT = new Uint32Array(nnz);
+        const valuesT = new Float32Array(nnz);
+        const cursor = rowPtrT.slice();
+        for (let i = 0; i < nRows; i++) {
+            for (let p = rowPtr[i]; p < rowPtr[i + 1]; p++) {
+                const j = colIdx[p];
+                const q = cursor[j]++;
+                colIdxT[q] = i;
+                valuesT[q] = values[p];
+            }
+        }
+        return new CSR(rowPtrT, colIdxT, valuesT, nCols, nRows);
+    }
+
+    get multi() { return this._multi; }
+}
+
+class DimReducer {
+    // PCA(2D) 快速近似：power-iteration + 投影
+    pca2D(emb, N, D, iters = 6) {
+        // 均值中心化
+        const mean = new Float32Array(D);
+        for (let i = 0; i < N; i++) {
+            const base = i * D;
+            for (let j = 0; j < D; j++) mean[j] += emb[base + j];
+        }
+        for (let j = 0; j < D; j++) mean[j] /= Math.max(1, N);
+        const X = new Float32Array(N * D);
+        for (let i = 0; i < N; i++) {
+            const base = i * D;
+            for (let j = 0; j < D; j++) X[base + j] = emb[base + j] - mean[j];
+        }
+        // 随机初始向量
+        let v1 = new Float32Array(D); for (let j = 0; j < D; j++) v1[j] = Math.random() - 0.5;
+        let v2 = new Float32Array(D); for (let j = 0; j < D; j++) v2[j] = Math.random() - 0.5;
+
+        const mulCov = (v) => { // X^T X v
+            const tmp = new Float32Array(D);
+            for (let i = 0; i < N; i++) {
+                const base = i * D;
+                // s = x_i dot v
+                let s = 0.0;
+                for (let j = 0; j < D; j++) s += X[base + j] * v[j];
+                for (let j = 0; j < D; j++) tmp[j] += X[base + j] * s;
+            }
+            return tmp;
+        };
+        const normalize = (v) => {
+            let s = 0.0; for (let j = 0; j < D; j++) s += v[j] * v[j];
+            s = Math.sqrt(s) || 1.0;
+            for (let j = 0; j < D; j++) v[j] /= s;
+        };
+
+        for (let t = 0; t < iters; t++) { v1 = mulCov(v1); normalize(v1); }
+        // v2 去除与 v1 的分量
+        for (let t = 0; t < iters; t++) {
+            v2 = mulCov(v2);
+            // Gram-Schmidt
+            let dot = 0.0; for (let j = 0; j < D; j++) dot += v2[j] * v1[j];
+            for (let j = 0; j < D; j++) v2[j] -= dot * v1[j];
+            normalize(v2);
+        }
+
+        // 投影到2D
+        const out = new Float32Array(N * 2);
+        for (let i = 0; i < N; i++) {
+            const base = i * D;
+            let x = 0.0, y = 0.0;
+            for (let j = 0; j < D; j++) {
+                const xv = X[base + j];
+                x += xv * v1[j];
+                y += xv * v2[j];
+            }
+            out[2 * i + 0] = x;
+            out[2 * i + 1] = y;
+        }
+        return out;
+    }
+
+    // 若安装 umap-js 则使用 UMAP，否则回退 PCA
+    project2D(emb, N, D, method = 'auto') {
+        if (method === 'pca') return this.pca2D(emb, N, D);
+        if (method === 'umap' || method === 'auto') {
+            try {
+                // 按需加载
+                const { UMAP } = require('umap-js');
+                const umap = new UMAP({ nComponents: 2, nNeighbors: 15, minDist: 0.1 });
+                // umap-js 需要普通数组
+                const data = new Array(N);
+                for (let i = 0; i < N; i++) {
+                    const row = new Array(D);
+                    const base = i * D;
+                    for (let j = 0; j < D; j++) row[j] = emb[base + j];
+                    data[i] = row;
+                }
+                const coords = umap.fit(data);
+                const out = new Float32Array(N * 2);
+                for (let i = 0; i < N; i++) { out[2 * i] = coords[i][0]; out[2 * i + 1] = coords[i][1]; }
+                return out;
+            } catch (_) {
+                return this.pca2D(emb, N, D);
+            }
+        }
+        return this.pca2D(emb, N, D);
+    }
+}
+
+// 提供多通道邻接卷（all/bi/out/in），供三维张量视角
+class MultiOrderAdjacency {
+    constructor(runtime) {
+        this.rt = runtime;
+    }
+    rebuild(topK = 64, Demb = 512) {
+        if (!this.rt.tensorBridge) this.rt.tensorBridge = new GraphTensorBridge(this.rt);
+        const gb = this.rt.tensorBridge;
+        gb.buildEmbeddings(Demb);
+        const multi = gb.buildMultiOrderCSR(topK);
+        return multi;
+    }
+}
+// ===== End of Linear Algebra Backend =====
 
+// ...existing code...
 class KVM {
     // this KVM is the key-value memory
     constructor() {
@@ -1615,7 +1996,9 @@ class Runtime {
             baseDir: path.join(__dirname, 'graph_parts'),
             backend: this.config.graphBackend || 'fs' // 可选 'fs' | 'lmdb' | 'level'
         });
-
+                this._act = BuiltinActivations.relu;
+        this._transfer = BuiltinTransfers.linear;
+        this._activationMeta = { activationType: 'relu', transferType: 'linear' };
         this.wordGraph = new GraphDB();
         this.kvm = new KVM();
         this.changer = new Changer();
@@ -1625,6 +2008,7 @@ class Runtime {
         this.wordAccessLog = new Map();
         this.initWordGraph();
         this.MAX_MEME_WORDS = 100; // 单个模因最大词数
+
         this.MIN_OVERLAP = 2;      // 至少有2个词重叠才允许合并
         // Runtime类内新增
         this.activationStats = new Map(); // 记录激活关系
@@ -1636,6 +2020,82 @@ class Runtime {
             batchSizeMultiplier: 1
         };
         this.memeBarrier = new memeBarrier(this);
+                this.tensor = new TensorEngine();
+        this.tensorBridge = new GraphTensorBridge(this);
+        this.dimReducer = new DimReducer();
+        this.multiAdj = new MultiOrderAdjacency(this);
+        this._laReady = false; // 线代缓存是否就绪
+    }
+        // 重建线代缓存：Embedding + 多通道CSR
+    rebuildLinearAlgebraCaches({ topK = 64, embDim = 512 } = {}) {
+        try {
+            this.multiAdj.rebuild(topK, embDim);
+            this._laReady = !!(this.tensorBridge?.multi?.all);
+            return {
+                ok: this._laReady,
+                nodes: this.tensorBridge?.rows?.length || 0,
+                embDim
+            };
+        } catch (e) {
+            this._laReady = false;
+            return { ok: false, error: e.message };
+        }
+    }
+
+    // 导出CSR（all通道）
+    exportSparseMatrix() {
+        const m = this.tensorBridge?.multi;
+        if (!m?.all) return null;
+        const A = m.all;
+        return {
+            nRows: A.nRows, nCols: A.nCols, nnz: A.nnz,
+            rowPtr: Array.from(A.rowPtr),
+            colIdx: Array.from(A.colIdx),
+            values: Array.from(A.values),
+            rows: this.tensorBridge.rows.slice()
+        };
+    }
+        // 高维->2D投影（PCA/UMAP）
+    foldHighDimTo2D(method = 'auto') {
+        const emb = this.tensorBridge?.emb;
+        const N = this.tensorBridge?.rows?.length || 0;
+        const D = this.tensorBridge?.dim || 0;
+        if (!emb || !N || !D) return { ok: false, error: 'embedding not ready' };
+        const coords = this.dimReducer.project2D(emb, N, D, method);
+        const out = {};
+        for (let i = 0; i < N; i++) out[this.tensorBridge.rows[i]] = [coords[2 * i], coords[2 * i + 1]];
+        return { ok: true, dim: 2, points: out };
+    }
+        // 获取/设置激活-传递函数配置
+    getActivationConfig() {
+        return {
+            activationType: this._activationMeta.activationType,
+            transferType: this._activationMeta.transferType,
+            activationCustom: this.config?.activationCustom || '',
+            transferCustom: this.config?.transferCustom || ''
+        };
+    }
+
+    setActivationConfig({ activationType, transferType, activationCustom, transferCustom } = {}) {
+        const aType = String(activationType || this._activationMeta.activationType || 'relu');
+        const tType = String(transferType || this._activationMeta.transferType || 'linear');
+
+        let act = BuiltinActivations[aType] || BuiltinActivations.relu;
+        let tr = BuiltinTransfers[tType] || BuiltinTransfers.linear;
+
+        if (aType === 'custom' && activationCustom) {
+            act = compileCustomFunctionSafely(activationCustom, ['x'], BuiltinActivations.relu);
+        }
+        if (tType === 'custom' && transferCustom) {
+            tr = compileCustomFunctionSafely(transferCustom, ['value', 'weight', 'decayK', 'ctx'], BuiltinTransfers.linear);
+        }
+
+        this._act = (typeof act === 'function') ? act : BuiltinActivations.relu;
+        this._transfer = (typeof tr === 'function') ? tr : BuiltinTransfers.linear;
+        this._activationMeta = { activationType: aType, transferType: tType };
+        this.config = this.config || {};
+        this.config.activationCustom = activationCustom || this.config.activationCustom || '';
+        this.config.transferCustom = transferCustom || this.config.transferCustom || '';
     }
     // 新增资源监控方法
     monitorSystemLoad() {
@@ -2075,112 +2535,48 @@ class Runtime {
      *        options.bidirectionalMultiplier: 双向连接的衰减倍率
      * @returns {Object|Map} 激活结果
      */
+  // 用于多源扩散：将“传递函数+激活函数”应用在每一步
+    // 线代版多源扩散（不跟踪路径）
     propagateSignalMultiSource(startIDs, strengths, decayK, maxStep, options = {}) {
-        decayK = decayK !== undefined ? decayK : (this.config.decayK !== undefined ? this.config.decayK : 1);
-        maxStep = maxStep !== undefined ? maxStep : (this.config.maxStep !== undefined ? this.config.maxStep : 10);
-        const maxActiveNodes = options.maxActiveNodes || 5000;
-        const minSignal = options.minSignal || 0.01;
-        const trackPath = options.trackPath || false;
-        // 单向和双向连接的衰减系数调整
-        const directionalMultiplier = options.directionalMultiplier || 0.7; // 单向连接的衰减倍率（较慢）
-        const bidirectionalMultiplier = options.bidirectionalMultiplier || 1.2; // 双向连接的衰减倍率（较快）
-
-        // 节点信号累加表
-        const signalMap = new Map();
-        // 路径追踪表（可选）
-        const activationPaths = trackPath ? new Map() : null;
-        // 记录节点激活类型
-        const activationTypes = trackPath ? new Map() : null;
-
-        // 初始化活跃队列，每个元素{id, value, from, connectionType}
-        let active = startIDs.map((id, i) => ({
-            id,
-            value: strengths[i],
-            from: null,
-            connectionType: -1  // 起点无连接类型
-        }));
-
-        let step = 0;
-
-        while (active.length > 0 && step < maxStep) {
-            // 限制活跃节点数，优先保留信号强的
-            if (active.length > maxActiveNodes) {
-                active.sort((a, b) => b.value - a.value);
-                active = active.slice(0, maxActiveNodes);
-                console.log(`[LIMIT] 多源扩散活跃节点数已限制为 ${maxActiveNodes}`);
+        // 如果调用方需要trackPath，仍走旧逻辑
+        if (options?.trackPath) {
+            return super.propagateSignalMultiSource
+                ? super.propagateSignalMultiSource(startIDs, strengths, decayK, maxStep, options)
+                : this._propagateFallback(startIDs, strengths, decayK, maxStep, options);
+        }
+
+        // 优先使用线代后端
+        if (this._laReady && this.tensorBridge?.multi?.all) {
+            const A = this.tensorBridge.multi.all;
+            const id2row = this.tensorBridge.rowIndex;
+            const seeds = [];
+            for (let i = 0; i < startIDs.length; i++) {
+                const r = id2row.get(startIDs[i]);
+                if (r !== undefined) seeds.push([r, strengths[i] || 0]);
             }
+            if (!seeds.length) return new Map();
 
-            const next = [];
-            for (const { id, value, from, connectionType } of active) {
-                if (value < minSignal) continue;
-
-                // 信号融合：累加到signalMap
-                signalMap.set(id, (signalMap.get(id) || 0) + value);
-
-                // 记录激活类型
-                if (trackPath && connectionType !== -1) {
-                    if (!activationTypes.has(id)) {
-                        activationTypes.set(id, new Set());
-                    }
-                    activationTypes.get(id).add(connectionType);
-                }
-
-                // 路径追踪
-                if (trackPath && from) {
-                    if (!activationPaths.has(id)) {
-                        activationPaths.set(id, []);
-                    }
-                    activationPaths.get(id).push({ from, connectionType, value });
-                }
-
-                // 传播到邻居（考虑连接方向）
-                const point = this.graph.points.get(id);
-                if (!point) continue;
-
-                // 限制每个节点最多处理的邻居数量
-                const MAX_NEIGHBORS = 30;
-                const neighbors = point.connect.slice(0, MAX_NEIGHBORS);
-
-                for (const [weight, neighborID, direction = 0] of neighbors) {
-                    // 根据连接类型决定衰减系数
-                    let effectiveDecay = decayK;
+            const actFn = this._act || ((x) => (x > 0 ? x : 0));
+            const steps = Math.max(1, maxStep | 0);
+            const x = this.tensor.iteratePropagation(A, seeds, steps, actFn, (decayK ?? 1));
 
-                    if (direction === 0) {
-                        // 双向连接 - 衰减较大（语义关联较弱）
-                        effectiveDecay *= bidirectionalMultiplier;
-                    } else {
-                        // 单向连接 - 衰减较小（语义流向强）
-                        effectiveDecay *= directionalMultiplier;
-                    }
-
-                    // 计算传播后的信号强度
-                    const nextValue = value - effectiveDecay * weight;
-
-                    // 仅当信号足够强时才继续传播
-                    if (nextValue >= minSignal) {
-                        next.push({
-                            id: neighborID,
-                            value: nextValue,
-                            from: id,
-                            connectionType: direction
-                        });
-                    }
-                }
+            // 返回Map<MemeID,value>
+            const out = new Map();
+            for (let i = 0; i < x.length; i++) {
+                if (x[i] > 0) out.set(this.tensorBridge.rows[i], x[i]);
             }
-            active = next;
-            step++;
+            return out;
         }
 
-        // 返回结果，根据跟踪路径选项决定返回格式
-        if (trackPath) {
-            return {
-                signalMap,
-                activationPaths,
-                activationTypes
-            };
-        }
+        // 回退旧实现
+        return this._propagateFallback(startIDs, strengths, decayK, maxStep, options);
+    }
 
-        return signalMap;
+    _propagateFallback(startIDs, strengths, decayK, maxStep, options) {
+        // 使用文件里现有版本（保持兼容）
+        // 这里直接调用之前定义的 Runtime.propagateSignalMultiSource 的原实现
+        const fn = Object.getPrototypeOf(this).propagateSignalMultiSource;
+        return fn.call(this, startIDs, strengths, decayK, maxStep, options);
     }
 
     // 主循环：持续归纳和信号传递
@@ -3358,6 +3754,70 @@ async function main() {
 
     // 安装对端监控触发器
     installPeerFailoverMonitor();
+    // ...existing code...
+app.post('/api/tensor/refresh', (req, res) => {
+    try {
+        const { topK = 64, embDim = 512 } = req.body || {};
+        const rt = global.ctrlA?.runtime;
+        if (!rt) return res.status(500).json({ ok: false, error: 'runtime missing' });
+        const ret = rt.rebuildLinearAlgebraCaches({ topK, embDim });
+        res.json({ ok: !!ret.ok, ...ret });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.get('/api/tensor/csr', (req, res) => {
+    try {
+        const rt = global.ctrlA?.runtime;
+        if (!rt) return res.status(500).json({ ok: false, error: 'runtime missing' });
+        const csr = rt.exportSparseMatrix();
+        if (!csr) return res.status(400).json({ ok: false, error: 'csr not ready' });
+        res.json({ ok: true, csr });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.get('/api/tensor/project2d', (req, res) => {
+    try {
+        const method = String(req.query?.method || 'auto');
+        const rt = global.ctrlA?.runtime;
+        if (!rt) return res.status(500).json({ ok: false, error: 'runtime missing' });
+        const ret = rt.foldHighDimTo2D(method);
+        res.json(ret);
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+
+app.get('/api/tensor/topk', (req, res) => {
+    try {
+        const memeId = String(req.query?.memeId || '');
+        const k = Math.max(1, Math.min(50, Number(req.query?.k || 10)));
+        const rt = global.ctrlA?.runtime;
+        if (!rt?.tensorBridge?.emb) return res.status(400).json({ ok: false, error: 'embedding not ready' });
+        const row = rt.tensorBridge.rowIndex.get(memeId);
+        if (row === undefined) return res.status(404).json({ ok: false, error: 'meme not found' });
+
+        const N = rt.tensorBridge.rows.length, D = rt.tensorBridge.dim;
+        const base = row * D;
+        const q = new Float32Array(D);
+        for (let j = 0; j < D; j++) q[j] = rt.tensorBridge.emb[base + j];
+
+        const scores = new Array(N);
+        for (let i = 0; i < N; i++) {
+            const b = i * D;
+            let s = 0.0; for (let j = 0; j < D; j++) s += q[j] * rt.tensorBridge.emb[b + j];
+            scores[i] = [rt.tensorBridge.rows[i], s];
+        }
+        scores.sort((a, b) => b[1] - a[1]);
+        res.json({ ok: true, memeId, neighbors: scores.slice(0, k) });
+    } catch (e) {
+        res.status(500).json({ ok: false, error: e.message });
+    }
+});
+// ...existing code...
 app.get('/api/graph/partitions/status', async (req, res) => {
     try {
         const g = global.ctrlA?.runtime?.graph;
@@ -3504,7 +3964,11 @@ app.post('/api/graph/prefetch', async (req, res) => {
         decay: 1,               // 新增
         decayK: 1,              // 新增
         maxLen: 16,             // 新增
-        edgeWeight: 1           // 新增，GraphDB默认边权重
+        edgeWeight: 1,          // 新增
+        activationType: 'relu',
+        transferType: 'linear',
+        activationCustom: '',
+        transferCustom: ''
     };
     const currentModelParams = { ...modelDefaults };
 
@@ -3610,10 +4074,10 @@ app.post('/api/adversary/start', (req, res) => {
 
     console.log('已设置交错自主学习定时任务，每200s执行一次');
 }
-// plainObjToRuntime: 将protobuf对象同步到runtime实例
-// 扩展 applyModelParams
 function applyModelParams(runtime) {
     if (!runtime) return;
+
+    // 同步通用参数
     runtime.MAX_MEME_WORDS = currentModelParams.maxMemeWords;
     runtime.MIN_OVERLAP = currentModelParams.minOverlapThreshold;
     runtime.config = runtime.config || {};
@@ -3624,11 +4088,12 @@ function applyModelParams(runtime) {
     runtime.config.iteration = currentModelParams.iteration;
     runtime.config.threshold = currentModelParams.threshold;
     runtime.config.decay = currentModelParams.decay;
+
     // memeBarrier
     if (runtime.memeBarrier) {
         runtime.memeBarrier.maliciousThreshold = currentModelParams.maliciousThreshold;
     }
-    // GraphDB边权重（如需全局调整，可遍历所有边）
+    // 全局边权
     if (runtime.graph && currentModelParams.edgeWeight !== undefined) {
         for (const point of runtime.graph.getAllPoints()) {
             for (const conn of point.connect) {
@@ -3636,7 +4101,20 @@ function applyModelParams(runtime) {
             }
         }
     }
-    console.log('[PARAMS] 已更新运行时参数:', currentModelParams);
+
+    // 新增：激活/传递函数配置
+    runtime.setActivationConfig({
+        activationType: currentModelParams.activationType,
+        transferType: currentModelParams.transferType,
+        activationCustom: currentModelParams.activationCustom,
+        transferCustom: currentModelParams.transferCustom
+    });
+
+    console.log('[PARAMS] 已更新运行时参数:', {
+        ...currentModelParams,
+        activationType: runtime.getActivationConfig().activationType,
+        transferType: runtime.getActivationConfig().transferType
+    });
 }
 // plainObjToRuntime: 将protobuf对象同步到runtime实例
 async function plainObjToRuntime(runtime, obj) {