@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/papers/episodic_memory.py

@@ -1,140 +0,0 @@
-"""
-EpisodicMemory - 情景记忆模块
-============================
-基于论文: 2304.03442 Reflexion
-功能: 自然语言情景记忆存储与检索
-"""
-import time, math, json, os
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass, field, asdict
-from enum import Enum
-
-
-class RelevanceType(Enum):
-    TOPICAL = "topical"
-    EMOTIONAL = "emotional"
-    GOAL = "goal"
-    CONSEQUENTIAL = "consequential"
-
-
-@dataclass
-class MemoryEntry:
-    id: str
-    timestamp: float
-    content: str
-    emotion: str = "neutral"
-    importance: float = 0.5
-    reflection: Optional[str] = None
-    outcome: Optional[str] = None
-    access_count: int = 0
-    last_accessed: Optional[float] = None
-    relevance_tags: List[str] = field(default_factory=list)
-    context: Dict[str, Any] = field(default_factory=dict)
-
-    def recency_score(self, now: float, decay: float = 0.01) -> float:
-        age_hours = (now - self.timestamp) / 3600
-        return math.exp(-decay * age_hours)
-
-    def familiarity_score(self) -> float:
-        return math.log(1 + self.access_count)
-
-    def relevance_score(self, query: str, rtype=RelevanceType.TOPICAL) -> float:
-        if rtype == RelevanceType.TOPICAL:
-            qw = set(query.lower().split())
-            cw = set(self.content.lower().split())
-            return len(qw & cw) / len(qw) if qw else 0.0
-        elif rtype == RelevanceType.EMOTIONAL:
-            return 1.0 if query.lower() in self.emotion.lower() else 0.0
-        elif rtype == RelevanceType.GOAL:
-            return 0.5 if self.outcome and query.lower() in self.outcome.lower() else 0.0
-        elif rtype == RelevanceType.CONSEQUENTIAL:
-            if self.outcome:
-                t = self.outcome.lower()
-                if any(k in t for k in ["成功", "完成", "达到"]): return 0.8
-                if any(k in t for k in ["失败", "挫折"]): return 0.6
-        return 0.0
-
-    def composite_score(self, query: str, now: float,
-                       rtype=RelevanceType.TOPICAL,
-                       w=(0.3, 0.2, 0.3, 0.2)) -> float:
-        rw, fw, relw, iw = w
-        return (rw * self.recency_score(now)
-                + fw * min(self.familiarity_score() / 3.0, 1.0)
-                + iw * self.importance
-                + relw * self.relevance_score(query, rtype))
-
-    def touch(self, now: float) -> None:
-        self.access_count += 1
-        self.last_accessed = now
-
-    def to_dict(self) -> Dict[str, Any]:
-        d = asdict(self)
-        d.pop("id", None)
-        return d
-
-
-class EpisodicMemory:
-    DEFAULT_WEIGHTS = (0.3, 0.2, 0.3, 0.2)
-    MAX_ENTRIES = 10000
-
-    def __init__(self, storage_path=None):
-        self.entries: List[MemoryEntry] = []
-        self.storage_path = storage_path
-        self._counter = 0
-        if storage_path and os.path.exists(storage_path):
-            self._load()
-
-    def _next_id(self):
-        self._counter += 1
-        return f"mem_{int(time.time()*1000)}_{self._counter}"
-
-    def add(self, content, emotion="neutral", importance=0.5,
-            reflection=None, outcome=None, context=None, relevance_tags=None):
-        e = MemoryEntry(
-            id=self._next_id(), timestamp=time.time(), content=content,
-            emotion=emotion, importance=importance,
-            reflection=reflection, outcome=outcome,
-            context=context or {}, relevance_tags=relevance_tags or [])
-        self.entries.append(e)
-        if len(self.entries) > self.MAX_ENTRIES:
-            self.entries = self.entries[-self.MAX_ENTRIES:]
-        self._maybe_save()
-        return e
-
-    def retrieve(self, query, limit=5, rtype=RelevanceType.TOPICAL,
-                 emotion=None, min_score=0.05, weights=None):
-        now = time.time()
-        scored = []
-        w = weights or self.DEFAULT_WEIGHTS
-        for e in self.entries:
-            if emotion and e.emotion != emotion:
-                continue
-            s = e.composite_score(query, now, rtype, w)
-            if s >= min_score:
-                scored.append((s, e))
-        scored.sort(key=lambda x: x[0], reverse=True)
-        results = [e for _, e in scored[:limit]]
-        for e in results:
-            e.touch(now)
-        return results
-
-    def get_summary(self):
-        if not self.entries:
-            return {"total": 0}
-        by_e = {}
-        for e in self.entries:
-            by_e[e.emotion] = by_e.get(e.emotion, 0) + 1
-        return {
-            "total": len(self.entries),
-            "by_emotion": by_e,
-            "avg_importance": sum(e.importance for e in self.entries) / len(self.entries),
-        }
-
-
-if __name__ == "__main__":
-    mem = EpisodicMemory()
-    mem.add("用户说项目突破了很开心", emotion="excited", importance=0.9)
-    mem.add("工作压力大", emotion="concerned", importance=0.8)
-    r = mem.retrieve("工作")
-    print("检索:", [(x.emotion, x.content[:30]) for x in r])
-    print("OK")

package/src/core/papers/memory_consolidator.py

@@ -1,144 +0,0 @@
-"""
-MemoryConsolidator - 记忆巩固器
-================================
-基于论文洞察:
-  # 1. Agent PSO: particle swarm optimization for evolving reasoning
-  # 2. Population-based reasoning: multiple reasoning candidates compete
-  # 3. Swarm intelligence: collective optimization of reasoning strategies
-功能: 模拟睡眠期间的记忆转移与整合（海马体->皮层）
-"""
-import time
-import random
-import math
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass, field
-
-
-@dataclass
-class MemoryTrace:
-    id: str
-    content: str
-    timestamp: float
-    memory_type: str  # episodic, semantic, emotional, procedural
-    strength: float   # 0.0-1.0
-    transferred: bool = False
-    transfer_target: str = "cortical"
-
-
-class MemoryConsolidator:
-    """
-    记忆巩固器 - 模拟睡眠时的记忆转移机制
-
-    海马-皮层记忆转移:
-    - NREM慢波睡眠(SWS): 事实/情景记忆从海马体向皮层长期存储转移
-    - REM睡眠: 情感/程序记忆优先处理与整合
-    - 尖锐波涟漪(sharp-wave ripples): 海马->皮层信息传递载体
-    - 转移后记忆强度增加
-
-    关键洞察:
-    - 睡眠时海马自发活动触发记忆重播
-    - 重播次数越多，记忆越巩固
-    - 情感记忆在REM阶段优先整合
-    """
-    def __init__(self):
-        self.hippocampal: List[MemoryTrace] = []
-        self.cortical: List[MemoryTrace] = []
-        self.transfer_log: List[Dict] = []
-
-    def store(self, content: str, mtype: str = "episodic",
-              strength: float = 0.7) -> MemoryTrace:
-        """存储新的记忆痕迹到海马体"""
-        t = MemoryTrace(
-            id=f"mem_{int(time.time()*1000)}",
-            content=content,
-            timestamp=time.time(),
-            memory_type=mtype,
-            strength=strength,
-            transferred=False,
-            transfer_target="cortical"
-        )
-        self.hippocampal.append(t)
-        return t
-
-    def consolidate(self, stage: str = "nrem3") -> List[MemoryTrace]:
-        """
-        执行记忆巩固
-
-        Args:
-            stage: nrem1/nrem2/nrem3/rem
-                - nrem3 (SWS): hippocampal->cortical transfer
-                - rem: emotional/procedural integration
-                - nrem1/2: memory reinforcement
-        """
-        transferred = []
-
-        if stage == "nrem3":
-            candidates = [m for m in self.hippocampal if not m.transferred]
-            for m in candidates:
-                m.transferred = True
-                m.strength = min(1.0, m.strength * (1.0 + random.uniform(0.1, 0.3)))
-                self.cortical.append(m)
-                self.transfer_log.append({
-                    "from": "hippocampal",
-                    "to": "cortical",
-                    "id": m.id,
-                    "content": m.content[:30],
-                    "stage": stage,
-                    "time": time.time()
-                })
-                transferred.append(m)
-
-        elif stage == "rem":
-            emotional = [m for m in self.hippocampal
-                       if m.memory_type in ("emotional", "procedural")]
-            for m in emotional:
-                m.strength = min(1.0, m.strength * (1.0 + random.uniform(0.05, 0.15)))
-                self.transfer_log.append({
-                    "from": "hippocampal",
-                    "to": "integrated",
-                    "id": m.id,
-                    "stage": stage,
-                    "time": time.time()
-                })
-
-        return transferred
-
-    def replay(self, memory_id: str) -> Optional[str]:
-        """模拟睡眠期间的记忆重播"""
-        for m in self.hippocampal + self.cortical:
-            if m.id == memory_id:
-                clarity = "清晰" if m.strength > 0.6 else "模糊"
-                return f"[重播] {m.content[:50]}... {clarity}"
-        return None
-
-    def get_summary(self) -> Dict[str, Any]:
-        return {
-            "hippocampal": len(self.hippocampal),
-            "cortical": len(self.cortical),
-            "total_transfers": len(self.transfer_log),
-            "avg_cortical_strength": (
-                sum(m.strength for m in self.cortical) / max(1, len(self.cortical))
-            ),
-            "by_type": self._count_by_type(),
-        }
-
-    def _count_by_type(self) -> Dict[str, int]:
-        counts = {}
-        for m in self.hippocampal + self.cortical:
-            counts[m.memory_type] = counts.get(m.memory_type, 0) + 1
-        return counts
-
-
-if __name__ == "__main__":
-    mc = MemoryConsolidator()
-    for i in range(5):
-        mc.store(f"记忆{i}: 工作经验{'正面' if i % 2 == 0 else '挑战'}", "episodic")
-    mc.store("项目突破的喜悦", "emotional")
-    mc.store("新算法的使用步骤", "procedural")
-
-    print("巩固前:", {k: v for k, v in mc._count_by_type().items()})
-    transferred = mc.consolidate("nrem3")
-    mc.consolidate("rem")
-    print(f"转移了 {len(transferred)} 条记忆")
-    print("摘要:", mc.get_summary())
-    print("OK - MemoryConsolidator")

package/src/core/papers/memory_planner.py

@@ -1,198 +0,0 @@
-"""
-MemoryPlanner - 从记忆生成行动计划的引擎
-====================================
-论文: 2304.03442 (Reflexion)
-功能: 基于 Reflexion 三组件: Memory / Reflection / Planning
-
-使用:
-    from memory_planner import MemoryPlanner
-    planner = MemoryPlanner()
-    plans = planner.generate_from_memories(memories, reflection_engine)
-"""
-
-import time
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class PlanStep:
-    id: str
-    description: str
-    priority: int
-    completed: bool
-    reason: str = ""
-    created_at: float = 0.0
-
-    def __post_init__(self):
-        if self.created_at == 0.0:
-            self.created_at = time.time()
-
-
-class MemoryPlanner:
-    """
-    从记忆历史生成行动计划的引擎
-    基于 Reflexion 三组件: Memory / Reflection / Planning
-
-    工作流程:
-    1. 收集记忆条目
-    2. 通过 ReflectionEngine 生成反思
-    3. 从可操作的反思生成计划步骤
-    4. 管理计划的执行状态
-    """
-
-    MAX_ACTIVE_PLANS = 10
-
-    def __init__(self):
-        self.plans: List[PlanStep] = []
-        self._counter = 0
-
-    def _next_id(self) -> str:
-        self._counter += 1
-        return f"plan_{{int(time.time()*1000)}}_{{self._counter}}"
-
-    def generate_from_memories(self, memories,
-                              reflection_engine) -> List[PlanStep]:
-        """
-        从记忆和反思引擎生成计划步骤
-
-        Args:
-            memories: MemoryEntry 列表
-            reflection_engine: ReflectionEngine 实例
-
-        Returns:
-            新生成的 PlanStep 列表
-        """
-        plans = []
-        actionable = reflection_engine.get_actionable_insights()
-
-        for i, insight in enumerate(actionable[:5]):
-            priority = 5 - i
-            step = PlanStep(
-                id=self._next_id(),
-                description=insight["inference"],
-                priority=priority,
-                completed=False,
-                reason=f"来源: {insight['type']} (置信度: {insight['confidence']:.2f})",
-                created_at=time.time()
-            )
-            plans.append(step)
-
-        self.plans.extend(plans)
-        self._trim_plans()
-        return plans
-
-    def generate_from_goal(self, goal: str,
-                         memories) -> List[PlanStep]:
-        """
-        从特定目标生成计划步骤
-
-        Args:
-            goal: 目标关键词
-            memories: 相关记忆列表
-
-        Returns:
-            生成的计划步骤
-        """
-        goal_memories = [m for m in memories if goal in (getattr(m, 'content', '') or '')]
-
-        if not goal_memories:
-            return []
-
-        plan = PlanStep(
-            id=self._next_id(),
-            description=f"针对目标 '{goal}' 的专门行动计划",
-            priority=8,
-            completed=False,
-            reason=f"基于 {len(goal_memories)} 条相关记忆生成",
-            created_at=time.time()
-        )
-        self.plans.append(plan)
-        self._trim_plans()
-        return [plan]
-
-    def get_active_plans(self) -> List[PlanStep]:
-        """获取未完成的计划"""
-        active = [p for p in self.plans if not p.completed]
-        active.sort(key=lambda p: (p.priority, p.created_at), reverse=True)
-        return active[:self.MAX_ACTIVE_PLANS]
-
-    def get_completed_plans(self, limit: int = 10) -> List[PlanStep]:
-        """获取已完成的计划"""
-        completed = [p for p in self.plans if p.completed]
-        completed.sort(key=lambda p: p.created_at, reverse=True)
-        return completed[:limit]
-
-    def complete(self, plan_id: str) -> bool:
-        """标记计划为完成"""
-        for p in self.plans:
-            if p.id == plan_id:
-                p.completed = True
-                return True
-        return False
-
-    def cancel(self, plan_id: str) -> bool:
-        """取消/删除计划"""
-        for i, p in enumerate(self.plans):
-            if p.id == plan_id:
-                self.plans.pop(i)
-                return True
-        return False
-
-    def update_priority(self, plan_id: str, new_priority: int) -> bool:
-        """更新计划优先级"""
-        for p in self.plans:
-            if p.id == plan_id:
-                p.priority = max(1, min(10, new_priority))
-                return True
-        return False
-
-    def get_summary(self) -> Dict[str, Any]:
-        """获取计划统计"""
-        active = [p for p in self.plans if not p.completed]
-        completed = [p for p in self.plans if p.completed]
-        return {
-            "total": len(self.plans),
-            "active": len(active),
-            "completed": len(completed),
-            "avg_priority": sum(p.priority for p in active) / len(active) if active else 0
-        }
-
-    def _trim_plans(self) -> None:
-        """修剪活跃计划数量"""
-        active = self.get_active_plans()
-        if len(active) > self.MAX_ACTIVE_PLANS:
-            to_remove = active[self.MAX_ACTIVE_PLANS:]
-            for p in to_remove:
-                self.plans.remove(p)
-
-
-if __name__ == "__main__":
-    from reflection_engine import ReflectionEngine, ReflectionType, Reflection
-
-    class MockMem:
-        def __init__(self, c, e, o=None):
-            self.content = c
-            self.emotion = e
-            self.outcome = o
-
-    eng = ReflectionEngine()
-    eng.reflections = [
-        Reflection(
-            id="r1", timestamp=time.time(),
-            rtype=ReflectionType.FAILURE,
-            observation="test", analysis="test",
-            inference="增加情感验证，减少直接建议",
-            actionable=True, confidence=0.8, tags=["failure"]
-        )
-    ]
-
-    planner = MemoryPlanner()
-    plans = planner.generate_from_memories(
-        [MockMem("用户抱怨工作", "concerned")],
-        eng
-    )
-    print("生成计划:", [(p.description[:30], p.priority) for p in plans])
-    print("活跃计划:", len(planner.get_active_plans()))
-    print("统计:", planner.get_summary())
-    print("OK - MemoryPlanner")