方法 AggregationProtocol.add_remote_node():
        """添加远程节点"""
        node = NodeInfo(
            node_id=node_id,
            name=name or

def add_remote_node(self):
        """添加远程节点"""
        node = NodeInfo(
            node_id=node_id,
            name=name or node_id,
            role=role,
            address=address,
            capability=NodeCapability(
                specializations=capabilities or ["general"],
                compute_score=compute_score,
            ),
            permission_level=permission_level,
        )

        self.registry.register(node)
        if address:
            self.bus.register_node_address(node_id, address)
        self.permission.set_node_permission(node_id, permission_level)


方法 AggregationProtocol.add_local_node():
        """添加本地节点（同一进程）"""
        self.registry.register(protocol.node_info)
        self._local_t

def add_local_node(self):
        """添加本地节点（同一进程）"""
        self.registry.register(protocol.node_info)
        self._local_transport.register_bus(protocol.node_info.node_id, protocol.bus)
        self.permission.set_node_permission(
            protocol.node_info.node_id,
            protocol.node_info.permission_level
        )


方法 AggregationProtocol.remove_node():
        """移除节点"""
        self.registry.unregister(node_id)
        self.bus.unregister_node_addre


types.py

文件 core/aggregation_protocol/types.py: 虫群聚合协议 — 类型定义

核心概念：
- 临时服务器(TaskForce): 按任务需要，临时组合多个设备
- 节点(Node): 每个参与设备，可同时属于多个临时服务器
- 权限(Permission): 决定可调用模型的范围和数量 | 定义: class NodeRole, class NodeStatus, class TaskForceStatus, class PermissionLevel, class AggregationStrategy, class
class, class
class, def is_available, def can_accept_task, def to_dict

#!/usr/bin/env python3
"""
虫群聚合协议 — 类型定义

核心概念：
- 临时服务器(TaskForce): 按任务需要，临时组合多个设备
- 节点(Node): 每个参与设备，可同时属于多个临时服务器
- 权限(Permission): 决定可调用模型的范围和数量
"""

from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Any
from datetime import datetime

# ============================================================
# 节点角色与状态
# ============================================================

class NodeRole(Enum):
    """节点角色"""
    QUEEN = "queen"           # 虫后


NodeRole

类 NodeRole 在 core/aggregation_protocol/types.py: 节点角色 | 方法:

class NodeRole:
    """节点角色"""
    QUEEN = "queen"           # 虫后 — 个人模型系统
    CEREBRATE = "cerebrate"   # 脑虫 — 区域路由节点
    HIVE = "hive"             # 虫巢 — 中央模型集群
    DRONE = "drone"           # 子虫 — 功能模块


NodeStatus

类 NodeStatus 在 core/aggregation_protocol/types.py: 节点状态 | 方法:

class NodeStatus:
    """节点状态"""
    ONLINE = "online"         # 在线
    BUSY = "busy"             # 忙碌
    IDLE = "idle"             # 空闲
    OFFLINE = "offline"       # 离线
    TRAINING = "training"     # 训练中


TaskForceStatus

类 TaskForceStatus 在 core/aggregation_protocol/types.py: 临时服务器状态 | 方法:

class TaskForceStatus:
    """临时服务器状态"""
    FORMING = "forming"       # 组建中
    ACTIVE = "active"         # 活跃运行
    COMPLETED = "completed"   # 任务完成
    FAILED = "failed"         # 失败解散


PermissionLevel

类 PermissionLevel 在 core/aggregation_protocol/types.py: 权限等级 | 方法:

class PermissionLevel:
    """权限等级"""
    OVERMIND = 0     # 虫皇 — 可调用系统所有在线模型
    CEREBRATE = 1    # 脑虫 — 可调用管辖区域内模型
    QUEEN = 2        # 虫后 — 可调用授权范围内的模型
    DRONE = 3        # 子虫 — 仅能被调用


AggregationStrategy

类 AggregationStrategy 在 core/aggregation_protocol/types.py: 聚合策略 | 方法:

class AggregationStrategy:
    """聚合策略"""
    PARAMETER_AVERAGE = "parameter_average"     # 参数平均
    KNOWLEDGE_DISTILL = "knowledge_distill"     # 知识蒸馏
    ENSEMBLE_VOTE = "ensemble_vote"             # 集成投票
    SEQUENTIAL_REFINE = "sequential_refine"     # 顺序精炼
    ADAPTIVE_MIX = "adaptive_mix"               # 自适应混合

# ============================================================
# 核心数据结构
# ============================================================

@dataclass


NodeCapability

类 NodeCapability 在 core/aggregation_protocol/types.py: 节点能力描述 | 方法:

class NodeCapability:
    """节点能力描述"""
    model_types: List[str] = field(default_factory=list)  # 支持的模型类型
    max_concurrent: int = 1                               # 最大并发任务
    memory_mb: int = 0                                    # 可用内存
    compute_score: float = 0.0                            # 计算能力评分
    specializations: List[str] = field(default_factory=list)  # 专长领域

@dataclass


NodeInfo

节点信息 — 参与聚合协议的设备

类 NodeInfo 在 core/aggregation_protocol/types.py: 节点信息 — 参与聚合协议的设备 | 方法: is_available, can_accept_task, to_dict

class NodeInfo:
    """节点信息 — 参与聚合协议的设备"""
    node_id: str                              # 唯一标识
    name: str                                 # 显示名称
    role: NodeRole = NodeRole.QUEEN           # 角色
    status: NodeStatus = NodeStatus.IDLE      # 状态
    address: str = ""                         # 网络地址 host:port
    capability: NodeCapability = field(default_factory=NodeCapability)
    permission_level: PermissionLevel = PermissionLevel.QUEEN
    current_taskforces: List[str] = field(default_factory=list)  # 当前参与的临时服务器
    metadata: Dict[str, Any] = field(default_factory=dict)
    last_heartbeat: Optional[datetime] = None
    registered_at: datetime = field(default_factory=datetime.now)

    def is_available(self) -> bool:
        return self.status in (NodeStatus.ONLINE, NodeStatus.IDLE)

    def can_accept_task(self) -> bool:
        return self.is_available() and len(self.current_taskforces) < self.capability.max_concurrent

    def to_dict(self) -> Dict:
        return {
            "node_id": self.node_id,
            "name": self.name,
            "role": self.role.value,
            "status": self.status.value,
            "address": self.address,
            "permission_level": self.permission_level.value,
            "active_taskforces": len(self.current_taskforces),
            "compute_score": self.capability.compute_score,
        }

@dataclass


TaskForce

类 TaskForce 在 core/aggregation_protocol/types.py: 临时服务器 — 核心概念

    按任务需要，临时组合多个设备形成一个协同计算单元。
    任务完成后自动解散，设备回归空闲池。
    同一设备可同时参与多个不同的临时服务器。 | 方法: add_member, remove_member, to_dict

class TaskForce:
    """
    临时服务器 — 核心概念

    按任务需要，临时组合多个设备形成一个协同计算单元。
    任务完成后自动解散，设备回归空闲池。
    同一设备可同时参与多个不同的临时服务器。
    """
    taskforce_id: str                         # 唯一标识
    name: str                                 # 任务名称
    status: TaskForceStatus = TaskForceStatus.FORMING
    coordinator: str = ""                     # 协调节点ID
    members: List[str] = field(default_factory=list)  # 成员节点ID列表
    strategy: AggregationStrategy = AggregationStrategy.ADAPTIVE_MIX
    task_description: str = ""                # 任务描述
    created_at: datetime = field(default_factory=datetime.now)
    completed_at: Optional[datetime] = None
    results: Dict[str, Any] = field(default_factory=dict)
    metadata: Dict[str, Any] = field(default_factory=dict)

    def add_member(self, node_id: str):
        if node_id not in self.members:
            self.members.append(node_id)

    def remove_member(self, node_id: str):
        self.members = [m for m in self.members if m != node_id]

    def to_dict(self) -> Dict:
        return {
            "taskforce_id": self.taskforce_id,
            "name": self.name,
            "status": self.status.value,
            "coordinator": self.coordinator,
            "member_count": len(self.members),
            "members": self.members,
            "strategy": self.strategy.value,
            "task_description": self.task_description[:50],
        }

@dataclass


方法 TaskForce.add_member():
        if node_id not in self.members:
            self.members.append(node_id)

def add_member(self):
        if node_id not in self.members:
            self.members.append(node_id)


方法 TaskForce.remove_member():
        self.members = [m for m in self.members if m != node_id]

def remove_member(self):
        self.members = [m for m in self.members if m != node_id]


AggregationTask

聚合任务 — 需要多个节点协同完成的工作

类 AggregationTask 在 core/aggregation_protocol/types.py: 聚合任务 — 需要多个节点协同完成的工作 | 方法: to_dict

class AggregationTask:
    """聚合任务 — 需要多个节点协同完成的工作"""
    task_id: str
    query: str                                # 任务内容
    requester: str                            # 请求节点ID
    required_capabilities: List[str] = field(default_factory=list)  # 需要的能力
    min_nodes: int = 2                        # 最少节点数
    max_nodes: int = 5                        # 最多节点数
    strategy: AggregationStrategy = AggregationStrategy.ADAPTIVE_MIX
    priority: int = 5                         # 优先级 1-10
    timeout_sec: float = 60.0                 # 超时时间
    created_at: datetime = field(default_factory=datetime.now)
    status: str = "pending"                   # pending/assigned/running/done/failed
    taskforce_id: str = ""                    # 分配的临时服务器ID
    result: Optional[Dict] = None             # 最终结果

    def to_dict(self) -> Dict:
        return {
            "task_id": self.task_id,
            "query": self.query[:50],
            "requester": self.requester,
            "required_capabilities": self.required_capabilities,
            "min_nodes": self.min_nodes,
            "max_nodes": self.max_nodes,
            "strategy": self.strategy.value,
            "status": self.status,
            "taskforce_id": self.taskforce_id,
        }

@dataclass


ProtocolMessage

协议消息 — 节点间通信

类 ProtocolMessage 在 core/aggregation_protocol/types.py: 协议消息 — 节点间通信 | 方法: to_dict

class ProtocolMessage:
    """协议消息 — 节点间通信"""
    msg_id: str
    sender: str
    receiver: str  # 空字符串表示广播
    msg_type: str  # discover/join/leave/task_assign/task_result/heartbeat/sync
    payload: Dict[str, Any] = field(default_factory=dict)
    timestamp: datetime = field(default_factory=datetime.now)
    ttl: int = 10  # 跳数限制

    def to_dict(self) -> Dict:
        return {
            "msg_id": self.msg_id,
            "sender": self.sender,
            "receiver": self.receiver,
            "msg_type": self.msg_type,
            "timestamp": self.timestamp.isoformat(),
        }

@dataclass


PermissionGrant

类 PermissionGrant 在 core/aggregation_protocol/types.py: 权限授予记录 | 方法: is_valid, to_dict

class PermissionGrant:
    """权限授予记录"""
    grant_id: str
    granter: str          # 授权者
    grantee: str          # 被授权者
    scope: str            # 授权范围: all/region/domain/specific
    max_nodes: int = 10   # 可调用的最大节点数
    models_allowed: List[str] = field(default_factory=list)  # 允许的模型类型
    expires_at: Optional[datetime] = None
    created_at: datetime = field(default_factory=datetime.now)

    def is_valid(self) -> bool:
        if self.expires_at and datetime.now() > self.expires_at:
            return False
        return True

    def to_dict(self) -> Dict:
        return {
            "grant_id": self.grant_id,
            "granter": self.granter,
            "grantee": self.grantee,
            "scope": self.scope,
            "max_nodes": self.max_nodes,
            "valid": self.is_valid(),
        }


函数 add_member(self, node_id: str) 在 core/aggregation_protocol/types.py:

def add_member(self, node_id: str):
        if node_id not in self.members:
            self.members.append(node_id)

    def remove_member(self, node_id: str):
        self.members = [m for m in self.members if m != node_id]

    def to_dict(self) -> Dict:
        return {
            "taskforce_id": self.taskforce_id,
            "name": self.name,
            "status": self.status.value,
            "coordinator": self.coordinator,
            "member_count": len(self.members),
            "members": self.members,
            "strategy": self.strategy.value,
            "task_description": self.task_description[:50],
        }

@dataclass


transport.py

文件 core/aggregation_protocol/transport.py: 虫群聚合协议 — 通信层

两种通信模式：
1. HTTP模式：节点间通过HTTP API通信（适合公网部署）
2. 内存模式：同一进程内通信（适合测试和单机多模型）

设计原则：
- 消息格式统一（ProtocolMessage）
- 支持点对点和广播
- 超时和重试机制 | 定义: class MessageBus, def __init__, def register_handler, def send, def broadcast, def receive, def _deliver, def _deliver_to, def register_node_address, def unregister_node_address

hashlib json logging threading time collections datetime typing concurrent.futures .types

#!/usr/bin/env python3
"""
虫群聚合协议 — 通信层

两种通信模式：
1. HTTP模式：节点间通过HTTP API通信（适合公网部署）
2. 内存模式：同一进程内通信（适合测试和单机多模型）

设计原则：
- 消息格式统一（ProtocolMessage）
- 支持点对点和广播
- 超时和重试机制
"""

import hashlib
import json
import logging
import threading
import time
from collections import deque
from datetime import datetime
from typing import Callable, Dict, List, Optional, Tuple
from concurrent.futures import ThreadPoolExecutor

try:
    import requests
    HAS_REQUESTS = True
except ImportError:
    HAS_REQUESTS = Fal


MessageBus

类 MessageBus 在 core/aggregation_protocol/transport.py: 消息总线 — 节点间通信的核心

    类似GPU集群中的NVLink/PCIe通信：
    - 点对点消息：发送给特定节点
    - 广播消息：发送给所有已知节点
    - 消息队列：异步收发 | 方法: __init__, register_handler, send, broadcast, receive, _deliver, _deliver_to, register_node_address, unregister_node_address, _create_message, get_stats, start, stop

class MessageBus:
    """
    消息总线 — 节点间通信的核心

    类似GPU集群中的NVLink/PCIe通信：
    - 点对点消息：发送给特定节点
    - 广播消息：发送给所有已知节点
    - 消息队列：异步收发
    """

    def __init__(self, self_node: NodeInfo, max_queue: int = 1000):
        self.self_node = self_node

        # 消息队列
        self._inbox = deque(maxlen=max_queue)
        self._outbox = deque(maxlen=max_queue)

        # 消息处理器 msg_type -> handler
        self._handlers: Dict[str, Callable] = {}

        # 已知节点地址 node_id -> address
        self._node_addresses: Dict[str, str] = {}

        # 线程安全
        self._lock = threading.RLock()
        self._running = False
        self._executor = ThreadPoolExecutor(max_workers=4)

        # 统计
        self._stats = {
            "sent": 0,
            "received": 0,
            "broadcasts": 0,
            "errors": 0,
        }

    # ============================================================
    # 消息处理
    # ============================================================

    def register_handler(self, msg_type: str, handler: Callable):
        """注册消息处理器"""
        self._handlers[msg_type] = handler

    def send(self, receiver: str, msg_type: str,
             payload: Dict = None) -> str:
        """发送点对点消息"""
        msg = self._create_message(receiver, msg_type, payload)

        with self._lock:
            self._outbox.append(msg)
            self._stats["sent"] += 1

        # 尝试立即发送
        self._deliver(msg)
        return msg.msg_id

    def broadcast(self, msg_type: str, payload: Dict = None) -> str:
        """广播消息给所有已知节点"""
        msg = self._create_message("", msg_type, payload)

        with self._lock:
            self._stats["broadcasts"] += 1

        # 发送给所有已知节点
        for node_id, address in list(self._node_addresses.items()):
            if node_id != self.self_node.node_id:
                self._deliver_to(msg, node_id, address)

        return msg.msg_id

    def receive(self, msg: ProtocolM


方法 MessageBus.register_handler():
        """注册消息处理器"""
        self._handlers[msg_type] = handler

def register_handler(self):
        """注册消息处理器"""
        self._handlers[msg_type] = handler


receive

方法 MessageBus.receive():
        """接收消息"""
        with self._lock:
            self._inbox.append(msg)
            self._s

def receive(self):
        """接收消息"""
        with self._lock:
            self._inbox.append(msg)
            self._stats["received"] += 1

        # 处理消息
        handler = self._handlers.get(msg.msg_type)
        if handler:
            try:
                self._executor.submit(handler, msg)
            except Exception as e:
                logger.error(f"消息处理失败: {e}")

    # ============================================================
    # 交付机制
    # ============================================================


方法 MessageBus.register_node_address():
        """注册节点地址"""
        with self._lock:
            self._node_addresses[node_id] = address

def register_node_address(self):
        """注册节点地址"""
        with self._lock:
            self._node_addresses[node_id] = address


方法 MessageBus.unregister_node_address():
        """注销节点地址"""
        with self._lock:
            self._node_addresses.pop(node_id, None)


start

方法 MessageBus.start():
        """启动消息总线"""
        self._running = True
        logger.info(f"消息总线启动: {self.self_node.nod

def start(self):
        """启动消息总线"""
        self._running = True
        logger.info(f"消息总线启动: {self.self_node.node_id}")


stop

方法 MessageBus.stop():
        """停止消息总线"""
        self._running = False
        self._executor.shutdown(wait=False)

def stop(self):
        """停止消息总线"""
        self._running = False
        self._executor.shutdown(wait=False)
        logger.info(f"消息总线停止: {self.self_node.node_id}")


LocalTransport

类 LocalTransport 在 core/aggregation_protocol/transport.py: 本地传输层 — 同一进程内节点间通信

    用于测试和单机多模型场景：
    - 虫后 + 多个子虫在同一进程中
    - 无需网络，直接方法调用 | 方法: __init__, register_bus, deliver_local, broadcast_local, get_node_ids

class LocalTransport:
    """
    本地传输层 — 同一进程内节点间通信

    用于测试和单机多模型场景：
    - 虫后 + 多个子虫在同一进程中
    - 无需网络，直接方法调用
    """

    def __init__(self):
        self._nodes: Dict[str, MessageBus] = {}
        self._lock = threading.RLock()

    def register_bus(self, node_id: str, bus: MessageBus):
        """注册节点的消息总线"""
        with self._lock:
            self._nodes[node_id] = bus

    def deliver_local(self, msg: ProtocolMessage):
        """本地投递消息"""
        with self._lock:
            target_bus = self._nodes.get(msg.receiver)
            if target_bus:
                target_bus.receive(msg)

    def broadcast_local(self, msg: ProtocolMessage, exclude: str = ""):
        """本地广播"""
        with self._lock:
            for node_id, bus in self._nodes.items():
                if node_id != msg.sender and node_id != exclude:
                    bus.receive(msg)

    def get_node_ids(self) -> List[str]:
        return list(self._nodes.keys())


方法 LocalTransport.register_bus():
        """注册节点的消息总线"""
        with self._lock:
            self._nodes[node_id] = bus

def register_bus(self):
        """注册节点的消息总线"""
        with self._lock:
            self._nodes[node_id] = bus


方法 LocalTransport.deliver_local():
        """本地投递消息"""
        with self._lock:
            target_bus = self._nodes.get(msg.receiver

def deliver_local(self):
        """本地投递消息"""
        with self._lock:
            target_bus = self._nodes.get(msg.receiver)
            if target_bus:
                target_bus.receive(msg)


方法 LocalTransport.broadcast_local():
        """本地广播"""
        with self._lock:
            for node_id, bus in self._nodes.items():

def broadcast_local(self):
        """本地广播"""
        with self._lock:
            for node_id, bus in self._nodes.items():
                if node_id != msg.sender and node_id != exclude:
                    bus.receive(msg)


economy.py

文件 core/aggregation_protocol/economy.py: 虫群经济系统 — 统一入口

整合算力货币、社交关系、交易市场
提供一站式经济服务 | 定义: class SwarmEconomy, def __init__, def register_node, def call_compute, def add_friend, def remove_friend, def are_friends, def create_circle, def join_circle, def leave_circle

hashlib time typing .economy_types .currency .social .marketplace

#!/usr/bin/env python3
"""
虫群经济系统 — 统一入口

整合算力货币、社交关系、交易市场
提供一站式经济服务
"""

import hashlib
import time
from typing import Dict, List, Optional

from .economy_types import (
    ResourceType, TransactionType, Transaction, Account,
    ComputePrice, PricingMode, CircleRole, Circle,
)
from .currency import ComputeCredit
from .social import SocialGraph
from .marketplace import Marketplace

class SwarmEconomy:
    """
    虫群经济系统

    三大子系统：
    1. ComputeCredit — 算力货币(转账/税收/分配)
    2. SocialGraph


SwarmEconomy

类 SwarmEconomy 在 core/aggregation_protocol/economy.py: 虫群经济系统

    三大子系统：
    1. ComputeCredit — 算力货币(转账/税收/分配)
    2. SocialGraph — 社交关系(好友/圈子)
    3. Marketplace — 交易市场(发布/搜索/购买算力)

    核心经济循环：
    用户贡献算力 → 获得CC → 消费CC调用他人算力
    虫皇收税5% → 分配给高贡献成 | 方法: __init__, register_node, call_compute, add_friend, remove_friend, are_friends, create_circle, join_circle, leave_circle, sell_compute, buy_compute, search_compute, collect_tax_info, distribute_tax, set_my_price, get_node_profile, get_stats

class SwarmEconomy:
    """
    虫群经济系统

    三大子系统：
    1. ComputeCredit — 算力货币(转账/税收/分配)
    2. SocialGraph — 社交关系(好友/圈子)
    3. Marketplace — 交易市场(发布/搜索/购买算力)

    核心经济循环：
    用户贡献算力 → 获得CC → 消费CC调用他人算力
    虫皇收税5% → 分配给高贡献成员(提升权限)
    """

    def __init__(self, overmind_id: str = "overmind"):
        self.overmind_id = overmind_id
        self.currency = ComputeCredit(overmind_id)
        self.social = SocialGraph()
        self.market = Marketplace(self.currency, self.social)

    # ============================================================
    # 节点注册
    # ============================================================

    def register_node(self, node_id: str, initial_balance: float = None) -> Account:
        """注册新节点，自动创建账户"""
        return self.currency.create_account(node_id, initial_balance)

    # ============================================================
    # 核心操作：调用算力
    # ============================================================

    def call_compute(self, caller_id: str, provider_id: str,
                     resource: ResourceType = ResourceType.INFERENCE,
                     units: float = 1.0,
                     force_permission: bool = False) -> Optional[Dict]:
        """
        调用他人算力 — 核心入口

        流程：
        1. 判断关系(好友/圈子/陌生人)
        2. 好友/圈子→免费或折扣
        3. 权限强制调用→不收费(虫皇税收分配)
        4. 陌生人→按市场价收费
        5. 每笔交易虫皇抽5%税
        """
        # 权限强制调用：不收费
        if force_permission:
            tx = Transaction(
                tx_id=hashlib.md5(f"perm_{caller_id}{provider_id}{time.time()}".encode()).hexdigest()[:12],
                from_node=caller_id, to_node=provider_id,
                amount=0.0, tx_type=TransactionType.PERMISSION_CALL,
                resource_type=resource, units=units,
                description="权限强制调用(不收费)",
            )
            self.currency.transactions.append(tx)
            provider_acc = self.currency.get_account(provider_id)
            if provider_acc:
                provi


方法 SwarmEconomy.remove_friend():
        """解除好友"""
        self.social.remove_friend(node_a, node_b)

def remove_friend(self):
        """解除好友"""
        self.social.remove_friend(node_a, node_b)


方法 SwarmEconomy.set_my_price():
        """自定义算力价格"""
        self.currency.set_price(
            node_id, resource, price,


social.py

文件 core/aggregation_protocol/social.py: 虫群经济系统 — 社交关系(好友+圈子)

核心逻辑：
- 加好友：互相免费调用（提前确认）
- 建圈子：圈内成员免费/折扣调用
- 任务执行快，不能等确认→提前授权
- 好友/圈子决定调用时的计费方式 | 定义: class SocialGraph, def __init__, def add_friend, def remove_friend, def are_friends, def get_friends, def get_mutual_friends, def create_circle, def join_circle, def leave_circle

hashlib time datetime typing .economy_types

#!/usr/bin/env python3
"""
虫群经济系统 — 社交关系(好友+圈子)

核心逻辑：
- 加好友：互相免费调用（提前确认）
- 建圈子：圈内成员免费/折扣调用
- 任务执行快，不能等确认→提前授权
- 好友/圈子决定调用时的计费方式
"""

import hashlib
import time
from datetime import datetime
from typing import Dict, List, Optional, Set

from .economy_types import Friendship, Circle, CircleRole

class SocialGraph:
    """社交关系图"""

    def __init__(self):
        self.friends: Dict[str, Set[str]] = {}     # node_id -> 好友集合
        self.circles: Dict[str, Circle] = {}        # circle_id -> Cir


SocialGraph

类 SocialGraph 在 core/aggregation_protocol/social.py: 社交关系图 | 方法: __init__, add_friend, remove_friend, are_friends, get_friends, get_mutual_friends, create_circle, join_circle, leave_circle, dissolve_circle, is_in_same_circle, get_shared_circles, get_node_circles, get_call_relation, get_stats

class SocialGraph:
    """社交关系图"""

    def __init__(self):
        self.friends: Dict[str, Set[str]] = {}     # node_id -> 好友集合
        self.circles: Dict[str, Circle] = {}        # circle_id -> Circle
        self.node_circles: Dict[str, Set[str]] = {} # node_id -> 圈子ID集合

    # ============================================================
    # 好友系统
    # ============================================================

    def add_friend(self, node_a: str, node_b: str) -> bool:
        """添加好友（双向）"""
        if node_a == node_b:
            return False
        self.friends.setdefault(node_a, set()).add(node_b)
        self.friends.setdefault(node_b, set()).add(node_a)
        return True

    def remove_friend(self, node_a: str, node_b: str):
        """解除好友"""
        if node_a in self.friends:
            self.friends[node_a].discard(node_b)
        if node_b in self.friends:
            self.friends[node_b].discard(node_a)

    def are_friends(self, node_a: str, node_b: str) -> bool:
        """是否好友"""
        return node_b in self.friends.get(node_a, set())

    def get_friends(self, node_id: str) -> List[str]:
        """获取好友列表"""
        return list(self.friends.get(node_id, set()))

    def get_mutual_friends(self, node_a: str, node_b: str) -> List[str]:
        """获取共同好友"""
        fa = self.friends.get(node_a, set())
        fb = self.friends.get(node_b, set())
        return list(fa & fb)

    # ============================================================
    # 圈子系统
    # ============================================================

    def create_circle(self, name: str, owner: str,
                      free_call: bool = True) -> Circle:
        """创建圈子"""
        circle_id = f"circle_{hashlib.md5(f'{name}{owner}{time.time()}'.encode()).hexdigest()[:8]}"
        circle = Circle(
            circle_id=circle_id,
            name=name,
            owner=owner,
            free_call=free_call,
        )
        circle.add_member(owner, Cir


方法 SocialGraph.remove_friend():
        """解除好友"""
        if node_a in self.friends:
            self.friends[node_a].discard(node

def remove_friend(self):
        """解除好友"""
        if node_a in self.friends:
            self.friends[node_a].discard(node_b)
        if node_b in self.friends:
            self.friends[node_b].discard(node_a)


文件 core/neuro/__init__.py: 虫群v10 — 类脑神经模型体系

架构: 神经元(3类) → 微柱(5类) → 功能柱 → 脑区 → 大脑

神经元3类: 兴奋性/抑制性/调节性
微柱5类: 感觉/记忆/联合/运动/调节
6大脑区: 感觉区/海马区/联合区/前额区/运动区/丘脑

三级记忆: 微缓存/短期/长期 + 静态知识库
密码本: 代号式存储 + 整理优化 + 同步协议 | 定义:

#!/usr/bin/env python3
"""
虫群v10 — 类脑神经模型体系

架构: 神经元(3类) → 微柱(5类) → 功能柱 → 脑区 → 大脑

神经元3类: 兴奋性/抑制性/调节性
微柱5类: 感觉/记忆/联合/运动/调节
6大脑区: 感觉区/海马区/联合区/前额区/运动区/丘脑

三级记忆: 微缓存/短期/长期 + 静态知识库
密码本: 代号式存储 + 整理优化 + 同步协议
"""

from .neuron import Neuron, NeuronType, TYPE_DEFAULTS
from .micro_column import MicroColumn, COLUMN_CONFIGS
from .functional_column import FunctionalColumn
from .brain import BrainRegion, Brain
from .text_encoder import SimpleTokenizer, EmbeddingLayer, TextDecoder
from .dialogue_memory import


distributed.py

文件 core/neuro/distributed.py: 虫群分布式6脑区服务架构

设计目标:
- 6脑区独立进程，通过ZeroMQ通信
- 支持本地(进程内) / 分布式(跨机器) 两种模式
- 保持与BrainV13相同的循环推理逻辑
- 横向扩展：同类脑区可加节点

架构:
┌─────────────────────────────────────────────────┐
│                 BrainOrchestrator | 定义: class
class, def to_json, def from_json, class RegionServer, def __init__, def create_region, def handle, def run, class SensoryServer, def __init__

json time zmq numpy typing dataclasses abc

#!/usr/bin/env python3
"""
虫群分布式6脑区服务架构

设计目标:
- 6脑区独立进程，通过ZeroMQ通信
- 支持本地(进程内) / 分布式(跨机器) 两种模式
- 保持与BrainV13相同的循环推理逻辑
- 横向扩展：同类脑区可加节点

架构:
┌─────────────────────────────────────────────────┐
│                 BrainOrchestrator               │
│          (编排器，统一调度6脑区)                  │
└──────────┬──────────┬──────────┬───────────────┘
           │          │          │
    ┌──────▼──┐ ┌─────▼────┐ ┌──▼────────┐
    │Sensory │ │Hippocampus│ │Association│
    │Server  │ │ Server    │ │  Server


BrainMessage

类 BrainMessage 在 core/neuro/distributed.py: 脑区间通信消息 | 方法: to_json, from_json

class BrainMessage:
    """脑区间通信消息"""
    action: str  # forward, reset, status
    round: int = 0
    input_data: Optional[np.ndarray] = None
    metadata: Dict[str, Any] = field(default_factory=dict)

    def to_json(self) -> str:
        d = {"action": self.action, "round": self.round, "metadata": self.metadata}
        if self.input_data is not None:
            d["input"] = self.input_data.tolist()
        return json.dumps(d)

    @classmethod
    def from_json(cls, s: str) -> 'BrainMessage':
        d = json.loads(s)
        arr = np.array(d.get("input", [])) if "input" in d else None
        return cls(action=d["action"], round=d.get("round", 0),
                   input_data=arr, metadata=d.get("metadata", {}))

# ============================================================
# 基础服务端类
# ============================================================


RegionServer

类 RegionServer 在 core/neuro/distributed.py: 脑区服务基类 | 方法: __init__, create_region, handle, run

class RegionServer:
    """脑区服务基类"""

    def __init__(self, name: str, port: int):
        self.name = name
        self.port = port
        self.context = None
        self.socket = None
        self._region = None  # 实际脑区实例

    @abstractmethod
    def create_region(self):
        """创建脑区实例"""
        pass

    def handle(self, msg: BrainMessage) -> Dict[str, Any]:
        """处理请求"""
        if msg.action == "forward":
            output = self._region.forward(msg.input_data)
            return {"output": output.tolist(), "metadata": {}}
        elif msg.action == "reset":
            self._region.reset()
            return {"status": "ok"}
        elif msg.action == "status":
            return {"status": "running", "region": self.name}
        else:
            return {"error": f"unknown action: {msg.action}"}

    def run(self):
        """启动服务"""
        self.context = zmq.Context()
        self.socket = self.context.socket(zmq.REP)
        self.socket.bind(f"tcp://*:{self.port}")
        self._region = self.create_region()

        print(f"[{self.name}] Started on port {self.port}")

        while True:
            try:
                msg_bytes = self.socket.recv()
                msg = BrainMessage.from_json(msg_bytes.decode())
                result = self.handle(msg)
                self.socket.send(json.dumps(result).encode())
            except KeyboardInterrupt:
                break
            except Exception as e:
                self.socket.send(json.dumps({"error": str(e)}).encode())

        self.socket.close()
        self.context.term()

# ============================================================
# 6脑区服务实现
# ============================================================


方法 RegionServer.create_region():
        """创建脑区实例"""
        pass

def create_region(self):
        """创建脑区实例"""
        pass


run

方法 RegionServer.run():
        """启动服务"""
        self.context = zmq.Context()
        self.socket = self.context.socket(z

def run(self):
        """启动服务"""
        self.context = zmq.Context()
        self.socket = self.context.socket(zmq.REP)
        self.socket.bind(f"tcp://*:{self.port}")
        self._region = self.create_region()

        print(f"[{self.name}] Started on port {self.port}")

        while True:
            try:
                msg_bytes = self.socket.recv()
                msg = BrainMessage.from_json(msg_bytes.decode())
                result = self.handle(msg)
                self.socket.send(json.dumps(result).encode())
            except KeyboardInterrupt:
                break
            except Exception as e:
                self.socket.send(json.dumps({"error": str(e)}).encode())

        self.socket.close()
        self.context.term()

# ============================================================
# 6脑区服务实现
# ============================================================


SensoryServer

类 SensoryServer 在 core/neuro/distributed.py: 感觉区服务 | 方法: __init__, create_region

class SensoryServer:
    """感觉区服务"""
    def __init__(self, port: int = 5501):
        super().__init__("Sensory", port)

    def create_region(self):
        from .regions.sensory_region import SensoryRegion
        return SensoryRegion(input_dim=32)


方法 SensoryServer.create_region():
        from .regions.sensory_region import SensoryRegion
        return SensoryRegion(input_dim=32

def create_region(self):
        from .regions.sensory_region import SensoryRegion
        return SensoryRegion(input_dim=32)


HippocampusServer

类 HippocampusServer 在 core/neuro/distributed.py: 海马体服务 | 方法: __init__, create_region, handle

class HippocampusServer:
    """海马体服务"""
    def __init__(self, port: int = 5502):
        super().__init__("Hippocampus", port)

    def create_region(self):
        from .regions.hippocampus_region import HippocampusRegion
        return HippocampusRegion()

    def handle(self, msg: BrainMessage) -> Dict[str, Any]:
        if msg.action == "forward":
            query = msg.metadata.get("query")
            output, confidence = self._region.forward(msg.input_data, query=query)
            return {"output": output.tolist(), "confidence": float(confidence)}
        return super().handle(msg)


方法 HippocampusServer.create_region():
        from .regions.hippocampus_region import HippocampusRegion
        return HippocampusRegion(

def create_region(self):
        from .regions.hippocampus_region import HippocampusRegion
        return HippocampusRegion()


AssociationServer

类 AssociationServer 在 core/neuro/distributed.py: 联合区服务 | 方法: __init__, create_region

class AssociationServer:
    """联合区服务"""
    def __init__(self, port: int = 5503):
        super().__init__("Association", port)

    def create_region(self):
        from .regions.association_region import AssociationRegion
        return AssociationRegion()


方法 AssociationServer.create_region():
        from .regions.association_region import AssociationRegion
        return AssociationRegion(

def create_region(self):
        from .regions.association_region import AssociationRegion
        return AssociationRegion()


PrefrontalServer

类 PrefrontalServer 在 core/neuro/distributed.py: 前额区服务 | 方法: __init__, create_region

class PrefrontalServer:
    """前额区服务"""
    def __init__(self, port: int = 5504):
        super().__init__("Prefrontal", port)

    def create_region(self):
        from .regions.prefrontal_region import PrefrontalRegion
        return PrefrontalRegion()


方法 PrefrontalServer.create_region():
        from .regions.prefrontal_region import PrefrontalRegion
        return PrefrontalRegion()

def create_region(self):
        from .regions.prefrontal_region import PrefrontalRegion
        return PrefrontalRegion()


MotorServer

类 MotorServer 在 core/neuro/distributed.py: 运动区服务 | 方法: __init__, create_region

class MotorServer:
    """运动区服务"""
    def __init__(self, port: int = 5505):
        super().__init__("Motor", port)

    def create_region(self):
        from .regions.motor_region import MotorRegion
        return MotorRegion(input_dim=32, output_dim=32)


方法 MotorServer.create_region():
        from .regions.motor_region import MotorRegion
        return MotorRegion(input_dim=32, outp

def create_region(self):
        from .regions.motor_region import MotorRegion
        return MotorRegion(input_dim=32, output_dim=32)


ThalamusServer

类 ThalamusServer 在 core/neuro/distributed.py: 丘脑服务 | 方法: __init__, create_region

class ThalamusServer:
    """丘脑服务"""
    def __init__(self, port: int = 5506):
        super().__init__("Thalamus", port)

    def create_region(self):
        from .regions.thalamus_region import ThalamusRegion
        return ThalamusRegion(min_depth=2, max_depth=10, stall_patience=5)

# ============================================================
# 编排器 (BrainOrchestrator)
# ============================================================


方法 ThalamusServer.create_region():
        from .regions.thalamus_region import ThalamusRegion
        return ThalamusRegion(min_depth


BrainOrchestrator

类 BrainOrchestrator 在 core/neuro/distributed.py: 分布式脑区编排器

    用法:
        orchestrator = BrainOrchestrator(mode="local")  # 本地模式
        # or
        orchestrator = BrainOrchestrator(mode="distributed", hosts={...})

        output = or | 方法: __init__, _connect_all, think, _send, close

class BrainOrchestrator:
    """
    分布式脑区编排器

    用法:
        orchestrator = BrainOrchestrator(mode="local")  # 本地模式
        # or
        orchestrator = BrainOrchestrator(mode="distributed", hosts={...})

        output = orchestrator.think(input_vector)
    """

    PORTS = {
        "sensory": 5501,
        "hippocampus": 5502,
        "association": 5503,
        "prefrontal": 5504,
        "motor": 5505,
        "thalamus": 5506,
    }

    def __init__(self, mode: str = "local", hosts: Dict[str, str] = None):
        """
        Args:
            mode: "local" (进程内) 或 "distributed" (跨机器)
            hosts: 分布式模式下各服务的主机地址 {"sensory": "192.168.1.1", ...}
        """
        self.mode = mode
        self.hosts = hosts or {}

        if mode == "local":
            # 本地模式：直接调用脑区
            from .brain_v13 import BrainV13
            self._brain = BrainV13()
            self._local = True
        else:
            # 分布式模式：ZeroMQ连接
            self._context = zmq.Context()
            self._sockets = {}
            self._local = False
            self._connect_all()

    def _connect_all(self):
        """连接所有脑区服务"""
        for name, default_port in self.PORTS.items():
            host = self.hosts.get(name, "localhost")
            port = default_port
            addr = f"tcp://{host}:{port}"
            sock = self._context.socket(zmq.REQ)
            sock.setsockopt(zmq.RCVTIMEO, 3000)  # 3秒超时
            sock.setsockopt(zmq.SNDTIMEO, 3000)
            sock.connect(addr)
            self._sockets[name] = sock
            print(f"[Orchestrator] Connected to {name} at {addr}")

    def think(self, x: np.ndarray) -> np.ndarray:
        """
        分布式循环推理

        信号流:
        1. 感觉区: 信号→特征
        2. 丘脑: 预算深度
        3. 海马区: 首轮检索
        4. 循环: 联合区 → 前额区 → (再检索) → ...
        5. 运动区: 输出
        """
        if self._local:
            return self._brain.think(x)

        # 分布式模式
        x = np.asarray(x, dtype=np.float32).ravel()


close

方法 BrainOrchestrator.close():
        """关闭连接"""
        if not self._local:
            for sock in self._sockets.values():

def close(self):
        """关闭连接"""
        if not self._local:
            for sock in self._sockets.values():
                sock.close()
            self._context.term()

# ============================================================
# 启动脚本
# ============================================================

if __name__ == "__main__":
    import sys

    if len(sys.argv) < 2:
        print("用法:")
        print("  python -m core.neuro.distributed sensory   # 启动感觉区")
        print("  python -m core.neuro.distributed hippocampus # 启动海马体")
        print("  python -m core.neuro.distributed all         # 启动全部(本地模式)")
        sys.exit(1)

    region = sys.argv[1]

    servers = {
        "sensory": SensoryServer,
        "hippocampus": HippocampusServer,
        "association": AssociationServer,
        "prefrontal": PrefrontalServer,
        "motor": MotorServer,
        "thalamus": ThalamusServer,
    }

    if region == "all":
        print("[分布式] 本地模式启动 (进程内)")
        from .brain_v13 imp


文件 core/neuro/functional_column.py: 虫群v10 — 功能柱模型
同类微柱聚合 + 3层通信协议

通信协议:
1. 输入分配: 均匀切分 / 重叠分配 / 全量+偏移
2. 柱间通信: 侧向抑制 + 同步信号
3. 输出聚合: 赢者通吃 / 加权平均 / 代号序列

三级记忆:
- 微缓存: 神经元运行时输入
- 短期记忆: 按需扩容，不用释放
- 长期记忆: 慎重删除，蒸馏萃取 | 定义: def split_input, def aggregate_winner_take_all, def aggregate_weighted_average, def aggregate_code_sequence, class FunctionalColumn, def __init__, def forward, def _aggregate, def reset, def short_term_store

#!/usr/bin/env python3
"""
虫群v10 — 功能柱模型
同类微柱聚合 + 3层通信协议

通信协议:
1. 输入分配: 均匀切分 / 重叠分配 / 全量+偏移
2. 柱间通信: 侧向抑制 + 同步信号
3. 输出聚合: 赢者通吃 / 加权平均 / 代号序列

三级记忆:
- 微缓存: 神经元运行时输入
- 短期记忆: 按需扩容，不用释放
- 长期记忆: 慎重删除，蒸馏萃取
"""

import numpy as np
from typing import Dict, List, Optional, Tuple
from .micro_column import MicroColumn, COLUMN_CONFIGS

# ============================================================
# 输入分配策略
# ============================================================

def split_input(X: np.ndarray, n_col


FunctionalColumn

类 FunctionalColumn 在 core/neuro/functional_column.py: 功能柱 — 同类微柱聚合

    同类型的微柱聚合成功能柱，通过3层通信协议协作:
    - 输入分配: 每个微柱接收输入的一部分
    - 柱间通信: 侧向抑制 + 同步信号
    - 输出聚合: 根据功能选择聚合策略

    三级记忆管理:
    - 短期记忆: 按需扩容/释放
    - 长期记忆: 慎重删除，蒸馏萃取
    - 静态知识库: 遗忘前备份 | 方法: __init__, forward, _aggregate, reset, short_term_store, _extract_patterns, _auto_learn, _auto_proliferate, short_term_retrieve, short_term_release, _short_term_evict, _promote_to_long_term, long_term_store, long_term_retrieve, long_term_distill, long_term_forget, _static_backup, static_kb_search, static_kb_size, sync_codebooks, total_params, total_memory_KB, total_disk_KB, total_codebook_entries, info

class FunctionalColumn:
    """
    功能柱 — 同类微柱聚合

    同类型的微柱聚合成功能柱，通过3层通信协议协作:
    - 输入分配: 每个微柱接收输入的一部分
    - 柱间通信: 侧向抑制 + 同步信号
    - 输出聚合: 根据功能选择聚合策略

    三级记忆管理:
    - 短期记忆: 按需扩容/释放
    - 长期记忆: 慎重删除，蒸馏萃取
    - 静态知识库: 遗忘前备份
    """

    # 聚合策略映射
    AGGREGATION_STRATEGIES = {
        "sensory": "winner",      # 感觉柱: 赢者通吃，聚焦关键特征
        "memory": "code_seq",     # 记忆柱: 代号序列，多记忆并行
        "associate": "weighted",  # 联合柱: 加权平均，多概念融合
        "motor": "winner",        # 运动柱: 赢者通吃，唯一输出
        "modulatory": "weighted", # 调节柱: 加权平均，综合状态
    }

    def __init__(self, column_type: str = "memory",
                 n_micro_columns: int = 10,
                 input_dim: int = 14,
                 output_dim: int = 10,
                 n_neurons_per_column: int = 100,
                 max_columns: int = 100,
                 input_overlap: float = 0.2):
        """
        Args:
            column_type: 微柱类型 (sensory/memory/associate/motor/modulatory)
            n_micro_columns: 初始微柱数量
            input_dim: 输入维度
            output_dim: 输出维度
            n_neurons_per_column: 每个微柱的神经元数
            max_columns: 最大微柱数 (增殖上限)
            input_overlap: 输入重叠率
        """
        self.column_type = column_type
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.n_neurons = n_neurons_per_column
        self.max_columns = max_columns
        self.input_overlap = input_overlap

        # 创建微柱集群
        self.columns: List[MicroColumn] = []
        for _ in range(n_micro_columns):
            col = MicroColumn(
                input_dim=input_dim,
                output_dim=output_dim,
                n_neurons=n_neurons_per_column,
                column_type=column_type,
            )
            self.columns.append(col)

        # 聚合策略
        self.agg_strategy = self.AGGREGATION_STRATEGIES.get(
            column_type, "weighted"
        )

        # --- 短期记忆缓冲区 ---
        self.short_term_buffer: List[Dict] = []
        self.short_te


reset

方法 FunctionalColumn.reset():
        """重置所有微柱状态"""
        for col in self.columns:
            col.reset()
        self._sync_


方法 FunctionalColumn.short_term_release():
        """释放不用的短期记忆 (关机/删除)"""
        before = len(self.short_term_buffer)
        self.short_ter

def short_term_release(self):
        """释放不用的短期记忆 (关机/删除)"""
        before = len(self.short_term_buffer)
        self.short_term_buffer = [
            m for m in self.short_term_buffer
            if m["access"] >= 2 or m["importance"] > 0.7
        ]
        return before - len(self.short_term_buffer)


方法 FunctionalColumn.long_term_store():
        """直接存入长期记忆"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.a

def long_term_store(self):
        """直接存入长期记忆"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()

        # 找记忆使用率最低的微柱
        best_col = min(self.columns, key=lambda c: c.memory_count)
        best_col.memory_store(key, value)


方法 FunctionalColumn.sync_codebooks():
        """
        密码本同步: 对齐各微柱的代号映射

        操作:
        1. 各柱提交高频代号
        2. 共同合并相似代号

def sync_codebooks(self):
        """
        密码本同步: 对齐各微柱的代号映射

        操作:
        1. 各柱提交高频代号
        2. 共同合并相似代号
        3. 一致性检查
        """
        # 收集所有密码本条目
        all_patterns = {}
        for i, col in enumerate(self.columns):
            for code, pattern in col.codebook.items():
                freq = col.codebook_freq.get(code, 1)
                key = f"col{i}_code{code}"
                all_patterns[key] = (pattern, freq, i, code)

        # 跨柱合并相似代号
        merged = set()
        new_global_codebook: Dict[int, np.ndarray] = {}
        global_freq: Dict[int, int] = {}
        new_code = 0

        items = list(all_patterns.items())
        for i, (k1, (p1, f1, col1, code1)) in enumerate(items):
            if k1 in merged:
                continue

            group = [(p1, f1, col1, code1)]
            for j, (k2, (p2, f2, col2, code2)) in enumerate(items):
                if i != j and k2 not in merged:
                    if np.linalg.norm(p1 - p2) < 0.5:


文件 core/neuro/brain_v13.py: 虫群v13 — 类脑循环架构

6脑区独立类 + 循环推理:
  sensory → hippocampus → association → prefrontal ↹(循环)
                                                  ↓(完成)
                                               motor → 输 | 定义: class BrainV13, def __init__, def think, def think_detailed, def remember, def recall, def _log_thought, def reset, def total_params, def info

#!/usr/bin/env python3
"""
虫群v13 — 类脑循环架构

6脑区独立类 + 循环推理:
  sensory → hippocampus → association → prefrontal ↹(循环)
                                                  ↓(完成)
                                               motor → 输出

丘脑全程调控: 思考深度预算 + 停滞检测 + 紧急中断

vs v12线性流水线: sensory→hippocampus→association→prefrontal→motor (条件反射)
v13循环架构: 前额区驱动多轮检索-整合-再检索，具备真正的推理能力
"""

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

from .regions.sensory_region import SensoryRegion
from .regions


类 BrainV13 在 core/neuro/brain_v13.py: 类脑循环架构大脑

    核心改进:
    1. 6个脑区各自独立结构，不再共用BrainRegion
    2. 前额区驱动循环推理，query_refinement送回海马区重新检索
    3. 丘脑控制思考深度(1-10轮)，coherence够高提前停止
    4. think()接口与旧Brain兼容: 输入32维 → 输出32维 | 方法: __init__, think, think_detailed, remember, recall, _log_thought, reset, total_params, info, expander, expand, auto_expand, record_think, get_expand_stats, search, _ensure_chat_interface, teach, chat, get_chat_stats, save, load, chat_with_llm

class BrainV13:
    """
    类脑循环架构大脑

    核心改进:
    1. 6个脑区各自独立结构，不再共用BrainRegion
    2. 前额区驱动循环推理，query_refinement送回海马区重新检索
    3. 丘脑控制思考深度(1-10轮)，coherence够高提前停止
    4. think()接口与旧Brain兼容: 输入32维 → 输出32维
    """

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

        # --- 6个脑区 (独立类) ---
        self.sensory = SensoryRegion(input_dim=input_dim)
        self.hippocampus = HippocampusRegion()
        self.association = AssociationRegion()
        self.prefrontal = PrefrontalRegion()
        self.motor = MotorRegion(input_dim=32, output_dim=32)
        self.thalamus = ThalamusRegion(min_depth=2, max_depth=10, stall_patience=5)

        # --- 思考历史 (调试用) ---
        self._thought_history: List[Dict] = []
        self._max_history = 20

        # --- 扩容器 (自扩容系统) ---
        self._expander: Optional[BrainExpander] = None

    # ============================================================
    # 核心: 循环推理
    # ============================================================

    def think(self, x: np.ndarray) -> np.ndarray:
        """
        类脑循环推理

        信号流:
        1. 感觉区: 信号→特征 (只做一次)
        2. 丘脑: 根据强度预算思考深度
        3. 首轮海马区检索
        4. 循环: 联合区整合 → 前额区推理 → 海马区再检索
        5. 运动区: 决策→输出

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

        Returns:
            输出向量(output_dim维)
        """
        x = np.asarray(x, dtype=np.float32).ravel()

        # Phase 1: 感觉区特征提取 (只做一次)
        sensory_feat, sensory_strength = self.sensory.forward(x)

        # Phase 2: 丘脑决定思考深度
        self.thalamus.reset()  # 每次新思考重置丘脑状态
        depth = self.thalamus.compute_depth_budget(sensory_strength)

        # Phase 3: 首轮海马区检索
        memory_result, mem_conf = self.hippocampus.forward(sensory_feat)

        # Phase 4: 循环推理
        decision = None
        self.prefrontal.reset()  # 每次新思考重置工作记忆

        for rou


remember

方法 BrainV13.remember():
        """存储记忆到海马区"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.a

def remember(self):
        """存储记忆到海马区"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()
        self.hippocampus.store(key, value)


reset

方法 BrainV13.reset():
        """重置全脑状态"""
        self.prefrontal.reset()
        self.thalamus.reset()
        self._th

def reset(self):
        """重置全脑状态"""
        self.prefrontal.reset()
        self.thalamus.reset()
        self._thought_history.clear()

    @property


方法 BrainV13.record_think():
        """
        记录think结果，用于自动扩容决策

        Args:
            output: think输出的向量

def record_think(self):
        """
        记录think结果，用于自动扩容决策

        Args:
            output: think输出的向量
            confidence: 置信度 (0-1)
            stall: 是否发生了stall

        Example:
            output = brain.think(embedding)
            confidence = 0.7
            stall = (np.linalg.norm(output) < 0.01)
            brain.record_think(output, confidence, stall)
        """
        self.expander.record_think(output, confidence, stall)


teach

方法 BrainV13.teach():
        """
        教会虫群一个问答对

        Args:
            question: 用户问题
            answer: 虫群回答

def teach(self):
        """
        教会虫群一个问答对

        Args:
            question: 用户问题
            answer: 虫群回答
        """
        self._ensure_chat_interface()
        self._chat_interface.teach(question, answer)


save

方法 BrainV13.save():
        """
        保存BrainV13到pickle文件

        Args:
            path: 保存路径，如 "brain_v13.pkl"

def save(self):
        """
        保存BrainV13到pickle文件

        Args:
            path: 保存路径，如 "brain_v13.pkl"
        """
        import pickle
        import os

        data = {
            "version": "v13",
            "brain_v13": self,
            # 保存各脑区
            "sensory": self.sensory,
            "hippocampus": self.hippocampus,
            "association": self.association,
            "prefrontal": self.prefrontal,
            "motor": self.motor,
            "thalamus": self.thalamus,
            # 配置
            "input_dim": self.input_dim,
            "output_dim": self.output_dim,
            # 扩容历史
            "expand_history": self.expander.get_history() if hasattr(self, '_expander') and self._expander else [],
        }

        os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
        with open(path, 'wb') as f:
            pickle.dump(data, f)
        print(f"BrainV13已保存到: {path}")

    @classmethod


文件 core/neuro/micro_column.py: 虫群v10 — 微柱元模型 (5种类型)

类型:
- sensory:  感觉柱 — 信号→特征提取
- memory:   记忆柱 — 存取记忆 (海马体)
- associate: 联合柱 — 连接不同功能区
- motor:    运动柱 — 输出控制
- modulatory: 调节柱 — 全局调控

每种类型有不同的默认参数和密码本策略 | 定义: class MicroColumn, def __init__, def forward, def reset, def set_inhibition, def set_modulation, def active_ratio, def output_strength, def memory_store, def memory_retrieve

#!/usr/bin/env python3
"""
虫群v10 — 微柱元模型 (5种类型)

类型:
- sensory:  感觉柱 — 信号→特征提取
- memory:   记忆柱 — 存取记忆 (海马体)
- associate: 联合柱 — 连接不同功能区
- motor:    运动柱 — 输出控制
- modulatory: 调节柱 — 全局调控

每种类型有不同的默认参数和密码本策略
"""

import numpy as np
from scipy import sparse
from typing import Dict, List, Optional, Tuple
import hashlib
import time

# ============================================================
# 微柱类型配置
# ============================================================

COLUMN_CONFIGS = {
    "sensory": {


MicroColumn

类 MicroColumn 在 core/neuro/micro_column.py: 微柱元模型 — 虫群可复制增殖自成长的基本单位

    同一结构, 不同权重 = 不同功能
    通过密码本机制实现超额存储效率 | 方法: __init__, forward, reset, set_inhibition, set_modulation, active_ratio, output_strength, memory_store, memory_retrieve, codebook_store, codebook_decode, codebook_encode_sequence, codebook_decode_sequence, codebook_reorganize, codebook_efficiency, replicate, distill, _vec_hash, _find_lru_slot, param_count, memory_bytes, disk_bytes, info

class MicroColumn:
    """
    微柱元模型 — 虫群可复制增殖自成长的基本单位

    同一结构, 不同权重 = 不同功能
    通过密码本机制实现超额存储效率
    """

    def __init__(self, input_dim=14, output_dim=10, n_neurons=100,
                 column_type="memory", sparsity=None, memory_slots=None):
        self.input_dim = input_dim
        self.output_dim = output_dim
        self.n_neurons = n_neurons
        self.column_type = column_type

        # 加载类型配置
        config = COLUMN_CONFIGS.get(column_type, COLUMN_CONFIGS["memory"])
        self.sparsity = sparsity or config["sparsity"]
        self.memory_slots = memory_slots or config["memory_slots"]
        self.lateral_inhibition = config["lateral_inhibition"]
        self.leak_rate = config["leak_rate"]
        self.base_threshold = config["threshold"]
        self._codebook_sim = config["codebook_similarity"]

        # --- 稀疏权重矩阵 ---
        self.W_in = sparse.random(
            n_neurons, input_dim, density=0.3,
            format='csr', dtype=np.float32
        ) * 0.5

        self.W_internal = sparse.random(
            n_neurons, n_neurons, density=self.sparsity,
            format='csr', dtype=np.float32
        ) * 0.3

        self.W_out = sparse.random(
            output_dim, n_neurons, density=0.3,
            format='csr', dtype=np.float32
        ) * 0.5

        # 偏置和阈值
        self.bias = np.random.randn(n_neurons).astype(np.float32) * 0.1
        self.threshold = np.ones(n_neurons, dtype=np.float32) * self.base_threshold

        # --- 状态 ---
        self.membrane = np.zeros(n_neurons, dtype=np.float32)
        self.activation = np.zeros(n_neurons, dtype=np.float32)

        # --- 记忆系统 ---
        self.memory_keys = np.zeros(
            (self.memory_slots, output_dim), dtype=np.float32
        )
        self.memory_values = np.zeros(
            (self.memory_slots, output_dim), dtype=np.float32
        )
        memory_freq_size = min(self.memory_slots, 200)
        self.memory_freq = np.ones(memo


reset

方法 MicroColumn.reset():
        """重置内部状态"""
        self.membrane = np.zeros(self.n_neurons, dtype=np.float32)
        sel

def reset(self):
        """重置内部状态"""
        self.membrane = np.zeros(self.n_neurons, dtype=np.float32)
        self.activation = np.zeros(self.n_neurons, dtype=np.float32)
        self._external_inhibition = 0.0
        self._modulation = 0.0


方法 MicroColumn.set_inhibition():
        """设置外部抑制信号 (功能柱通信用)"""
        self._external_inhibition = min(strength, 0.8)

def set_inhibition(self):
        """设置外部抑制信号 (功能柱通信用)"""
        self._external_inhibition = min(strength, 0.8)


方法 MicroColumn.set_modulation():
        """设置调节信号 (调节柱用)"""
        self._modulation = np.clip(signal, 0.0, 1.0)

    @property

def set_modulation(self):
        """设置调节信号 (调节柱用)"""
        self._modulation = np.clip(signal, 0.0, 1.0)

    @property


文件 core/neuro/text_encoder.py: 虫群v11 — 文本编码层

SimpleTokenizer: 字级分词 + 高频词组合
EmbeddingLayer: token_id → 语义向量
TextDecoder: 决策向量 → 文本输出 | 定义: class SimpleTokenizer, def __init__, def _add_token, def build_vocab, def _raw_tokenize, def encode, def decode, def actual_vocab_size, def save, def load

#!/usr/bin/env python3
"""
虫群v11 — 文本编码层

SimpleTokenizer: 字级分词 + 高频词组合
EmbeddingLayer: token_id → 语义向量
TextDecoder: 决策向量 → 文本输出
"""

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

class SimpleTokenizer:
    """
    轻量分词器 — 字级 + 高频词

    策略:
    - 中文字逐字分
    - 英文按空格分词
    - 数字整体保留
    - 高频词表覆盖常见组合
    """

    # 特殊token
    PAD = 0
    UNK = 1
    BOS = 2  # 句首
    EOS = 3  # 句尾

    def __init__(self, vocab_size: int = 5000):
        self.v


SimpleTokenizer

类 SimpleTokenizer 在 core/neuro/text_encoder.py: 轻量分词器 — 字级 + 高频词

    策略:
    - 中文字逐字分
    - 英文按空格分词
    - 数字整体保留
    - 高频词表覆盖常见组合 | 方法: __init__, _add_token, build_vocab, _raw_tokenize, encode, decode, actual_vocab_size, save, load

class SimpleTokenizer:
    """
    轻量分词器 — 字级 + 高频词

    策略:
    - 中文字逐字分
    - 英文按空格分词
    - 数字整体保留
    - 高频词表覆盖常见组合
    """

    # 特殊token
    PAD = 0
    UNK = 1
    BOS = 2  # 句首
    EOS = 3  # 句尾

    def __init__(self, vocab_size: int = 5000):
        self.vocab_size = vocab_size
        self.token2id: Dict[str, int] = {}
        self.id2token: Dict[int, str] = {}

        # 特殊token初始化
        special = ["<PAD>", "<UNK>", "<BOS>", "<EOS>"]
        for i, tok in enumerate(special):
            self.token2id[tok] = i
            self.id2token[i] = tok

        self._next_id = len(special)
        self._frozen = False  # 词表是否冻结

    def _add_token(self, token: str) -> int:
        """添加token到词表"""
        if token in self.token2id:
            return self.token2id[token]
        if self._next_id >= self.vocab_size:
            return self.UNK
        tid = self._next_id
        self.token2id[token] = tid
        self.id2token[tid] = token
        self._next_id += 1
        return tid

    def build_vocab(self, texts: List[str], min_freq: int = 1):
        """从语料构建词表"""
        from collections import Counter
        counter = Counter()
        for text in texts:
            tokens = self._raw_tokenize(text)
            counter.update(tokens)

        # 按频率排序，过滤低频
        for token, freq in counter.most_common():
            if freq >= min_freq and self._next_id < self.vocab_size:
                self._add_token(token)

        self._frozen = True

    def _raw_tokenize(self, text: str) -> List[str]:
        """原始分词: 中文字级 + 英文词级 + 数字整体"""
        tokens = []
        i = 0
        while i < len(text):
            ch = text[i]

            # 中文字符
            if '\u4e00' <= ch <= '\u9fff':
                tokens.append(ch)
                i += 1
            # 英文
            elif ch.isalpha():
                j = i
                while j < len(text) and text[j].isalpha():
                    j += 1
                tokens.


方法 SimpleTokenizer.build_vocab():
        """从语料构建词表"""
        from collections import Counter
        counter = Counter()
        f

def build_vocab(self):
        """从语料构建词表"""
        from collections import Counter
        counter = Counter()
        for text in texts:
            tokens = self._raw_tokenize(text)
            counter.update(tokens)

        # 按频率排序，过滤低频
        for token, freq in counter.most_common():
            if freq >= min_freq and self._next_id < self.vocab_size:
                self._add_token(token)

        self._frozen = True


save

方法 SimpleTokenizer.save():
        """保存词表"""
        data = {
            "vocab_size": self.vocab_size,
            "token2i

def save(self):
        """保存词表"""
        data = {
            "vocab_size": self.vocab_size,
            "token2id": self.token2id,
        }
        with open(path, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)

    @classmethod


EmbeddingLayer

类 EmbeddingLayer 在 core/neuro/text_encoder.py: token → 语义向量

    5000 × 32 = 16万参数
    多token输入 → 平均池化 → 32维向量 | 方法: __init__, _get_sqlite_conn, lookup_word, add_word_from_sqlite, forward, embed_single, param_count

class EmbeddingLayer:
    """
    token → 语义向量

    5000 × 32 = 16万参数
    多token输入 → 平均池化 → 32维向量
    """

    def __init__(self, vocab_size: int = 5000, embed_dim: int = 32,
                 sqlite_db: str = None, pca_matrix: np.ndarray = None, pca_mean: np.ndarray = None):
        self.vocab_size = vocab_size
        self.embed_dim = embed_dim
        # Xavier初始化
        scale = np.sqrt(2.0 / (vocab_size + embed_dim))
        self.weight = np.random.randn(vocab_size, embed_dim).astype(np.float32) * scale
        self._param_count = vocab_size * embed_dim

        # SQLite动态查词支持
        self._sqlite_db = sqlite_db
        self._pca_matrix = pca_matrix  # (32, 300) PCA转换矩阵
        self._pca_mean = pca_mean  # (300,) PCA均值
        self._conn = None
        self._cache = {}  # 词→向量缓存，避免重复查询

    def _get_sqlite_conn(self):
        """惰性连接SQLite"""
        if self._conn is None and self._sqlite_db:
            import sqlite3
            if os.path.exists(self._sqlite_db):
                self._conn = sqlite3.connect(self._sqlite_db)
        return self._conn

    def lookup_word(self, word: str) -> Optional[np.ndarray]:
        """从SQLite词库查找词向量，返回32维向量或None"""
        # 缓存优先
        if word in self._cache:
            return self._cache[word]

        conn = self._get_sqlite_conn()
        if conn is None:
            return None

        cursor = conn.cursor()
        cursor.execute('SELECT vector FROM word_vectors WHERE word = ?', (word,))
        row = cursor.fetchone()
        if row is None:
            return None

        vec_300 = np.frombuffer(row[0], dtype=np.float32).astype(np.float64)
        # PCA降维 300→32: (x - mean) @ components.T
        if self._pca_matrix is not None and self._pca_mean is not None:
            vec_centered = vec_300 - self._pca_mean
            vec_32 = vec_centered @ self._pca_matrix.T
            vec_32 = vec_32 / (np.linalg.norm(vec_32) + 1e-8)
        else:
            vec_32 = vec_300[:self.embed_d


TextDecoder

类 TextDecoder 在 core/neuro/text_encoder.py: 决策向量 → 文本输出

    两种模式:
    1. 虫群模式: 向量 → Embedding最近邻 → token → 文本
    2. LLM模式: 直接输出LLM生成的文本 | 方法: __init__, decode_vector, decode_vectors_sequence

class TextDecoder:
    """
    决策向量 → 文本输出

    两种模式:
    1. 虫群模式: 向量 → Embedding最近邻 → token → 文本
    2. LLM模式: 直接输出LLM生成的文本
    """

    def __init__(self, embedding: EmbeddingLayer, tokenizer: SimpleTokenizer):
        self.embedding = embedding
        self.tokenizer = tokenizer

    def decode_vector(self, vec: np.ndarray, top_k: int = 1) -> str:
        """
        向量 → 最近邻token → 文本

        原理: 在embedding空间找最近的token
        """
        vec = np.asarray(vec, dtype=np.float32).ravel()

        # 对齐维度
        if len(vec) < self.embedding.embed_dim:
            vec = np.pad(vec, (0, self.embedding.embed_dim - len(vec)))
        elif len(vec) > self.embedding.embed_dim:
            vec = vec[:self.embedding.embed_dim]

        # 余弦相似度
        norms = np.linalg.norm(self.embedding.weight, axis=1)
        query_norm = np.linalg.norm(vec)

        if query_norm < 1e-8:
            return ""

        similarities = self.embedding.weight @ vec / (norms * query_norm + 1e-8)

        # 构建有意义token的索引（排除<UNK>和特殊token）
        if not hasattr(self, '_valid_token_ids'):
            valid = []
            for tid in range(4, self.embedding.weight.shape[0]):
                token = self.tokenizer.id2token.get(tid, '<UNK>')
                if token and token != '<UNK>':
                    valid.append(tid)
            self._valid_token_ids = np.array(valid, dtype=np.int64) if valid else np.arange(4, min(100, self.embedding.weight.shape[0]))

        # 只在有意义的token中搜索
        valid_weights = self.embedding.weight[self._valid_token_ids]
        valid_norms = np.linalg.norm(valid_weights, axis=1)
        similarities = valid_weights @ vec / (valid_norms * query_norm + 1e-8)

        # 取top_k
        top_indices = np.argsort(similarities)[-top_k:][::-1]
        valid_ids = [int(self._valid_token_ids[i]) for i in top_indices]
        if not valid_ids:
            return ""

        return self.tokenizer.decode(valid_id


文件 core/neuro/prefrontal_hybrid.py: 虫群v11 — 前额区混合推理引擎

双模式推理:
- 虫群模式: 密码本匹配 + 记忆检索, <10ms
- LLM模式: 外部API调用(NIM), 1-3s

自动切换: 基于复杂度评估
  complexity < 0.6 → 虫群(快)
  complexity >= 0.6 → LLM(深)

LLM结果回存海马区 → 下次虫群直接命中 → 学习过程 | 定义: class ComplexityEstimator, def __init__, def estimate, def estimate_from_text, def avg_complexity, class SwarmReasoner, def __init__, def reason, class LLMReasoner, def __init__

numpy typing time os sys .text_encoder .dialogue_memory

#!/usr/bin/env python3
"""
虫群v11 — 前额区混合推理引擎

双模式推理:
- 虫群模式: 密码本匹配 + 记忆检索, <10ms
- LLM模式: 外部API调用(NIM), 1-3s

自动切换: 基于复杂度评估
  complexity < 0.6 → 虫群(快)
  complexity >= 0.6 → LLM(深)

LLM结果回存海马区 → 下次虫群直接命中 → 学习过程
"""

import numpy as np
from typing import Dict, List, Optional, Tuple
import time
import os
import sys

# 虫群内部模块
from .text_encoder import SimpleTokenizer, EmbeddingLayer, TextDecoder
from .dialogue_memory import DialogueMemory, DialogueTurn

class ComplexityEstimator:
    """
    复杂度评估器


ComplexityEstimator

类 ComplexityEstimator 在 core/neuro/prefrontal_hybrid.py: 复杂度评估器

    三维度评估:
    1. 记忆匹配度(0-1): 越高越简单
    2. 输入长度(0-1): 越长越复杂
    3. 微柱激活分散度(0-1): 越散越复杂 | 方法: __init__, estimate, estimate_from_text, avg_complexity

class ComplexityEstimator:
    """
    复杂度评估器

    三维度评估:
    1. 记忆匹配度(0-1): 越高越简单
    2. 输入长度(0-1): 越长越复杂
    3. 微柱激活分散度(0-1): 越散越复杂
    """

    def __init__(self):
        # 权重
        self.w_memory = 0.4    # 记忆匹配最重要
        self.w_length = 0.3    # 长度次之
        self.w_sparsity = 0.3  # 分散度

        # 历史统计(用于自适应)
        self._history = []
        self._max_history = 100

    def estimate(self, memory_score: float, input_length: int,
                 activation_sparsity: float = 0.5) -> float:
        """
        评估复杂度 0~1

        Args:
            memory_score: 记忆匹配度 0~1 (1=精确命中)
            input_length: 输入token数
            activation_sparsity: 微柱激活分散度 0~1
        """
        # 归一化
        mem_norm = 1.0 - np.clip(memory_score, 0, 1)  # 反转: 越匹配越简单
        len_norm = np.clip(input_length / 50.0, 0, 1)  # 50 token为上限
        spa_norm = np.clip(activation_sparsity, 0, 1)

        # 加权
        complexity = (
            self.w_memory * mem_norm +
            self.w_length * len_norm +
            self.w_sparsity * spa_norm
        )

        # 记录历史
        self._history.append(complexity)
        if len(self._history) > self._max_history:
            self._history.pop(0)

        return float(np.clip(complexity, 0, 1))

    def estimate_from_text(self, text: str, memory_score: float = 0.0) -> float:
        """从文本直接评估(简化版)"""
        length = len(text)
        # 中文约1字=1token, 英文约1词=1token
        token_est = length  # 粗估
        sparsity = 0.3 if length < 10 else 0.6  # 短句集中，长句分散

        # 关键词维度: 检测代码/数学/复杂推理关键词
        complex_keywords = [
            '写', '排序', '算法', '函数', '实现', '编程', '代码',
            '解释', '分析', '比较', '设计', '优化', '如何',
            '计算', '乘', '除', '开方', '平方', '立方',
            '为什么', '原理', '机制', '流程',
        ]
        keyword_boost = sum(0.08 for kw in complex_keywords if kw in text)
        keyword_boost = min(keyword_boost, 0.4)  # 上限0.4

        base = self.estimate(memory_score, token_est, s


SwarmReasoner

虫群推理器 — 密码本 + 记忆检索

    纯本地，<10ms

类 SwarmReasoner 在 core/neuro/prefrontal_hybrid.py: 虫群推理器 — 密码本 + 记忆检索

    纯本地，<10ms | 方法: __init__, reason

class SwarmReasoner:
    """
    虫群推理器 — 密码本 + 记忆检索

    纯本地，<10ms
    """

    def __init__(self, tokenizer: SimpleTokenizer, embedding: EmbeddingLayer,
                 dialogue_memory: DialogueMemory):
        self.tokenizer = tokenizer
        self.embedding = embedding
        self.dialogue_memory = dialogue_memory
        self.decoder = TextDecoder(embedding, tokenizer)

    def reason(self, query_vec: np.ndarray, query_text: str = "") -> Dict:
        """
        虫群推理

        Returns:
            {"text": str, "score": float, "source": str, "ms": int}
        """
        t0 = time.time()

        # 1. 对话记忆检索(需要向量)
        mem_results = self.dialogue_memory.retrieve(query_vec, top_k=3)

        best_text = ""
        best_score = 0.0
        best_source = "none"

        if mem_results:
            q_text, a_text, best_sim = mem_results[0]
            if best_sim > 0.5:
                best_text = a_text
                best_score = best_sim
                best_source = "dialogue_memory"

        # 2. 密码本检索(如果对话记忆不够)
        if best_score < 0.3:
            # 用embedding最近邻
            decoded = self.decoder.decode_vector(query_vec, top_k=3)
            if decoded:
                best_text = decoded
                best_score = 0.2  # 密码本匹配置信度低
                best_source = "codebook"

        ms = int((time.time() - t0) * 1000)

        return {
            "text": best_text,
            "score": best_score,
            "source": best_source,
            "ms": ms,
        }


LLMReasoner

LLM推理器 — 外部API调用

    支持: NIM API (可扩展其他)

类 LLMReasoner 在 core/neuro/prefrontal_hybrid.py: LLM推理器 — 外部API调用

    支持: NIM API (可扩展其他) | 方法: __init__, _init_nim, available, reason

class LLMReasoner:
    """
    LLM推理器 — 外部API调用

    支持: NIM API (可扩展其他)
    """

    def __init__(self, api_key: str = None, provider: str = "nim",
                 model: str = "chat"):
        self.provider = provider
        self.model = model
        self._nim = None
        self._available = False

        # 尝试初始化NIM
        if api_key:
            self._init_nim(api_key)
        else:
            # 从环境变量读取
            env_key = os.environ.get("NIM_API_KEY", "")
            if env_key:
                self._init_nim(env_key)

    def _init_nim(self, api_key: str):
        """初始化NIM推理器"""
        try:
            sys.path.insert(0, "/home/admin/swarm")
            from core.nim_inference import NIMInference
            self._nim = NIMInference(api_key)
            self._available = True
        except Exception as e:
            print(f"[LLMReasoner] NIM初始化失败: {e}")
            self._available = False

    @property
    def available(self) -> bool:
        return self._available and self._nim is not None

    def reason(self, query_text: str, context_text: str = "",
               system_prompt: str = None) -> Dict:
        """
        LLM推理

        Args:
            query_text: 用户问题
            context_text: 上下文(海马记忆)
            system_prompt: 系统提示

        Returns:
            {"text": str, "model": str, "ms": int, "error": str|None}
        """
        if not self.available:
            return {
                "text": "",
                "model": "none",
                "ms": 0,
                "error": "LLM不可用",
            }

        t0 = time.time()

        # 构建消息
        messages = []

        # 系统提示
        if not system_prompt:
            system_prompt = (
                "你是虫群智能体的推理核心。"
                "基于提供的记忆和上下文，简洁准确地回答问题。"
            )
        messages.append({"role": "system", "content": system_prompt})

        # 上下文(记忆)
        if context_text:
            messages.append({


PrefrontalHybrid

类 PrefrontalHybrid 在 core/neuro/prefrontal_hybrid.py: 前额区混合推理引擎

    双模式:
    - 虫群模式: 快速，<10ms，密码本+记忆
    - LLM模式: 深度，1-3s，外部API

    自动切换 + LLM结果回存 | 方法: __init__, forward, _learn_from_llm, get_stats, set_llm, llm_available

class PrefrontalHybrid:
    """
    前额区混合推理引擎

    双模式:
    - 虫群模式: 快速，<10ms，密码本+记忆
    - LLM模式: 深度，1-3s，外部API

    自动切换 + LLM结果回存
    """

    def __init__(self, tokenizer: SimpleTokenizer, embedding: EmbeddingLayer,
                 dialogue_memory: DialogueMemory,
                 llm_api_key: str = None,
                 complexity_threshold: float = 0.2):
        self.tokenizer = tokenizer
        self.embedding = embedding
        self.dialogue_memory = dialogue_memory

        # 子组件
        self.complexity_estimator = ComplexityEstimator()
        self.swarm_reasoner = SwarmReasoner(tokenizer, embedding, dialogue_memory)
        self.llm_reasoner = LLMReasoner(api_key=llm_api_key)

        # 阈值
        self.complexity_threshold = complexity_threshold

        # 统计
        self.stats = {
            "total_queries": 0,
            "swarm_queries": 0,
            "llm_queries": 0,
            "llm_errors": 0,
            "avg_complexity": 0.0,
            "saved_by_cache": 0,
        }

        # 最近推理历史
        self._last_reasoning = None

    def forward(self, query_text: str, query_vec: np.ndarray = None,
                context_text: str = "") -> Dict:
        """
        混合推理主入口

        Args:
            query_text: 用户问题文本
            query_vec: 问题向量(可选，没有则自动编码)
            context_text: 上下文文本

        Returns:
            {
                "text": str,           # 回答文本
                "mode": "swarm"|"llm", # 推理模式
                "complexity": float,    # 复杂度
                "score": float,         # 置信度
                "ms": int,              # 耗时
                "error": str|None,      # 错误
            }
        """
        self.stats["total_queries"] += 1
        t0 = time.time()

        # 1. 编码(如果没给向量)
        if query_vec is None:
            ids = self.tokenizer.encode(query_text)
            query_vec = self.embedding.forward(ids)

        # 2. 虫群快速推理(总是先尝试)
        swarm_result = self.swarm


方法 PrefrontalHybrid.set_llm():
        """动态设置LLM"""
        self.llm_reasoner = LLMReasoner(api_key=api_key, model=model)

def set_llm(self):
        """动态设置LLM"""
        self.llm_reasoner = LLMReasoner(api_key=api_key, model=model)

    @property


文件 core/neuro/adaptive_orchestrator.py: 虫群分布式部署管理器

两种轻量模式：
1. 部分分布式：只把重计算脑区放远程，本地保留轻量脑区
2. 进程池自动启停：空闲N秒后自动回收，需要时再拉起

网络矩阵 = 本地轻量化 + 远程算力聚集 | 定义: class LazyRegionProxy, def __init__, def instance, def _connect_remote, def forward, def _remote_call, def release, class ProcessPoolManager, def __init__, def get_or_spawn

time multiprocessing typing multiprocessing numpy

#!/usr/bin/env python3
"""
虫群分布式部署管理器

两种轻量模式：
1. 部分分布式：只把重计算脑区放远程，本地保留轻量脑区
2. 进程池自动启停：空闲N秒后自动回收，需要时再拉起

网络矩阵 = 本地轻量化 + 远程算力聚集
"""

import time
import multiprocessing as mp
from typing import Dict, Optional, Callable
from multiprocessing import Process, Queue
import numpy as np

class LazyRegionProxy:
    """
    懒加载脑区代理

    特点：
    - 首次调用时才加载脑区
    - 空闲超时后自动释放内存
    - 支持本地/远程两种模式
    """

    def __init__(self,
                 region_name: str,
                 load_fn: Callable,


LazyRegionProxy

类 LazyRegionProxy 在 core/neuro/adaptive_orchestrator.py: 懒加载脑区代理

    特点：
    - 首次调用时才加载脑区
    - 空闲超时后自动释放内存
    - 支持本地/远程两种模式 | 方法: __init__, instance, _connect_remote, forward, _remote_call, release

class LazyRegionProxy:
    """
    懒加载脑区代理

    特点：
    - 首次调用时才加载脑区
    - 空闲超时后自动释放内存
    - 支持本地/远程两种模式
    """

    def __init__(self,
                 region_name: str,
                 load_fn: Callable,
                 remote_host: Optional[str] = None,
                 remote_port: int = 5500,
                 idle_timeout: float = 60.0):
        """
        Args:
            region_name: 脑区名称
            load_fn: 加载脑区的函数
            remote_host: 远程地址，None=本地模式
            remote_port: 远程端口
            idle_timeout: 空闲超时（秒），超时后释放
        """
        self.region_name = region_name
        self.load_fn = load_fn
        self.remote_host = remote_host
        self.remote_port = remote_port + {"sensory": 1, "hippocampus": 2,
                                           "association": 3, "prefrontal": 4,
                                           "motor": 5, "thalamus": 6}[region_name]
        self.idle_timeout = idle_timeout

        self._instance = None
        self._last_access = time.time()
        self._is_remote = remote_host is not None

        if not self._is_remote:
            # 本地模式：立即加载
            self._instance = load_fn()

    @property
    def instance(self):
        """懒加载访问"""
        now = time.time()

        # 检查超时释放
        if self._instance is not None and now - self._last_access > self.idle_timeout:
            print(f"[LazyRegion] {self.region_name} idle timeout, releasing...")
            del self._instance
            self._instance = None

        # 需要时加载
        if self._instance is None:
            if self._is_remote:
                # 远程模式：建立连接（按需连接）
                self._connect_remote()
            else:
                # 本地模式：加载实例
                print(f"[LazyRegion] Loading {self.region_name}...")
                self._instance = self.load_fn()

        self._last_access = time.time()
        return self._instance

    def _connect_remote(self):
        """连接远程脑区服务"""
        import zmq


instance

方法 LazyRegionProxy.instance():
        """懒加载访问"""
        now = time.time()

        # 检查超时释放
        if self._instance i

def instance(self):
        """懒加载访问"""
        now = time.time()

        # 检查超时释放
        if self._instance is not None and now - self._last_access > self.idle_timeout:
            print(f"[LazyRegion] {self.region_name} idle timeout, releasing...")
            del self._instance
            self._instance = None

        # 需要时加载
        if self._instance is None:
            if self._is_remote:
                # 远程模式：建立连接（按需连接）
                self._connect_remote()
            else:
                # 本地模式：加载实例
                print(f"[LazyRegion] Loading {self.region_name}...")
                self._instance = self.load_fn()

        self._last_access = time.time()
        return self._instance


forward

方法 LazyRegionProxy.forward():
        """代理到实际脑区"""
        if self._is_remote:
            return self._remote_call(*args, **kwa

def forward(self):
        """代理到实际脑区"""
        if self._is_remote:
            return self._remote_call(*args, **kwargs)
        else:
            return self.instance.forward(*args, **kwargs)


release

方法 LazyRegionProxy.release():
        """手动释放"""
        if self._instance is not None:
            del self._instance

def release(self):
        """手动释放"""
        if self._instance is not None:
            del self._instance
            self._instance = None
            print(f"[LazyRegion] {self.region_name} released")


ProcessPoolManager

进程池管理器 - 自动启停

    脑区进程空闲N秒后自动退出
    下次请求时自动拉起

类 ProcessPoolManager 在 core/neuro/adaptive_orchestrator.py: 进程池管理器 - 自动启停

    脑区进程空闲N秒后自动退出
    下次请求时自动拉起 | 方法: __init__, get_or_spawn, check_idle, shutdown_all

class ProcessPoolManager:
    """
    进程池管理器 - 自动启停

    脑区进程空闲N秒后自动退出
    下次请求时自动拉起
    """

    def __init__(self, idle_timeout: float = 60.0):
        self.idle_timeout = idle_timeout
        self.processes: Dict[str, Process] = {}
        self.last_request_time: Dict[str, float] = {}
        self._monitor_running = False

    def get_or_spawn(self, name: str, spawn_fn: Callable) -> Process:
        """
        获取或启动进程

        Args:
            name: 进程名称
            spawn_fn: 启动进程的函数

        Returns:
            进程对象
        """
        now = time.time()

        # 检查现有进程状态
        if name in self.processes:
            proc = self.processes[name]
            if proc.is_alive():
                self.last_request_time[name] = now
                return proc
            else:
                # 进程已退出，清理
                del self.processes[name]

        # 启动新进程
        print(f"[ProcessPool] Spawning {name}...")
        proc = spawn_fn()
        self.processes[name] = proc
        self.last_request_time[name] = now
        proc.start()

        return proc

    def check_idle(self) -> Dict[str, bool]:
        """
        检查哪些进程应该回收

        Returns:
            {进程名: 是否应该退出}
        """
        now = time.time()
        idle = {}

        for name, last_time in list(self.last_request_time.items()):
            if name in self.processes:
                proc = self.processes[name]
                if now - last_time > self.idle_timeout and proc.is_alive():
                    print(f"[ProcessPool] {name} idle, terminating...")
                    proc.terminate()
                    proc.join(timeout=5)
                    if proc.is_alive():
                        proc.kill()
                    del self.processes[name]
                    idle[name] = True
                else:
                    idle[name] = False

        return idle

    def shutdown_all(self):
        """关闭所有进程"""
        for name, pr


方法 ProcessPoolManager.shutdown_all():
        """关闭所有进程"""
        for name, proc in self.processes.items():
            if proc.is_alive

def shutdown_all(self):
        """关闭所有进程"""
        for name, proc in self.processes.items():
            if proc.is_alive():
                proc.terminate()
                proc.join(timeout=5)
        self.processes.clear()


AdaptiveBrainOrchestrator

类 AdaptiveBrainOrchestrator 在 core/neuro/adaptive_orchestrator.py: 自适应脑区编排器

    根据任务复杂度动态选择：
    1. 纯本地模式（0网络开销）
    2. 部分分布式（只把重的放远程）
    3. 全分布式（6区全远程）

    支持进程池自动启停 | 方法: __init__, _init_local, _init_partial, _init_distributed, think, _estimate_complexity, _think_distributed, release_idle, shutdown

class AdaptiveBrainOrchestrator:
    """
    自适应脑区编排器

    根据任务复杂度动态选择：
    1. 纯本地模式（0网络开销）
    2. 部分分布式（只把重的放远程）
    3. 全分布式（6区全远程）

    支持进程池自动启停
    """

    # 各脑区计算复杂度（相对权重）
    COMPLEXITY = {
        "sensory": 0.1,      # 极轻量
        "thalamus": 0.1,     # 极轻量
        "motor": 0.1,        # 极轻量
        "hippocampus": 1.0,  # 最重（记忆检索）
        "association": 0.5,  # 中等
        "prefrontal": 0.3,   # 较轻
    }

    def __init__(self,
                 mode: str = "local",
                 remote_config: Dict[str, str] = None,
                 lazy_loading: bool = True,
                 idle_timeout: float = 60.0):
        """
        Args:
            mode: "local" | "partial" | "distributed"
            remote_config: 远程配置 {"hippocampus": "192.168.1.10", ...}
            lazy_loading: True=懒加载
            idle_timeout: 空闲超时（秒）
        """
        self.mode = mode
        self.remote_config = remote_config or {}
        self.lazy_loading = lazy_loading
        self.idle_timeout = idle_timeout

        # 懒加载代理
        self._proxies: Dict[str, LazyRegionProxy] = {}

        # 进程池（分布式模式用）
        self._pool = ProcessPoolManager(idle_timeout) if mode == "distributed" else None

        # 本地脑区（用于快速路径）
        self._local_brain = None

        if mode == "local":
            self._init_local()
        elif mode == "partial":
            self._init_partial()
        elif mode == "distributed":
            self._init_distributed()

    def _init_local(self):
        """纯本地模式"""
        from .brain_v13 import BrainV13
        self._local_brain = BrainV13()
        print("[Orchestrator] Local mode initialized")

    def _init_partial(self):
        """部分分布式：重的放远程，轻的本地"""
        # 重的：hippocampus, association
        # 轻的：sensory, motor, prefrontal, thalamus

        from .brain_v13 import BrainV13
        self._local_brain = BrainV13()

        # 懒加载重的脑区（如果有远程配置）
        for heavy in ["hippocampus", "association"]:
            if heav


方法 AdaptiveBrainOrchestrator.release_idle():
        """释放空闲脑区"""
        for proxy in self._proxies.values():
            proxy.release()

def release_idle(self):
        """释放空闲脑区"""
        for proxy in self._proxies.values():
            proxy.release()

        if self._pool:
            self._pool.check_idle()


shutdown

方法 AdaptiveBrainOrchestrator.shutdown():
        """关闭所有"""
        self.release_idle()

        if self._local_brain:
            d


文件 core/neuro/dialogue_memory.py: 虫群v11 — 对话记忆系统

在虫群三级记忆基础上增加对话专用记忆层:
- DialogueMemory: 对话轮次管理(问题向量→回答向量)
- ContextWindow: 最近N轮对话缓存
- EpisodicMemory: 场景化记忆(谁/何时/什么)

与海马区记忆系统对接:
- 对话记忆通过海马区的short_term/long_term接口存储
- 高频对话自动进入密码本 | 定义: class
class, def to_dict, class ContextWindow, def __init__, def add, def get_context_vector, def _align_dim, def get_text_summary, def clear, class DialogueMemory

#!/usr/bin/env python3
"""
虫群v11 — 对话记忆系统

在虫群三级记忆基础上增加对话专用记忆层:
- DialogueMemory: 对话轮次管理(问题向量→回答向量)
- ContextWindow: 最近N轮对话缓存
- EpisodicMemory: 场景化记忆(谁/何时/什么)

与海马区记忆系统对接:
- 对话记忆通过海马区的short_term/long_term接口存储
- 高频对话自动进入密码本
"""

import numpy as np
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import datetime
import json

@dataclass
class DialogueTurn:
    """一轮对话"""
    question_vec: np.ndarray      # 问题向量(32维)
    answer_vec: np.ndarray


DialogueTurn

类 DialogueTurn 在 core/neuro/dialogue_memory.py: 一轮对话 | 方法: to_dict

class DialogueTurn:
    """一轮对话"""
    question_vec: np.ndarray      # 问题向量(32维)
    answer_vec: np.ndarray        # 回答向量(32维)
    question_text: str = ""       # 原始问题文本
    answer_text: str = ""         # 原始回答文本
    timestamp: str = ""           # 时间戳
    source: str = "swarm"         # 来源: swarm/llm/user
    importance: float = 0.5       # 重要性

    def to_dict(self) -> dict:
        return {
            "question_text": self.question_text,
            "answer_text": self.answer_text,
            "timestamp": self.timestamp,
            "source": self.source,
            "importance": self.importance,
        }


ContextWindow

类 ContextWindow 在 core/neuro/dialogue_memory.py: 上下文窗口 — 最近N轮对话缓存

    滑动窗口机制:
    - 维护最近max_turns轮对话
    - 超出时淘汰最旧的
    - 提供上下文向量供联合区整合 | 方法: __init__, add, get_context_vector, _align_dim, get_text_summary, clear

class ContextWindow:
    """
    上下文窗口 — 最近N轮对话缓存

    滑动窗口机制:
    - 维护最近max_turns轮对话
    - 超出时淘汰最旧的
    - 提供上下文向量供联合区整合
    """

    def __init__(self, max_turns: int = 5, embed_dim: int = 32):
        self.max_turns = max_turns
        self.embed_dim = embed_dim
        self.turns: List[DialogueTurn] = []

    def add(self, turn: DialogueTurn):
        """添加一轮对话"""
        self.turns.append(turn)
        if len(self.turns) > self.max_turns:
            self.turns.pop(0)

    def get_context_vector(self, n_turns: int = 3) -> np.ndarray:
        """
        获取最近N轮的上下文向量

        策略: 最近轮次权重更大
        输出: embed_dim维向量
        """
        if not self.turns:
            return np.zeros(self.embed_dim, dtype=np.float32)

        recent = self.turns[-n_turns:]
        n = len(recent)

        # 加权平均: 越新权重越大
        weights = np.array([2**i for i in range(n)], dtype=np.float32)
        weights /= weights.sum()

        q_sum = np.zeros(self.embed_dim, dtype=np.float32)
        a_sum = np.zeros(self.embed_dim, dtype=np.float32)

        for i, turn in enumerate(recent):
            q_aligned = self._align_dim(turn.question_vec)
            a_aligned = self._align_dim(turn.answer_vec)
            q_sum += weights[i] * q_aligned
            a_sum += weights[i] * a_aligned

        # 问题+回答各半
        context = np.concatenate([q_sum[:16], a_sum[:16]])[:self.embed_dim]
        return context.astype(np.float32)

    def _align_dim(self, vec: np.ndarray) -> np.ndarray:
        """维度对齐"""
        vec = np.asarray(vec, dtype=np.float32).ravel()
        if len(vec) < self.embed_dim:
            vec = np.pad(vec, (0, self.embed_dim - len(vec)))
        elif len(vec) > self.embed_dim:
            vec = vec[:self.embed_dim]
        return vec

    def get_text_summary(self, n_turns: int = 3) -> str:
        """获取最近N轮的文本摘要(供LLM prompt用)"""
        recent = self.turns[-n_turns:]
        if not recent:
            return ""
        lines =


add

方法 ContextWindow.add():
        """添加一轮对话"""
        self.turns.append(turn)
        if len(self.turns) > self.max_turns:

def add(self):
        """添加一轮对话"""
        self.turns.append(turn)
        if len(self.turns) > self.max_turns:
            self.turns.pop(0)


clear

方法 ContextWindow.clear():
        self.turns.clear()

def clear(self):
        self.turns.clear()


DialogueMemory

类 DialogueMemory 在 core/neuro/dialogue_memory.py: 对话记忆管理

    三层结构:
    1. ContextWindow: 最近5轮(滑动窗口)
    2. DialogueStore: 长期问答对(向量检索)
    3. EpisodicMemory: 场景化记忆(带标签)

    与虫群海马区对接:
    - store_turn() 同时写入ContextWindow和海马区
    - retrieve()  | 方法: __init__, set_hippocampus, store_turn, retrieve, get_context_vector, get_context_text, add_episodic, search_episodic, _cosine_sim, stats

class DialogueMemory:
    """
    对话记忆管理

    三层结构:
    1. ContextWindow: 最近5轮(滑动窗口)
    2. DialogueStore: 长期问答对(向量检索)
    3. EpisodicMemory: 场景化记忆(带标签)

    与虫群海马区对接:
    - store_turn() 同时写入ContextWindow和海马区
    - retrieve() 优先查ContextWindow，再查海马区
    """

    def __init__(self, embed_dim: int = 32, max_context_turns: int = 5):
        self.embed_dim = embed_dim

        # 三层记忆
        self.context = ContextWindow(max_turns=max_context_turns, embed_dim=embed_dim)
        self.dialogue_store: List[DialogueTurn] = []  # 长期问答对
        self.episodic: List[dict] = []                 # 场景化记忆
        self._max_dialogue = 10000                     # 长期对话上限

        # 海马区引用(稍后设置)
        self._hippocampus = None

    def set_hippocampus(self, brain_region):
        """设置海马区引用，用于长期存储"""
        self._hippocampus = brain_region

    def store_turn(self, question_vec: np.ndarray, answer_vec: np.ndarray,
                   question_text: str = "", answer_text: str = "",
                   source: str = "swarm", importance: float = 0.5):
        """
        存储一轮对话

        同时写入:
        1. ContextWindow(短期)
        2. DialogueStore(中期)
        3. 海马区(长期，如果设置了引用)
        """
        question_vec = np.asarray(question_vec, dtype=np.float32).ravel()
        answer_vec = np.asarray(answer_vec, dtype=np.float32).ravel()

        turn = DialogueTurn(
            question_vec=question_vec,
            answer_vec=answer_vec,
            question_text=question_text,
            answer_text=answer_text,
            timestamp=datetime.now().isoformat(),
            source=source,
            importance=importance,
        )

        # 1. 写入上下文窗口
        self.context.add(turn)

        # 2. 写入长期对话存储
        self.dialogue_store.append(turn)
        if len(self.dialogue_store) > self._max_dialogue:
            # 淘汰最不重要的
            self.dialogue_store.sort(key=lambda t: t.importance, reverse=True)
            self.dialogue_store = self.dialogue_s


方法 DialogueMemory.set_hippocampus():
        """设置海马区引用，用于长期存储"""
        self._hippocampus = brain_region

def set_hippocampus(self):
        """设置海马区引用，用于长期存储"""
        self._hippocampus = brain_region


方法 DialogueMemory.store_turn():
        """
        存储一轮对话

        同时写入:
        1. ContextWindow(短期)
        2. DialogueS

def store_turn(self):
        """
        存储一轮对话

        同时写入:
        1. ContextWindow(短期)
        2. DialogueStore(中期)
        3. 海马区(长期，如果设置了引用)
        """
        question_vec = np.asarray(question_vec, dtype=np.float32).ravel()
        answer_vec = np.asarray(answer_vec, dtype=np.float32).ravel()

        turn = DialogueTurn(
            question_vec=question_vec,
            answer_vec=answer_vec,
            question_text=question_text,
            answer_text=answer_text,
            timestamp=datetime.now().isoformat(),
            source=source,
            importance=importance,
        )

        # 1. 写入上下文窗口
        self.context.add(turn)

        # 2. 写入长期对话存储
        self.dialogue_store.append(turn)
        if len(self.dialogue_store) > self._max_dialogue:
            # 淘汰最不重要的
            self.dialogue_store.sort(key=lambda t: t.importance, reverse=True)
            self.dialogue_store = self.dialogue_store[:self._max_dialogue]

        # 3. 写入海马区(如


方法 DialogueMemory.add_episodic():
        """添加场景化记忆"""
        self.episodic.append({
            "who": who,
            "what": wh

def add_episodic(self):
        """添加场景化记忆"""
        self.episodic.append({
            "who": who,
            "what": what,
            "where": where,
            "when": datetime.now().isoformat(),
            "tags": tags or [],
        })
        # 限制数量
        if len(self.episodic) > 500:
            self.episodic = self.episodic[-500:]


brain.py

文件 core/neuro/brain.py: 虫群v10 — 脑区模型 + 完整大脑

脑区: 多功能柱协作
大脑: 6大脑区 + 信号流 + 丘脑调控

6大脑区:
- 感觉区: 信号→特征
- 海马区: 特征→记忆存取
- 联合区: 多区信息整合
- 前额区: 决策规划
- 运动区: 决策→动作
- 丘脑: 全局调控

信号流: 感觉区→海马区→联合区→前额区→运动区
丘脑全程调控注意力和优先级 | 定义: class BrainRegion, def __init__, def forward, def reset, def store_memory, def retrieve_memory, def distill, def total_params, def total_memory_KB, def info

#!/usr/bin/env python3
"""
虫群v10 — 脑区模型 + 完整大脑

脑区: 多功能柱协作
大脑: 6大脑区 + 信号流 + 丘脑调控

6大脑区:
- 感觉区: 信号→特征
- 海马区: 特征→记忆存取
- 联合区: 多区信息整合
- 前额区: 决策规划
- 运动区: 决策→动作
- 丘脑: 全局调控

信号流: 感觉区→海马区→联合区→前额区→运动区
丘脑全程调控注意力和优先级
"""

import numpy as np
from typing import Dict, List, Optional, Tuple
from .functional_column import FunctionalColumn

class BrainRegion:
    """
    脑区 — 多功能柱协作

    每个脑区包含1-多个功能柱，负责特定功能
    脑区之间通过标准接口通信
    """

    def __init__(self, name: str, region_type: str,
                 n


BrainRegion

类 BrainRegion 在 core/neuro/brain.py: 脑区 — 多功能柱协作

    每个脑区包含1-多个功能柱，负责特定功能
    脑区之间通过标准接口通信 | 方法: __init__, forward, reset, store_memory, retrieve_memory, distill, total_params, total_memory_KB, info

class BrainRegion:
    """
    脑区 — 多功能柱协作

    每个脑区包含1-多个功能柱，负责特定功能
    脑区之间通过标准接口通信
    """

    def __init__(self, name: str, region_type: str,
                 n_columns: int = 3,
                 input_dim: int = 32, output_dim: int = 32,
                 n_neurons: int = 300,
                 n_micro_per_column: int = 32):
        self.name = name
        self.region_type = region_type
        self.input_dim = input_dim
        self.output_dim = output_dim

        # 创建功能柱
        self.columns: List[FunctionalColumn] = []
        for _ in range(n_columns):
            fc = FunctionalColumn(
                column_type=region_type,
                n_micro_columns=n_micro_per_column,
                input_dim=input_dim,
                output_dim=output_dim,
                n_neurons_per_column=n_neurons,
            )
            self.columns.append(fc)

    def forward(self, x: np.ndarray) -> np.ndarray:
        """脑区前向传播: 各功能柱协作"""
        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]

        # 各功能柱处理
        outputs = []
        for col in self.columns:
            out = col.forward(x)
            outputs.append(out)

        # 脑区级聚合: 加权平均
        if not outputs:
            return np.zeros(self.output_dim, dtype=np.float32)

        result = np.mean(outputs, axis=0)
        return result.astype(np.float32)

    def reset(self):
        """重置所有功能柱"""
        for col in self.columns:
            col.reset()

    def store_memory(self, key: np.ndarray, value: np.ndarray):
        """存储到最优功能柱"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()

        best = min(self.columns, key=lambda c: len(c.short_term_buffer))
        best.short_term_store(key, value, importance=0


reset

方法 BrainRegion.reset():
        """重置所有功能柱"""
        for col in self.columns:
            col.reset()

def reset(self):
        """重置所有功能柱"""
        for col in self.columns:
            col.reset()


方法 BrainRegion.store_memory():
        """存储到最优功能柱"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.a

def store_memory(self):
        """存储到最优功能柱"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()

        best = min(self.columns, key=lambda c: len(c.short_term_buffer))
        best.short_term_store(key, value, importance=0.5)


Brain

类 Brain 在 core/neuro/brain.py: 完整大脑 — 6大脑区协作

    信号流: 输入→感觉区→海马区→联合区→前额区→运动区→输出
    丘脑全程调控

    三级记忆:
    - 微缓存: 神经元运行时
    - 短期: 按需扩容/释放
    - 长期: 慎重删除，蒸馏萃取
    - 静态知识库: 只增不减，按需检索 | 方法: __init__, _init_connections, think, remember, recall, consolidate, reset, total_params, total_memory_KB, static_kb_size, info

class Brain:
    """
    完整大脑 — 6大脑区协作

    信号流: 输入→感觉区→海马区→联合区→前额区→运动区→输出
    丘脑全程调控

    三级记忆:
    - 微缓存: 神经元运行时
    - 短期: 按需扩容/释放
    - 长期: 慎重删除，蒸馏萃取
    - 静态知识库: 只增不减，按需检索
    """

    def __init__(self, input_dim: int = 32, output_dim: int = 32,
                 n_neurons: int = 300, n_micro_per_column: int = 32,
                 region_config: Dict[str, int] = None):
        """
        参数:
        - input_dim: 输入维度
        - output_dim: 输出维度
        - n_neurons: 每个功能柱的神经元数
        - n_micro_per_column: 每个功能柱的微柱数
        - region_config: 各脑区功能柱数量配置，默认差异化配置
        """
        self.input_dim = input_dim
        self.output_dim = output_dim

        # 默认差异化配置：各脑区根据功能需求独立配置
        if region_config is None:
            region_config = {
                "sensory": 5,       # 感觉区: 5柱（处理多模态输入）
                "hippocampus": 8,   # 海马区: 8柱（记忆存储需要更多）
                "association": 6,   # 联合区: 6柱（信息整合）
                "prefrontal": 4,    # 前额区: 4柱（决策）
                "motor": 3,         # 运动区: 3柱（执行）
                "thalamus": 1,     # 丘脑: 1柱（调节）
            }

        # --- 6大脑区 (独立配置柱数) ---
        self.regions: Dict[str, BrainRegion] = {
            "sensory": BrainRegion(
                "感觉区", "sensory",
                n_columns=region_config.get("sensory", 5),
                input_dim=input_dim, output_dim=64,
                n_neurons=n_neurons, n_micro_per_column=n_micro_per_column,
            ),
            "hippocampus": BrainRegion(
                "海马区", "memory",
                n_columns=region_config.get("hippocampus", 8),
                input_dim=64, output_dim=64,
                n_neurons=n_neurons, n_micro_per_column=n_micro_per_column,
            ),
            "association": BrainRegion(
                "联合区", "associate",
                n_columns=region_config.get("association", 6),
                input_dim=64, output_dim=64,
                n_neurons=n_neurons, n_micro_per_column=n_micro_per_column,
            ),


remember

方法 Brain.remember():
        """存入记忆 (海马区)"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np

def remember(self):
        """存入记忆 (海马区)"""
        key = np.asarray(key, dtype=np.float32).ravel()
        value = np.asarray(value, dtype=np.float32).ravel()
        self.regions["hippocampus"].store_memory(key, value)


reset

方法 Brain.reset():
        """重置全脑状态"""
        for region in self.regions.values():
            region.reset()

def reset(self):
        """重置全脑状态"""
        for region in self.regions.values():
            region.reset()
        self._attention = np.ones(32, dtype=np.float32)
        self._thought_history.clear()

    @property


文件 core/neuro/brain_expander.py: BrainV13 自扩容系统 (简化版) | 定义: class BrainExpander, def __init__, def expand, def record_think, def auto_expand, def get_stats, def get_history

#!/usr/bin/env python3
"""
BrainV13 自扩容系统 (简化版)
"""

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

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,