BrainExpander

类 BrainExpander 在 core/neuro/brain_expander.py: BrainV13 扩容器 | 方法: __init__, expand, record_think, auto_expand, get_stats, get_history

class BrainExpander:
    """BrainV13 扩容器"""

    AUTO_TRIGGERS = {
        "memory_usage_ratio": 0.85,
        "avg_confidence": 0.3,
        "stall_frequency": 5,
        "output_norm_avg": 0.1,
    }

    def __init__(self, brain):
        self.brain = brain
        self._expand_history: List[Dict] = []
        self._stats = {
            "memory_usage_ratio": 0.0,
            "avg_confidence": 0.5,
            "stall_count": 0,
            "output_norm_avg": 1.0,
            "total_thinks": 0,
        }

    def expand(self,
               input_dim: Optional[int] = None,
               output_dim: Optional[int] = None,
               memory_capacity: Optional[int] = None,
               hidden_dim_scale: float = 1.0) -> Dict:
        """手动扩容"""
        changes = {}
        old_info = self.brain.info()

        if input_dim and input_dim != self.brain.input_dim:
            old_input = self.brain.input_dim
            self.brain.input_dim = input_dim
            from .regions.sensory_region import SensoryRegion
            self.brain.sensory = SensoryRegion(input_dim=input_dim, output_dim=64)
            changes["input_dim"] = f"{old_input} -> {input_dim}"

        if output_dim and output_dim != self.brain.output_dim:
            old_output = self.brain.output_dim
            self.brain.output_dim = output_dim
            from .regions.motor_region import MotorRegion
            self.brain.motor = MotorRegion(input_dim=32, output_dim=output_dim)
            changes["output_dim"] = f"{old_output} -> {output_dim}"

        if memory_capacity and memory_capacity != self.brain.hippocampus.memory_capacity:
            old_cap = self.brain.hippocampus.memory_capacity
            self.brain.hippocampus.memory_capacity = memory_capacity
            changes["memory_capacity"] = f"{old_cap} -> {memory_capacity}"

        if hidden_dim_scale != 1.0:
            if hasattr(self.brain.association, 'hidden_dim'):
                old_h = self.brain.asso


方法 BrainExpander.record_think():
        self._stats["total_thinks"] += 1
        self._stats["output_norm_avg"] = self._stats["outp

def record_think(self):
        self._stats["total_thinks"] += 1
        self._stats["output_norm_avg"] = self._stats["output_norm_avg"] * 0.9 + float(np.linalg.norm(output)) * 0.1
        self._stats["avg_confidence"] = self._stats["avg_confidence"] * 0.9 + confidence * 0.1
        if stall:
            self._stats["stall_count"] += 1
        else:
            self._stats["stall_count"] = 0
        mem_used = len(self.brain.hippocampus._memory_keys)
        mem_cap = self.brain.hippocampus.memory_capacity
        self._stats["memory_usage_ratio"] = mem_used / mem_cap if mem_cap > 0 else 0


方法 BrainExpander.get_stats():
        return self._stats.copy()

def get_stats(self):
        return self._stats.copy()


方法 BrainExpander.get_history():
        return self._expand_history.copy()

def get_history(self):
        return self._expand_history.copy()


文件 core/neuro/chat_interface.py: 虫群v11 — 对话接口

在Brain类上添加chat()方法，整合:
- SimpleTokenizer + EmbeddingLayer (文本→向量)
- Brain.think() (6脑区信号处理)
- DialogueMemory (对话记忆存取)
- PrefrontalHybrid (混合推理: 虫群+LLM)
- TextDecoder (向量→文本)

信号流:
  文本输入 | 定义: class ChatInterface, def from_pickle, def __init__, def chat, def get_stats, def teach

#!/usr/bin/env python3
"""
虫群v11 — 对话接口

在Brain类上添加chat()方法，整合:
- SimpleTokenizer + EmbeddingLayer (文本→向量)
- Brain.think() (6脑区信号处理)
- DialogueMemory (对话记忆存取)
- PrefrontalHybrid (混合推理: 虫群+LLM)
- TextDecoder (向量→文本)

信号流:
  文本输入 → tokenizer → embedding(32维) →
  虫群模式: Brain.think() → decoder → 文本输出
  LLM模式: PrefrontalHybrid → LLM回复 → 存入记忆 → 文本输出
"""

import pickle
import numpy as np
from typing import Dict, Optional

from .text_encoder import SimpleTokenizer, EmbeddingLayer, TextDecoder
from .dia


ChatInterface

类 ChatInterface 在 core/neuro/chat_interface.py: v11对话接口 — 让虫群从数值处理器变成文字对话智能体

    用法:
        from core.neuro.brain import Brain
        brain = Brain.load("brain_trained.pkl")
        chat = ChatInterface(brain, api_key="nvapi-xxx")

  | 方法: from_pickle, __init__, chat, get_stats, teach

class ChatInterface:
    """
    v11对话接口 — 让虫群从数值处理器变成文字对话智能体

    用法:
        from core.neuro.brain import Brain
        brain = Brain.load("brain_trained.pkl")
        chat = ChatInterface(brain, api_key="nvapi-xxx")

        reply = chat.chat("你好")
        print(reply)  # "你好！很高兴认识你"
    """

    @classmethod
    def from_pickle(cls, pkl_path: str, api_key: str = None):
        """从pickle文件加载（支持v12和v13格式）"""
        with open(pkl_path, 'rb') as f:
            data = pickle.load(f)

        # 检测版本: v13有brain_v13和version字段
        version = data.get('version', 'v12')

        if version == 'v13':
            # v13格式: brain_v13 + migrated_from
            from .brain_v13 import BrainV13
            from .regions.sensory_region import SensoryRegion
            brain = data.get('brain_v13')
            # 如果brain为空，创建新的BrainV13
            if brain is None:
                print('Brain为空，创建新的BrainV13...')
                brain = BrainV13()
            # 旧pkl的SensoryRegion用的是FunctionalColumn(v1)，替换为v2
            if not hasattr(brain.sensory, '_W_semantic'):
                brain.sensory = SensoryRegion(
                    input_dim=brain.sensory.input_dim,
                    output_dim=brain.sensory.output_dim
                )
            # 旧pkl丘脑参数可能过旧，强制更新
            brain.thalamus.min_depth = 2
            brain.thalamus.stall_patience = 5
            # 旧pkl运动区可能还是32维输出，升级到64维匹配embedding
            if brain.motor.output_dim != 64:
                from .regions.motor_region import MotorRegion
                brain.motor = MotorRegion(input_dim=32, output_dim=64)
            dialogue_memory = None  # v13记忆内置于HippocampusRegion
            embedding = data.get('embedding')
            tokenizer = data.get('tokenizer')
        else:
            # v12格式: brain + dialogue_memory
            brain = data.get('brain')
            dialogue_memory = data.get('dialogue_memory')
            embedding = data.get('embedding')
            tokenizer = data.get('toke


方法 ChatInterface.from_pickle():
        """从pickle文件加载（支持v12和v13格式）"""
        with open(pkl_path, 'rb') as f:
            data = p

def from_pickle(self):
        """从pickle文件加载（支持v12和v13格式）"""
        with open(pkl_path, 'rb') as f:
            data = pickle.load(f)

        # 检测版本: v13有brain_v13和version字段
        version = data.get('version', 'v12')

        if version == 'v13':
            # v13格式: brain_v13 + migrated_from
            from .brain_v13 import BrainV13
            from .regions.sensory_region import SensoryRegion
            brain = data.get('brain_v13')
            # 如果brain为空，创建新的BrainV13
            if brain is None:
                print('Brain为空，创建新的BrainV13...')
                brain = BrainV13()
            # 旧pkl的SensoryRegion用的是FunctionalColumn(v1)，替换为v2
            if not hasattr(brain.sensory, '_W_semantic'):
                brain.sensory = SensoryRegion(
                    input_dim=brain.sensory.input_dim,
                    output_dim=brain.sensory.output_dim
                )
            # 旧pkl丘脑参数可能过旧，强制更新
            brain.thalamus.min_depth = 2
            brain.thalamus.stall_patien


teach

方法 ChatInterface.teach():
        """教会虫群一个问答对，存入对话记忆"""
        q_ids = self.tokenizer.encode(question, self.embedding)

def teach(self):
        """教会虫群一个问答对，存入对话记忆"""
        q_ids = self.tokenizer.encode(question, self.embedding)
        a_ids = self.tokenizer.encode(answer, self.embedding)
        q_vec = self.embedding.forward(q_ids)
        a_vec = self.embedding.forward(a_ids)
        self.dialogue_memory.store_turn(
            question_vec=q_vec, answer_vec=a_vec,
            question_text=question, answer_text=answer,
            source="teaching",
        )


从pickle文件加载（支持v12和v13格式）

函数 from_pickle(cls, pkl_path: str, api_key: str = None) 在 core/neuro/chat_interface.py: 从pickle文件加载（支持v12和v13格式）

def from_pickle(cls, pkl_path: str, api_key: str = None):
        """从pickle文件加载（支持v12和v13格式）"""
        with open(pkl_path, 'rb') as f:
            data = pickle.load(f)

        # 检测版本: v13有brain_v13和version字段
        version = data.get('version', 'v12')

        if version == 'v13':
            # v13格式: brain_v13 + migrated_from
            from .brain_v13 import BrainV13
            from .regions.sensory_region import SensoryRegion
            brain = data.get('brain_v13')
            # 如果brain为空，创建新的BrainV13
            if brain is None:
                print('Brain为空，创建新的BrainV13...')
                brain = BrainV13()
            # 旧pkl的SensoryRegion用的是FunctionalColumn(v1)，替换为v2
            if not hasattr(brain.sensory, '_W_semantic'):
                brain.sensory = SensoryRegion(
                    input_dim=brain.sensory.input_dim,
                    output_dim=brain.sensory.output_dim
                )
            # 旧pkl丘脑参数可能过旧，强制更新
            brain.thalamus.min_depth = 2
            brain.thalamus.stall_patience = 5
            # 旧pkl运动区可能还是32维输出，升级到64维匹配embedding
            if brain.motor.output_dim != 64:
                from .regions.motor_region import MotorRegion
                brain.motor = MotorRegion(input_dim=32, output_dim=64)
            dialogue_memory = None  # v13记忆内置于HippocampusRegion
            embedding = data.get('embedding')
            tokenizer = data.get('tokenizer')
        else:
            # v12格式: brain + dialogue_memory
            brain = data.get('brain')
            dialogue_memory = data.get('dialogue_memory')
            embedding = data.get('embedding')
            tokenizer = data.get('tokenizer')

        chat = cls(brain=brain, api_key=api_key)
        if dialogue_memory:
            chat.dialogue_memory = dialogue_memory
            chat.hybrid.dialogue_memory = dialogue_memory
            chat.hybrid.swarm_reasoner.dialogue_memory = dialogue_memory
        # 使用保存的embedding和tokenizer
        if embedding:
            chat.embedding = embedding


neuron.py

文件 core/neuro/neuron.py: 虫群v10 — 神经元数学模型
5层处理: 树突→突触→胞体→激活→输出
3种类型: 兴奋性/抑制性/调节性 | 定义: class NeuronType, class Neuron, def __init__, def forward, def get_lateral_signal, def apply_modulation, def reset, def param_count, def memory_bytes, def info

#!/usr/bin/env python3
"""
虫群v10 — 神经元数学模型
5层处理: 树突→突触→胞体→激活→输出
3种类型: 兴奋性/抑制性/调节性
"""

import numpy as np
from enum import Enum

class NeuronType(Enum):
    EXCITATORY = "excitatory"   # 兴奋性 80% - 放大传递
    INHIBITORY = "inhibitory"   # 抑制性 15% - 压制约束
    MODULATORY = "modulatory"   # 调节性  5% - 控制状态

# 类型默认参数
TYPE_DEFAULTS = {
    NeuronType.EXCITATORY: {
        "leak_rate": 0.3,
        "threshold": 1.0,
        "output_scale": 1.0,
        "weight_sign": 1.0,      # 权重为正
        "lateral_str


NeuronType

类 NeuronType 在 core/neuro/neuron.py:  | 方法:

class NeuronType:
    EXCITATORY = "excitatory"   # 兴奋性 80% - 放大传递
    INHIBITORY = "inhibitory"   # 抑制性 15% - 压制约束
    MODULATORY = "modulatory"   # 调节性  5% - 控制状态

# 类型默认参数
TYPE_DEFAULTS = {
    NeuronType.EXCITATORY: {
        "leak_rate": 0.3,
        "threshold": 1.0,
        "output_scale": 1.0,
        "weight_sign": 1.0,      # 权重为正
        "lateral_strength": 0.0, # 不产生侧向抑制
    },
    NeuronType.INHIBITORY: {
        "leak_rate": 0.5,        # 更快衰减
        "threshold": 0.8,        # 更低阈值(更易激活)
        "output_scale": -0.5,    # 负输出
        "weight_sign": -1.0,     # 权重为负
        "lateral_strength": 0.3, # 侧向抑制强度
    },
    NeuronType.MODULATORY: {
        "leak_rate": 0.1,        # 慢衰减(持久影响)
        "threshold": 1.5,        # 高阈值(不易激活)
        "output_scale": 1.0,
        "weight_sign": 1.0,
        "lateral_strength": 0.0,
    },
}


Neuron

类 Neuron 在 core/neuro/neuron.py: 单神经元数学模型

    5层处理流程:
    1. 树突处理: xi' = αi · xi
    2. 突触传递: si = wi · xi' · σ(η)
    3. 胞体整合: V(t) = V(t-1)·λ + Σ(si) + b
    4. 激活判断: o = f(V - θ) if V > θ
    5. 输出:     out = β · o

    3 | 方法: __init__, forward, get_lateral_signal, apply_modulation, reset, param_count, memory_bytes, info

class Neuron:
    """
    单神经元数学模型

    5层处理流程:
    1. 树突处理: xi' = αi · xi
    2. 突触传递: si = wi · xi' · σ(η)
    3. 胞体整合: V(t) = V(t-1)·λ + Σ(si) + b
    4. 激活判断: o = f(V - θ) if V > θ
    5. 输出:     out = β · o

    3种类型:
    - 兴奋性: 输出>0, 放大传递信号
    - 抑制性: 输出<0, 侧向抑制约束
    - 调节性: 输出0-1, 调节其他神经元参数(θ/λ)
    """

    def __init__(self, input_dim=14, neuron_type=NeuronType.EXCITATORY,
                 leak_rate=None, threshold=None, output_scale=None):
        self.input_dim = input_dim
        self.neuron_type = neuron_type

        # 从类型默认值加载参数
        defaults = TYPE_DEFAULTS[neuron_type]
        self.leak_rate = leak_rate if leak_rate is not None else defaults["leak_rate"]
        self.threshold = threshold if threshold is not None else defaults["threshold"]
        self.output_scale = output_scale if output_scale is not None else defaults["output_scale"]
        self.weight_sign = defaults["weight_sign"]
        self.lateral_strength = defaults["lateral_strength"]

        # 权重参数
        self.alpha = np.random.randn(input_dim) * 0.1  # 树突增益
        # 权重符号由类型决定
        raw_weight = np.random.randn(input_dim) * 0.5
        self.weight = np.abs(raw_weight) * self.weight_sign
        self.noise_scale = np.abs(np.random.randn(input_dim)) * 0.1
        self.bias = np.random.randn() * 0.1

        # 调节性神经元专用: 调节目标参数
        self.modulate_threshold = 0.0   # 对目标θ的调节量
        self.modulate_leak = 0.0        # 对目标λ的调节量

        # 状态
        self.membrane_potential = 0.0
        self.last_output = 0.0

    def forward(self, x: np.ndarray) -> float:
        """单次前向传播"""
        # 1. 树突处理
        x_dendrite = self.alpha * x
        # 2. 突触传递
        noise = np.random.randn(self.input_dim) * self.noise_scale
        s = self.weight * x_dendrite * (1 + noise)
        # 3. 胞体整合
        self.membrane_potential = (
            self.membrane_potential * self.leak_rate + np.sum(s) + self.bias
        )
        # 4. 激活判断
        if self.neuron_type =


方法 Neuron.apply_modulation():
        """接受调节信号，调整自身参数(调节性神经元作用)"""
        # mod_signal: 0-1范围
        # 高调节信号 → 降低阈值(更易激活) + 加快

def apply_modulation(self):
        """接受调节信号，调整自身参数(调节性神经元作用)"""
        # mod_signal: 0-1范围
        # 高调节信号 → 降低阈值(更易激活) + 加快衰减(更响应快)
        self.threshold = max(0.1, self.threshold - mod_signal * 0.1)
        self.leak_rate = min(0.9, self.leak_rate + mod_signal * 0.05)


reset

方法 Neuron.reset():
        """重置膜电位"""
        self.membrane_potential = 0.0
        self.last_output = 0.0

    @

def reset(self):
        """重置膜电位"""
        self.membrane_potential = 0.0
        self.last_output = 0.0

    @property


文件 core/neuro/regions/motor_region.py: 虫群v13 — 运动区

功能：将前额区决策信号转化为输出动作
- 决策锐化：softmax-like，决策越确定输出越sharp
- 置信度评估：决策向量的集中度 | 定义: class MotorRegion, def __init__, def forward, def _sharpen, def _compute_confidence, def total_params

#!/usr/bin/env python3
"""
虫群v13 — 运动区

功能：将前额区决策信号转化为输出动作
- 决策锐化：softmax-like，决策越确定输出越sharp
- 置信度评估：决策向量的集中度
"""

import numpy as np
from typing import Tuple

class MotorRegion:
    """
    运动区 — 决策执行

    输入: prefrontal_decision(32维)
    输出: motor_output(32维) + decision_confidence(1维)

    改动最小: 当前结构基本够用，加一个锐化操作
    """

    def __init__(self, input_dim: int = 32, output_dim: int = 32,
                 sharpness: float = 2.0):
        self.input_dim = input_dim
        self.output


MotorRegion

类 MotorRegion 在 core/neuro/regions/motor_region.py: 运动区 — 决策执行

    输入: prefrontal_decision(32维)
    输出: motor_output(32维) + decision_confidence(1维)

    改动最小: 当前结构基本够用，加一个锐化操作 | 方法: __init__, forward, _sharpen, _compute_confidence, total_params

class MotorRegion:
    """
    运动区 — 决策执行

    输入: prefrontal_decision(32维)
    输出: motor_output(32维) + decision_confidence(1维)

    改动最小: 当前结构基本够用，加一个锐化操作
    """

    def __init__(self, input_dim: int = 32, output_dim: int = 32,
                 sharpness: float = 2.0):
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.sharpness = sharpness  # 锐化强度

        # 输出变换矩阵
        self.W_out = np.random.randn(output_dim, input_dim).astype(np.float32) * 0.3
        self.b_out = np.zeros(output_dim, dtype=np.float32)

    def forward(self, decision: np.ndarray) -> Tuple[np.ndarray, float]:
        """
        决策 → 输出

        Args:
            decision: 前额区决策信号(32维)

        Returns:
            (motor_output, decision_confidence)
        """
        decision = np.asarray(decision, dtype=np.float32).ravel()

        # 维度适配
        if len(decision) < self.input_dim:
            decision = np.pad(decision, (0, self.input_dim - len(decision)))
        elif len(decision) > self.input_dim:
            decision = decision[:self.input_dim]

        # 置信度: 直接从决策输入计算(锐化前)
        confidence = float(self._compute_confidence(decision))

        # 线性变换
        output = self.W_out @ decision + self.b_out

        # 决策锐化: 增强强信号
        output = self._sharpen(output)

        return output.astype(np.float32), confidence

    def _sharpen(self, x: np.ndarray) -> np.ndarray:
        """
        锐化: 增强强信号、抑制弱信号

        策略: 保留符号，对幅度做power变换
        大值被放大，小值被缩小
        """
        sign = np.sign(x)
        magnitude = np.abs(x)
        # power变换: x^sharpness, 保留相对差异
        # 需要先归一化避免溢出
        max_mag = np.max(magnitude)
        if max_mag > 1e-8:
            normalized = magnitude / max_mag
            sharpened_mag = np.power(normalized, 1.0 / self.sharpness) * max_mag
        else:
            sharpened_mag = magnitude
        return sign * sharpened_mag

    def _compute_conf


文件 core/neuro/regions/__init__.py: 虫群v13 — 脑区专用模块 | 定义:

#!/usr/bin/env python3
"""虫群v13 — 脑区专用模块"""

from .sensory_region import SensoryRegion
from .hippocampus_region import HippocampusRegion
from .association_region import AssociationRegion
from .prefrontal_region import PrefrontalRegion
from .motor_region import MotorRegion
from .thalamus_region import ThalamusRegion


文件 core/neuro/regions/hippocampus_region.py: 虫群v13 — 海马区 (HippocampusRegion)

功能：记忆存取 + 模式补全
- 内置向量记忆库（不依赖外部DialogueMemory）
- 记忆检索：余弦相似度匹配
- 模式补全：部分匹配时用已有记忆补全缺失部分
- 记忆存储：由前额区触发

输入：sensory_features(64维) + 可选query(64维，前额区循环检索时传入)
输出：memory_result | 定义: class HippocampusRegion, def __init__, def forward, def _retrieve, def _pattern_completion, def store, def memory_count, def total_params, def info

#!/usr/bin/env python3
"""
虫群v13 — 海马区 (HippocampusRegion)

功能：记忆存取 + 模式补全
- 内置向量记忆库（不依赖外部DialogueMemory）
- 记忆检索：余弦相似度匹配
- 模式补全：部分匹配时用已有记忆补全缺失部分
- 记忆存储：由前额区触发

输入：sensory_features(64维) + 可选query(64维，前额区循环检索时传入)
输出：memory_result(64维) + memory_confidence(1维)
"""

import numpy as np
from typing import Dict, List, Optional, Tuple

class HippocampusRegion:
    """
    海马区 — 记忆存取 + 模式补全

    核心能力：
    1. 记忆检索：从内置记忆库找最相似记忆
    2. 模式补全：部分匹配时混合sensory和best_match
    3. 记忆存储：新信息写入（由外部触发）

    与旧B


HippocampusRegion

类 HippocampusRegion 在 core/neuro/regions/hippocampus_region.py: 海马区 — 记忆存取 + 模式补全

    核心能力：
    1. 记忆检索：从内置记忆库找最相似记忆
    2. 模式补全：部分匹配时混合sensory和best_match
    3. 记忆存储：新信息写入（由外部触发）

    与旧BrainRegion区别：
    - 内置记忆库，不是通用forward
    - 模式补全是核心——这是海马体的真正能力
    | 方法: __init__, forward, _retrieve, _pattern_completion, store, memory_count, total_params, info

class HippocampusRegion:
    """
    海马区 — 记忆存取 + 模式补全

    核心能力：
    1. 记忆检索：从内置记忆库找最相似记忆
    2. 模式补全：部分匹配时混合sensory和best_match
    3. 记忆存储：新信息写入（由外部触发）

    与旧BrainRegion区别：
    - 内置记忆库，不是通用forward
    - 模式补全是核心——这是海马体的真正能力
    - confidence传给丘脑和前额区，决定是否继续检索
    """

    def __init__(self, input_dim: int = 64, memory_capacity: int = 10000):
        self.input_dim = input_dim
        self.memory_capacity = memory_capacity

        # --- 内置向量记忆库 ---
        # 存储(key, value)对，key是输入向量，value是记忆向量
        self._memory_keys: List[np.ndarray] = []    # 检索用
        self._memory_values: List[np.ndarray] = []   # 返回用
        self._memory_freq: List[int] = []            # 访问频率

        # --- 功能柱：用于模式补全的变换 ---
        # 补全变换矩阵：将sensory特征映射到记忆空间
        self._completion_W = np.random.randn(
            input_dim, input_dim
        ).astype(np.float32) * 0.1

        # --- 检索统计 ---
        self._total_retrieves = 0
        self._total_stores = 0

    def forward(self, sensory_features: np.ndarray,
                query: Optional[np.ndarray] = None) -> Tuple[np.ndarray, float]:
        """
        海马区前向传播

        Args:
            sensory_features: 感觉区输出(64维)
            query: 前额区循环检索时的精炼查询(64维)，优先于sensory

        Returns:
            (memory_result, memory_confidence)
            - memory_result: 64维，记忆检索/补全结果
            - memory_confidence: 0-1，检索置信度
        """
        features = np.asarray(sensory_features, dtype=np.float32).ravel()

        # 如果有精炼query，优先使用（循环推理时前额区传入）
        search_vec = query if query is not None else features

        # 维度适配
        if len(search_vec) < self.input_dim:
            search_vec = np.pad(search_vec, (0, self.input_dim - len(search_vec)))
        elif len(search_vec) > self.input_dim:
            search_vec = search_vec[:self.input_dim]

        # 1. 记忆检索
        best_match, best_sim = self._retrieve(search_vec)

        # 2. 模式补全
        memory_result, memory_confidence = s


store

方法 HippocampusRegion.store():
        """
        存储新记忆

        Args:
            key: 检索键(64维)
            value: 记忆值(6

def store(self):
        """
        存储新记忆

        Args:
            key: 检索键(64维)
            value: 记忆值(64维)
        """
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()

        # 维度适配
        if len(key) < self.input_dim:
            key = np.pad(key, (0, self.input_dim - len(key)))
        if len(value) < self.input_dim:
            value = np.pad(value, (0, self.input_dim - len(value)))

        # 检查是否已存在相似记忆（避免重复）
        if self._memory_keys:
            keys_matrix = np.array(self._memory_keys)
            key_norm = np.linalg.norm(key)
            if key_norm > 1e-8:
                dots = keys_matrix @ key
                norms = np.linalg.norm(keys_matrix, axis=1) * key_norm
                norms = np.maximum(norms, 1e-8)
                sims = dots / norms
                if np.max(sims) > 0.95:
                    # 已有高度相似记忆，更新而非新增
                    idx = int(np.argmax(sims))


文件 core/neuro/regions/sensory_region.py: 虫群v13 — 感觉区 (SensoryRegion) v2

功能：将外部输入(如embedding)转换为标准量级的内部表示
- 输入归一化：自动将任意量级输入缩放到标准范围
- 双通道提取：语义通道 + 强度通道
- 不再依赖FunctionalColumn，改用轻量线性变换

输入：raw_input(input_dim维，通常32维embedding)
输出：sensory_featur | 定义: class SensoryRegion, def __init__, def forward, def reset, def total_params, def adaptive_scale, def info

#!/usr/bin/env python3
"""
虫群v13 — 感觉区 (SensoryRegion) v2

功能：将外部输入(如embedding)转换为标准量级的内部表示
- 输入归一化：自动将任意量级输入缩放到标准范围
- 双通道提取：语义通道 + 强度通道
- 不再依赖FunctionalColumn，改用轻量线性变换

输入：raw_input(input_dim维，通常32维embedding)
输出：sensory_features(64维) + sensory_strength(0~1标量)
"""

import numpy as np
from typing import Tuple

class SensoryRegion:
    """
    感觉区 — 输入感知 + 特征提取

    核心改进（v2）：
    1. 输入自适应归一化——无论输入量级多大都能正确响应
    2. 轻量线性变换替代FunctionalColumn——消除ReLU裁剪问题
    3. 双通道设计保留——语义通道+强度通道

    与旧版区别：


SensoryRegion

类 SensoryRegion 在 core/neuro/regions/sensory_region.py: 感觉区 — 输入感知 + 特征提取

    核心改进（v2）：
    1. 输入自适应归一化——无论输入量级多大都能正确响应
    2. 轻量线性变换替代FunctionalColumn——消除ReLU裁剪问题
    3. 双通道设计保留——语义通道+强度通道

    与旧版区别：
    - 旧版用FunctionalColumn(2.17M参数)，ReLU裁剪微小信号 | 方法: __init__, forward, reset, total_params, adaptive_scale, info

class SensoryRegion:
    """
    感觉区 — 输入感知 + 特征提取

    核心改进（v2）：
    1. 输入自适应归一化——无论输入量级多大都能正确响应
    2. 轻量线性变换替代FunctionalColumn——消除ReLU裁剪问题
    3. 双通道设计保留——语义通道+强度通道

    与旧版区别：
    - 旧版用FunctionalColumn(2.17M参数)，ReLU裁剪微小信号→strength=0
    - 新版用3个轻量矩阵(~6K参数)，输入归一化后再变换，信号不丢失
    """

    def __init__(self, input_dim: int = 32, output_dim: int = 64):
        self.input_dim = input_dim
        self.output_dim = output_dim

        # --- 输入归一化层 ---
        # 将任意量级的输入映射到标准范围(norm~5)
        # 用可学习的缩放因子，初始值保守
        self._input_scale = np.ones(1, dtype=np.float32)

        # --- 语义变换矩阵 ---
        # 提取输入的语义模式
        self._W_semantic = np.random.randn(
            output_dim // 2, input_dim
        ).astype(np.float32) * 0.1

        # --- 强度变换矩阵 ---
        # 提取输入的强度/重要性分布
        self._W_strength = np.random.randn(
            output_dim // 2, input_dim
        ).astype(np.float32) * 0.1

        # --- 跨通道融合矩阵 ---
        # 让语义和强度通道互相增强
        self._W_fusion = np.random.randn(
            output_dim, output_dim
        ).astype(np.float32) * 0.05

        # --- 统计 ---
        self._forward_count = 0
        self._input_norms = []  # 最近输入范数，用于自适应

    def forward(self, x: np.ndarray) -> Tuple[np.ndarray, float]:
        """
        感觉区前向传播

        Args:
            x: 输入向量(input_dim维)

        Returns:
            (sensory_features, sensory_strength)
            - sensory_features: 64维特征向量
            - sensory_strength: 输入激活强度标量(0~1)
        """
        x = np.asarray(x, dtype=np.float32).ravel()

        # 维度适配
        if len(x) < self.input_dim:
            x = np.pad(x, (0, self.input_dim - len(x)))
        elif len(x) > self.input_dim:
            x = x[:self.input_dim]

        # --- Step 1: 输入自适应归一化 ---
        input_norm = float(np.linalg.norm(x))

        # 记录输入范数用于自适应(兼容旧pkl)
        if not hasattr(self, '_input_norms'):
            self._input_norms = []
        self._input_nor


reset

方法 SensoryRegion.reset():
        """重置状态"""
        self._input_norms = []

    @property

def reset(self):
        """重置状态"""
        self._input_norms = []

    @property


文件 core/neuro/regions/prefrontal_region.py: 虫群v13 — 前额区 (PrefrontalRegion) ★ 核心

功能：工作记忆维护 + 目标追踪 + 循环推理驱动

这是整个架构的核心：
- working_memory: 64维状态，跨循环持久，逐轮更新
- 循环控制: 根据coherence和轮次决定是否继续
- query_refinement: 用工作记忆生成新query送回海马区重新检索
- 决策输出: 推理完成时输出32维 | 定义: class PrefrontalRegion, def __init__, def init_cycle, def forward, def _should_stop, def force_decision, def reset, def round, def total_params, def info

#!/usr/bin/env python3
"""
虫群v13 — 前额区 (PrefrontalRegion) ★ 核心

功能：工作记忆维护 + 目标追踪 + 循环推理驱动

这是整个架构的核心：
- working_memory: 64维状态，跨循环持久，逐轮更新
- 循环控制: 根据coherence和轮次决定是否继续
- query_refinement: 用工作记忆生成新query送回海马区重新检索
- 决策输出: 推理完成时输出32维决策信号

信号流:
  每轮循环:
    1. 接收: integrated(64维) + coherence(1维) + memory_confidence(1维)
    2. 更新工作记忆: wm = f(wm, integrated, coherence)
    3. 判断: coherence > 0.6 or round >= max → 输出决策
    4. 否则: 生成refined_query送回海马区
"""

import numpy as np
from typing import Dict, Optiona


PrefrontalRegion

类 PrefrontalRegion 在 core/neuro/regions/prefrontal_region.py: 前额区 — 工作记忆 + 循环推理 + 决策

    不继承BrainRegion，完全独立实现。
    核心状态: working_memory(64维)，跨循环持久。 | 方法: __init__, init_cycle, forward, _should_stop, force_decision, reset, round, total_params, info

class PrefrontalRegion:
    """
    前额区 — 工作记忆 + 循环推理 + 决策

    不继承BrainRegion，完全独立实现。
    核心状态: working_memory(64维)，跨循环持久。
    """

    def __init__(self, input_dim: int = 64, output_dim: int = 32,
                 max_rounds: int = 10):
        """
        Args:
            input_dim: 输入维度(来自联合区的integrated)
            output_dim: 决策输出维度(送运动区)
            max_rounds: 最大循环轮次
        """
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.max_rounds = max_rounds

        # === 工作记忆 (核心状态) ===
        self.working_memory = np.zeros(input_dim, dtype=np.float32)
        self._wm_initialized = False

        # === 更新变换 ===
        # working_memory更新: wm = gate * integrated + (1-gate) * wm
        # gate由coherence控制
        self.W_update = np.random.randn(input_dim, input_dim).astype(np.float32) * 0.1
        self.b_update = np.zeros(input_dim, dtype=np.float32)

        # === 决策变换 ===
        # working_memory → 决策输出
        self.W_decision = np.random.randn(output_dim, input_dim).astype(np.float32) * 0.1
        self.b_decision = np.zeros(output_dim, dtype=np.float32)

        # === query精炼变换 ===
        # working_memory → refined_query(64维，送回海马区)
        self.W_refine = np.random.randn(input_dim, input_dim).astype(np.float32) * 0.1
        self.b_refine = np.zeros(input_dim, dtype=np.float32)

        # === 循环状态 ===
        self._round = 0
        self._done = False
        self._coherence_history = []

        # === 目标追踪 ===
        self._goal_vector = np.zeros(input_dim, dtype=np.float32)

    def init_cycle(self, initial_input: np.ndarray):
        """
        初始化新的思考循环

        Args:
            initial_input: 第一轮输入(来自联合区的integrated)
        """
        initial_input = np.asarray(initial_input, dtype=np.float32).ravel()

        # 工作记忆初始化为首次输入
        if len(initial_input) >= self.input_dim:
            self.working_memory = initial_input[:self.input_dim].copy()
        else:


方法 PrefrontalRegion.init_cycle():
        """
        初始化新的思考循环

        Args:
            initial_input: 第一轮输入(来自联合区的integra

def init_cycle(self):
        """
        初始化新的思考循环

        Args:
            initial_input: 第一轮输入(来自联合区的integrated)
        """
        initial_input = np.asarray(initial_input, dtype=np.float32).ravel()

        # 工作记忆初始化为首次输入
        if len(initial_input) >= self.input_dim:
            self.working_memory = initial_input[:self.input_dim].copy()
        else:
            self.working_memory[:len(initial_input)] = initial_input
        self._wm_initialized = True

        # 目标向量 = 初始输入(记住"我在思考什么")
        self._goal_vector = self.working_memory.copy()

        # 重置循环状态
        self._round = 1
        self._done = False
        self._coherence_history = []


reset

方法 PrefrontalRegion.reset():
        """重置工作记忆和循环状态"""
        self.working_memory = np.zeros(self.input_dim, dtype=np.float32)

def reset(self):
        """重置工作记忆和循环状态"""
        self.working_memory = np.zeros(self.input_dim, dtype=np.float32)
        self._wm_initialized = False
        self._round = 0
        self._done = False
        self._coherence_history = []
        self._goal_vector = np.zeros(self.input_dim, dtype=np.float32)

    @property


文件 core/neuro/regions/thalamus_region.py: 虫群v13 — 丘脑区

功能：全局调度 + 循环控制 + 注意力门控
- 思考深度预算：根据输入强度决定循环次数(1-10轮)
- 注意力门控：控制哪些脑区在当前轮次被激活
- 进展评估：监测coherence变化率，无进展时建议中断
- 紧急中断：连续N轮无进展强制输出 | 定义: class ThalamusRegion, def __init__, def compute_depth_budget, def update, def _compute_progress, def _update_attention, def _make_decision, def reset, def total_params

#!/usr/bin/env python3
"""
虫群v13 — 丘脑区

功能：全局调度 + 循环控制 + 注意力门控
- 思考深度预算：根据输入强度决定循环次数(1-10轮)
- 注意力门控：控制哪些脑区在当前轮次被激活
- 进展评估：监测coherence变化率，无进展时建议中断
- 紧急中断：连续N轮无进展强制输出
"""

import numpy as np
from typing import Dict, Tuple

class ThalamusRegion:
    """
    丘脑 — 全局调度中心

    从被动调制 → 主动调度

    输入: sensory_strength(1维) + 历史coherence
    输出: depth_budget + attention_gate + continue_flag
    """

    def __init__(self, n_regions: int = 5,
                 max_depth: int = 10,


ThalamusRegion

类 ThalamusRegion 在 core/neuro/regions/thalamus_region.py: 丘脑 — 全局调度中心

    从被动调制 → 主动调度

    输入: sensory_strength(1维) + 历史coherence
    输出: depth_budget + attention_gate + continue_flag | 方法: __init__, compute_depth_budget, update, _compute_progress, _update_attention, _make_decision, reset, total_params

class ThalamusRegion:
    """
    丘脑 — 全局调度中心

    从被动调制 → 主动调度

    输入: sensory_strength(1维) + 历史coherence
    输出: depth_budget + attention_gate + continue_flag
    """

    def __init__(self, n_regions: int = 5,
                 max_depth: int = 10,
                 min_depth: int = 2,
                 stall_patience: int = 3,
                 stall_threshold: float = 0.05):
        """
        Args:
            n_regions: 脑区数量(不含丘脑自身)
            max_depth: 最大循环轮次
            min_depth: 最小循环轮次
            stall_patience: 无进展容忍轮次
            stall_threshold: 无进展阈值(coherence变化<此值视为停滞)
        """
        self.n_regions = n_regions
        self.max_depth = max_depth
        self.min_depth = min_depth
        self.stall_patience = stall_patience or 4  # 允许4轮无进展再判定stall
        self.stall_threshold = stall_threshold

        # 注意力权重: 各脑区的激活强度
        self.attention_gate = np.ones(n_regions, dtype=np.float32)

        # 历史追踪
        self._coherence_history = []
        self._stall_count = 0
        self._current_depth = 0
        self._depth_budget = 1

    def compute_depth_budget(self, sensory_strength: float) -> int:
        """
        根据输入强度决定思考深度预算

        简单问候(strength低) → 1轮
        需要回忆(strength中) → 3-5轮
        复杂推理(strength高) → 7-10轮
        """
        # sensory_strength通常在0-1之间
        # 强度低=简单输入，快速反射
        # 强度高=复杂输入，需要深度思考
        # sensory_strength经sqrt映射后范围约0.1~1.0
        # 简单输入(strength~0.1) → 3轮
        # 中等输入(strength~0.5) → 7轮
        # 复杂输入(strength~1.0) → 10轮
        budget = self.min_depth + int(sensory_strength * (self.max_depth - self.min_depth))
        budget = max(self.min_depth, min(budget, self.max_depth))
        self._depth_budget = budget
        return budget

    def update(self, round_num: int, coherence: float,
               sensory_strength: float = None) -> Dict:
        """
        每轮循环的调度决策

        Args:
            round_num: 当前轮次(1-based)
            coherence: 当前一致性分数
            sensory_


reset

方法 ThalamusRegion.reset():
        """重置丘脑状态"""
        self.attention_gate = np.ones(self.n_regions, dtype=np.float32)

def reset(self):
        """重置丘脑状态"""
        self.attention_gate = np.ones(self.n_regions, dtype=np.float32)
        self._coherence_history.clear()
        self._stall_count = 0
        self._current_depth = 0
        self._depth_budget = 1

    @property


文件 core/neuro/regions/association_region.py: 虫群v13 — 联合区 (AssociationRegion)

功能: 多源信息整合 + 一致性检测
- 将感觉特征 + 记忆结果融合为统一表示
- 动态权重: 根据memory_confidence调整融合比例
- 一致性检测: sensory与memory矛盾时coherence低
- 输出: integrated(64维) + coherence(1维)

信号流:
sensory_fea | 定义: class AssociationRegion, def __init__, def forward, def _store_pattern, def total_params, def info

#!/usr/bin/env python3
"""
虫群v13 — 联合区 (AssociationRegion)

功能: 多源信息整合 + 一致性检测
- 将感觉特征 + 记忆结果融合为统一表示
- 动态权重: 根据memory_confidence调整融合比例
- 一致性检测: sensory与memory矛盾时coherence低
- 输出: integrated(64维) + coherence(1维)

信号流:
sensory_features(64维) ─┐
                        ├→ 加权融合(动态权重) → integrated(64维)
memory_result(64维) ────┘
                        → coherence = cosine(sensory, memory)
"""

import numpy as np
from typing import Dict, Tuple

class AssociationRegion:
    """
    联合区 — 多源信息整合中心


AssociationRegion

类 AssociationRegion 在 core/neuro/regions/association_region.py: 联合区 — 多源信息整合中心

    核心能力:
    1. 动态融合: 记忆置信度高则偏重记忆，低则偏重感觉
    2. 一致性检测: sensory和memory方向一致则coherence高
    3. 类比推理: 用融合变换矩阵做非线性组合 | 方法: __init__, forward, _store_pattern, total_params, info

class AssociationRegion:
    """
    联合区 — 多源信息整合中心

    核心能力:
    1. 动态融合: 记忆置信度高则偏重记忆，低则偏重感觉
    2. 一致性检测: sensory和memory方向一致则coherence高
    3. 类比推理: 用融合变换矩阵做非线性组合
    """

    def __init__(self, input_dim: int = 64):
        self.input_dim = input_dim

        # 融合变换矩阵: 两路64维 → 64维
        # W_sensory: 感觉通路权重
        self.W_sensory = np.random.randn(input_dim, input_dim).astype(np.float32) * 0.1
        # W_memory: 记忆通路权重
        self.W_memory = np.random.randn(input_dim, input_dim).astype(np.float32) * 0.1
        # 偏置
        self.bias = np.zeros(input_dim, dtype=np.float32)

        # 类比推理: 模式关联矩阵(存储常见联合模式)
        self._association_patterns = []  # [(pattern_vec, frequency)]
        self._max_patterns = 200

        # 统计
        self._fusion_count = 0

    def forward(self,
                sensory_features: np.ndarray,
                memory_result: np.ndarray,
                memory_confidence: float = 0.5
                ) -> Tuple[np.ndarray, float]:
        """
        多源融合 + 一致性检测

        Args:
            sensory_features: 感觉区输出(64维)
            memory_result: 海马区输出(64维)
            memory_confidence: 海马区置信度(0-1)

        Returns:
            (integrated, coherence)
            - integrated: 融合后表示(64维)
            - coherence: 一致性分数(0-1)
        """
        sensory = np.asarray(sensory_features, dtype=np.float32).ravel()
        memory = np.asarray(memory_result, dtype=np.float32).ravel()

        # 维度对齐
        if len(sensory) < self.input_dim:
            sensory = np.pad(sensory, (0, self.input_dim - len(sensory)))
        else:
            sensory = sensory[:self.input_dim]
        if len(memory) < self.input_dim:
            memory = np.pad(memory, (0, self.input_dim - len(memory)))
        else:
            memory = memory[:self.input_dim]

        # === 1. 一致性检测 ===
        norm_s = np.linalg.norm(sensory)
        norm_m = np.linalg.norm(memory)
        if norm_s > 1e-8 and norm_m > 1e-8:


gateway.py

文件 gateway/gateway.py: 虫群API网关 — 香港节点
功能：转发OpenAI/Anthropic/Google等API请求
部署：阿里云香港轻量云 1核1G | 定义: def verify_key, def match_upstream, def forward_request, def stream_generator, def chat_completions, def forward_anthropic, def forward_gemini, def generic_proxy, def health, def get_stats

fastapi fastapi.responses httpx asyncio json os time typing

#!/usr/bin/env python3
"""
虫群API网关 — 香港节点
功能：转发OpenAI/Anthropic/Google等API请求
部署：阿里云香港轻量云 1核1G
"""

from fastapi import FastAPI, Request, HTTPException, Header
from fastapi.responses import StreamingResponse, JSONResponse
import httpx
import asyncio
import json
import os
import time
from typing import Optional

app = FastAPI(title="Swarm Gateway", version="1.0")

# ========== 配置 ==========

# 网关鉴权密钥（客户端必须携带）
GATEWAY_KEY = os.environ.get("GATEWAY_KEY", "swarm-gateway-2026")

# 支持的上游API（自动路由）
UPSTR


函数 forward_request(
    upstream_name: str,
    path: str,
    method: str,
    headers: dict,
    body: bytes,
    stream: bool = False,
) 在 gateway/gateway.py: 转发请求到上游API

def forward_request(
    upstream_name: str,
    path: str,
    method: str,
    headers: dict,
    body: bytes,
    stream: bool = False,
):
    """转发请求到上游API"""
    upstream = UPSTREAMS.get(upstream_name)
    if not upstream:
        raise HTTPException(400, f"未知上游: {upstream_name}")

    if not upstream["key"]:
        raise HTTPException(400, f"上游 {upstream_name} 未配置API密钥")

    # 构建上游URL
    url = upstream["base"].rstrip("/") + path

    # 构建请求头（替换鉴权）
    fwd_headers = {}
    for k, v in headers.items():
        # 跳过host和原鉴权头
        if k.lower() in ("host", "authorization", "content-length"):
            continue
        fwd_headers[k] = v

    # 根据上游类型设置鉴权头
    if upstream_name == "anthropic":
        fwd_headers["x-api-key"] = upstream["key"]
        fwd_headers["anthropic-version"] = "2023-06-01"
    elif upstream_name == "gemini":
        # Gemini用URL参数传key
        url += f"?key={upstream['key']}" if "?" not in url else f"&key={upstream['key']}"
    else:
        # OpenAI兼容格式
        fwd_headers["Authorization"] = f"Bearer {upstream['key']}"

    # 统计
    stats["total"] += 1
    stats["by_upstream"][upstream_name] = stats["by_upstream"].get(upstream_name, 0) + 1

    # 发送请求
    async with httpx.AsyncClient(timeout=120.0) as client:
        if stream:
            # 流式转发
            async def stream_generator():
                try:
                    async with client.stream(method, url, headers=fwd_headers, content=body) as resp:
                        async for chunk in resp.aiter_bytes():
                            yield chunk
                except Exception as e:
                    stats["errors"] += 1
                    yield json.dumps({"error": str(e)}).encode()

            return StreamingResponse(
                stream_generator(),
                media_type="text/event-stream",
            )
        else:
            # 普通转发
            try:
                resp = await client.request(method, url, headers=fwd_headers, content=body)
                return JSONResponse(
                    content=resp.json() if resp.headers.get("content-type", "").startswith("application/json") e