079project 4.0.0 → 5.0.0

package/forwarder.js

@@ -1104,13 +1104,6 @@ function updateParamSliders(params) {
     `);
 });
 
-// 目标端口列表
-const AI_PORTS = [
-    process.env.AI_PORT_A || process.argv[3],
-    process.env.AI_PORT_B || process.argv[4],
-    process.env.AI_PORT_C || process.argv[5]
-];
-const Study_Port=process.env.AI_STUDY_PORT ||  process.argv[6]; // 学习模块端口
 
 const systemStats = {
     requestsTotal: 0,
@@ -1121,7 +1114,167 @@ const systemStats = {
     aiResponseTimes: { [process.argv[3]]: [], [process.argv[4]]: [], [process.argv[5]]: [] },
     lastErrors: []
 };
+// ...existing code...
+
+// ========== 分片/冷-热池调度（forwarder 层） ==========
+class ShardDescriptor {
+    /**
+     * @param {Object} opts
+     * @param {string} opts.id          逻辑ID（如 "text_base", "law_1"）
+     * @param {number[]} opts.ports     该 shard 对应的后端端口列表（当前版本：本 forwarder 下的某个子集）
+     * @param {number[]} [opts.embedding] 语义中心向量（可选，先空）
+     * @param {string[]} [opts.tags]    领域标签，如 ['code','cn','law']
+     */
+    constructor(opts) {
+        this.id = opts.id;
+        this.ports = opts.ports || [];
+        this.embedding = Array.isArray(opts.embedding) ? opts.embedding : null;
+        this.tags = Array.isArray(opts.tags) ? opts.tags : [];
+        this.lastUsedTs = 0;
+        this.usageCount = 0;
+        this.loaded = true;  // 第1轮简化：都视为“热”，仅做路由选择
+    }
+
+    touch() {
+        this.lastUsedTs = Date.now();
+        this.usageCount++;
+    }
+}
+
+// 非TF的极简 embedding：词袋hash到固定维度
+function hashStrSimple(str, seed = 1315423911) {
+    let h = seed >>> 0;
+    for (let i = 0; i < str.length; i++) {
+        h ^= ((h << 5) + str.charCodeAt(i) + (h >>> 2)) >>> 0;
+    }
+    return h >>> 0;
+}
+
+function textToMiniEmbedding(text, dim = 64) {
+    const vec = new Float32Array(dim);
+    const toks = basicClean(text).toLowerCase().split(/[^a-z0-9_\-\u4e00-\u9fa5]+/).filter(Boolean);
+    if (!toks.length) return Array.from(vec);
+    for (const t of toks) {
+        const h = hashStrSimple(t);
+        const idx = h % dim;
+        vec[idx] += 1;
+    }
+    // L2 normalize
+    let n2 = 0; for (let i = 0; i < dim; i++) n2 += vec[i] * vec[i];
+    n2 = Math.sqrt(n2) || 1;
+    for (let i = 0; i < dim; i++) vec[i] /= n2;
+    return Array.from(vec);
+}
+
+function cosineSim(a, b) {
+    if (!a || !b || a.length !== b.length) return 0;
+    let dot = 0, na = 0, nb = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        na += a[i] * a[i];
+        nb += b[i] * b[i];
+    }
+    if (!na || !nb) return 0;
+    return dot / Math.sqrt(na * nb);
+}
+
+class ShardManager {
+    constructor(allPorts) {
+        this.shards = new Map();   // id -> ShardDescriptor
+        this.portToShard = new Map(); // port -> shardId（方便反查）
+        this.dim = 64;
+
+        // 初始策略：把当前 AI_PORTS 按顺序平均分成几组，构成 “模型组”
+        // 例如 3 个端口 => 一个 shard；12 个端口 => 3~4 个 shard
+        const ports = allPorts.filter(p => !!p).map(p => Number(p));
+        const N = ports.length;
+        if (!N) return;
+        const targetShardCount = Math.min(4, Math.max(1, Math.floor(N / 3))) || 1;
+        const shardSize = Math.max(1, Math.floor(N / targetShardCount));
+        let idx = 0;
+        for (let s = 0; s < targetShardCount; s++) {
+            const slice = ports.slice(idx, idx + shardSize);
+            idx += shardSize;
+            if (!slice.length) break;
+            const id = `shard_${s}`;
+            const desc = new ShardDescriptor({
+                id,
+                ports: slice,
+                embedding: null,
+                tags: []  // 可以后续通过API补充
+            });
+            this.shards.set(id, desc);
+            for (const p of slice) this.portToShard.set(p, id);
+        }
+    }
 
+    listShards() {
+        return Array.from(this.shards.values()).map(s => ({
+            id: s.id,
+            ports: s.ports,
+            tags: s.tags,
+            loaded: s.loaded,
+            lastUsedTs: s.lastUsedTs,
+            usageCount: s.usageCount
+        }));
+    }
+
+    // 手工更新某个 shard 的语义中心 + 标签
+    updateShardMeta(id, { embedding, tags } = {}) {
+        const s = this.shards.get(id);
+        if (!s) return false;
+        if (Array.isArray(embedding)) s.embedding = embedding.slice();
+        if (Array.isArray(tags)) s.tags = tags.slice();
+        return true;
+    }
+
+    /**
+     * 根据当前对话 embedding + 可选 tags，选出本轮要用的 shard 列表
+     * @param {number[]} queryEmb
+     * @param {Object} opt
+     * @param {number} opt.topK    选多少个 shard
+     * @param {string[]} [opt.hints] 额外提示（如 'code','zh'）
+     */
+    selectShards(queryEmb, { topK = 2, hints = [] } = {}) {
+        const entries = Array.from(this.shards.values()).filter(s => s.loaded && s.ports.length);
+        if (!entries.length) return [];
+
+        const scores = entries.map(s => {
+            let sim = 0;
+            if (s.embedding) sim = cosineSim(queryEmb, s.embedding);
+            let tagBonus = 0;
+            if (hints && hints.length && s.tags && s.tags.length) {
+                const inter = s.tags.filter(t => hints.includes(t));
+                tagBonus = inter.length ? 0.1 * inter.length : 0;
+            }
+            // 加一点近期使用度的温度
+            const usageBoost = Math.log(1 + s.usageCount) * 0.01;
+            return { shard: s, score: sim + tagBonus + usageBoost };
+        });
+        scores.sort((a, b) => b.score - a.score);
+        const out = scores.slice(0, Math.max(1, topK)).map(x => x.shard);
+        const now = Date.now();
+        for (const s of out) { s.lastUsedTs = now; s.usageCount++; }
+        return out;
+    }
+
+    // 当前端口属于哪个 shard（用于监控）
+    shardOfPort(port) {
+        const id = this.portToShard.get(Number(port));
+        return id || null;
+    }
+}
+
+// 初始化 ShardManager
+const AI_PORTS = [
+    process.env.AI_PORT_A || process.argv[3],
+    process.env.AI_PORT_B || process.argv[4],
+    process.env.AI_PORT_C || process.argv[5]
+];
+const Study_Port = process.env.AI_STUDY_PORT || process.argv[6];
+
+const shardManager = new ShardManager(AI_PORTS);
+// ========== 冷/热池调度结束 ==========
 // 新增：统一从各后端响应中提取文本
 function extractText(resp) {
     if (!resp) return '';
@@ -1169,28 +1322,30 @@ function perturb(arr) {
  */
 // 修改 requestAI，返回 null 表示离线
 // 修改 requestAI 函数，增加重试和超时处理
-async function requestAI(port, message, retries = 3) {
+async function requestAI(port, message, retries = 3, shardId = null) {
     const url = `http://localhost:${port}/api/chat`;
     for (let attempt = 1; attempt <= retries; attempt++) {
         try {
             const start = Date.now();
-            const response = await axios.post(url, { message }, { timeout: 10000 }); // 10秒超时
+            const response = await axios.post(url, { message }, { timeout: 10000 });
             const latency = Date.now() - start;
             systemStats.aiResponseTimes[port] = systemStats.aiResponseTimes[port] || [];
             systemStats.aiResponseTimes[port].push(latency);
+            // 这里可以将 shardId 写入统计日志，但先不动 API
             return response.data;
         } catch (error) {
-            console.warn(`[WARN] 请求 AI 实例 ${port} 失败 (尝试 ${attempt}/${retries}): ${error.message}`);
+            console.warn(`[WARN] 请求 AI 实例 ${port} (shard=${shardId || 'unknown'}) 失败 (尝试 ${attempt}/${retries}): ${error.message}`);
             if (attempt === retries) {
                 systemStats.lastErrors.push({ port, error: error.message });
-                return null; // 返回 null 表示服务不可用
+                return null;
             }
-            await new Promise(resolve => setTimeout(resolve, 1000)); // 重试前等待 1 秒
+            await new Promise(resolve => setTimeout(resolve, 1000));
         }
     }
 }
 
 
+// ...existing code...
 app.post('/api/chat', async (req, res) => {
     const { message } = req.body;
     if (!message) return res.status(400).json({ error: 'No message' });
@@ -1205,27 +1360,49 @@ app.post('/api/chat', async (req, res) => {
     let results = [];
 
     try {
-        // 星火阵列多轮交互（每一轮并发请求3个AI）
+        // === 核心：为当前请求生成embedding并选择合适 shard ===
+        const queryEmb = textToMiniEmbedding(message, shardManager.dim);
+        // 可加一点简单的“领域 hint”：例如包含 code / law / zh 等关键词
+        const hints = [];
+        const lower = message.toLowerCase();
+        if (/[{};()=]/.test(message) || /code|function|class|import|def /.test(lower)) hints.push('code');
+        if (/[，。？！]/.test(message) || /的|了|吗/.test(message)) hints.push('zh');
+        // 暂时不细分，topK=2
+        const selectedShards = shardManager.selectShards(queryEmb, { topK: 2, hints });
+
+        // 从被选中的 shard 中收集端口
+        let candidatePorts = [];
+        for (const s of selectedShards) candidatePorts.push(...s.ports);
+        // 去重复
+        candidatePorts = Array.from(new Set(candidatePorts));
+
+        // 如果还为空，兜底用全部 AI_PORTS
+        if (!candidatePorts.length) {
+            candidatePorts = AI_PORTS.filter(p => !!p);
+        }
+
+        // 星火阵列多轮交互（每一轮并发请求若干 AI）
         for (let round = 0; round <= communicateCount; round++) {
+            const msgArr = inputs.map(arr => (arr || words).join(' '));
+            // 对不超过 candidatePorts.length 的前几个输入进行并发请求
             results = await Promise.all(
-                AI_PORTS.map((port, i) => requestAI(port, (inputs[i] || words).join(' ')))
+                candidatePorts.map((port, idx) =>
+                    requestAI(port, msgArr[idx % msgArr.length], 3, shardManager.shardOfPort(port))
+                )
             );
 
-            // 下一轮输入为本轮输出分词（先提取文本，再 split）
             if (round < communicateCount) {
-                console.log(results);
                 inputs = results.map(r => extractText(r).toLowerCase().split(/\s+/).filter(Boolean));
             }
         }
 
-        // 只保留有效响应（提取为字符串）
         const texts = results.map(extractText).filter(t => typeof t === 'string' && t.length > 0);
         if (texts.length === 0) {
             systemStats.requestsFailed++;
             return res.status(502).json({ error: '所有AI实例均不可用或无响应' });
         }
 
-        // 统计词频
+        // ...后面词频融合 + SERIALIZER_API 部分保持不变...
         const freq = {};
         texts.forEach(t => t.split(/\s+/).forEach(w => { if (w) freq[w] = (freq[w] || 0) + 1; }));
         const sorted = Object.entries(freq).sort((a, b) => b[1] - a[1]);
@@ -1247,7 +1424,18 @@ app.post('/api/chat', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+app.get('/api/shards', (req, res) => {
+    res.json({ ok: true, shards: shardManager.listShards() });
+});
 
+// 更新某个 shard 的标签/embedding（embedding 可手工填或从文件导入）
+app.post('/api/shards/:id/meta', (req, res) => {
+    const { id } = req.params;
+    const { embedding, tags } = req.body || {};
+    const ok = shardManager.updateShardMeta(id, { embedding, tags });
+    if (!ok) return res.status(404).json({ ok: false, error: 'shard not found' });
+    res.json({ ok: true });
+});
 //==============================================================================
 // 新增功能：模型参数调节
 //==============================================================================