079project 4.0.0 → 5.0.0

package/main_Study.cjs

@@ -273,7 +273,318 @@ async function deltaCloneRuntime(prevClone, srcRuntime) {
     clone.__deltaIndexes.vocabHash = srcVocabHash;
     return clone;
 }
+// ...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...
 // 按需检索器：在用户输入（processInput）时触发网络检索与增量学习
 class OnlineResearcher {
     constructor(runtime, options = {}) {
@@ -2118,6 +2429,51 @@ class Runtime {
                 this._act = BuiltinActivations.relu;
         this._transfer = BuiltinTransfers.linear;
         this._activationMeta = { activationType: 'relu', transferType: 'linear' };
+                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() {
@@ -2683,75 +3039,47 @@ class Runtime {
      *        options.trackPath: 是否记录激活路径
      * @returns {Object|Map} { signalMap, activationPaths } 或 signalMap
      */
+    // 线代版多源扩散（不跟踪路径）
     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 actFn = this._act || BuiltinActivations.relu;
-        const transferFn = this._transfer || BuiltinTransfers.linear;
-
-        const signalMap = new Map();
-        const activationPaths = trackPath ? new Map() : null;
-        const activationTypes = trackPath ? new Map() : null;
-
-        let active = startIDs.map((id, i) => ({
-            id, value: strengths[i], from: null, connectionType: -1
-        }));
-        let step = 0;
+        // 如果调用方需要trackPath，仍走旧逻辑
+        if (options?.trackPath) {
+            return super.propagateSignalMultiSource
+                ? super.propagateSignalMultiSource(startIDs, strengths, decayK, maxStep, options)
+                : this._propagateFallback(startIDs, strengths, decayK, maxStep, options);
+        }
 
-        while (active.length > 0 && step < maxStep) {
-            if (active.length > maxActiveNodes) {
-                active.sort((a, b) => b.value - a.value);
-                active = active.slice(0, maxActiveNodes);
+        // 优先使用线代后端
+        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;
-
-                // 节点处应用激活函数（融合累计）
-                const prev = signalMap.get(id) || 0;
-                const merged = actFn(prev + value);
-                signalMap.set(id, merged);
-
-                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 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));
 
-                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) {
-                    const ctx = { direction, directionalMultiplier, bidirectionalMultiplier };
-                    const rawNext = transferFn(value, weight, decayK, ctx);
-                    const nextValue = actFn(rawNext);
-
-                    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 signalMap;
+        // 回退旧实现
+        return this._propagateFallback(startIDs, strengths, decayK, maxStep, options);
+    }
+
+    _propagateFallback(startIDs, strengths, decayK, maxStep, options) {
+        // 使用文件里现有版本（保持兼容）
+        // 这里直接调用之前定义的 Runtime.propagateSignalMultiSource 的原实现
+        const fn = Object.getPrototypeOf(this).propagateSignalMultiSource;
+        return fn.call(this, startIDs, strengths, decayK, maxStep, options);
     }
     // ...existing code...
 
@@ -4328,6 +4656,70 @@ async function main() {
     if (String(process.env.ADV_AUTOSTART || '').toLowerCase() === 'true') {
         adv.start();
     }
+    // ...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...
 // 新增：serve 侧参数调优 API（默认不启用自动调参，仅手动设置）
 app.get('/api/tune/get', (req, res) => {
     try {