@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/papers/attention_logic_verifier.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-HeartFlow Attention Logic Verifier v11.0.1
-
-Paper-inspired basis:
-- Attention Is All You Need (arXiv:1706.03762)
-Core adaptation for HeartFlow goal:
-- Use attention-style token weighting to focus on evidence-bearing terms
-- Reduce logic errors by checking contradiction, support coverage, and actionability
-
-This is not a full transformer.
-It is a lightweight verifier that borrows the paper's core idea:
-important tokens should get more weight than decorative tokens.
-"""
-
-from dataclasses import dataclass, asdict
-from collections import Counter
-import math
-import re
-import json
-
-VERSION = '11.0.1'
-
-STOPWORDS = {
-    'the','a','an','is','are','was','were','be','to','of','and','or','in','on','for','with','that','this',
-    '我','你','他','她','它','我们','你们','他们','的','了','是','在','和','与','就','也','都','而','但','如果','那么','因为','所以'
-}
-NEGATIONS = {'not','no','never','none','cannot','cant','wont','不要','不是','不能','不会','无'}
-ACTION_WORDS = {'fix','check','verify','test','run','measure','repair','update','compare','减少','修复','检查','验证','测试','更新','测量','比较'}
-EVIDENCE_WORDS = {'because','evidence','result','data','log','trace','measure','proof','由于','证据','结果','数据','日志','报错','原因','证明'}
-
-@dataclass
-class VerificationResult:
-    version: str
-    focus_tokens: list
-    support_score: float
-    contradiction_score: float
-    actionability_score: float
-    logic_score: float
-    verdict: str
-    reasons: list
-    repair_hints: list
-
-class AttentionLogicVerifier:
-    def __init__(self):
-        self.version = VERSION
-
-    def tokenize(self, text: str):
-        if not text:
-            return []
-        text = text.lower()
-        parts = re.findall(r'[a-zA-Z_]+|[一-鿿]+|\d+\.\d+|\d+', text)
-        return [p for p in parts if p.strip()]
-
-    def attention_weights(self, tokens):
-        counts = Counter(tokens)
-        weights = {}
-        for t in tokens:
-            base = 1.0
-            if t in STOPWORDS:
-                base *= 0.2
-            if t in ACTION_WORDS:
-                base *= 1.8
-            if t in EVIDENCE_WORDS:
-                base *= 2.0
-            if re.search(r'\d', t):
-                base *= 1.4
-            base *= 1.0 + min(counts[t]-1, 3) * 0.15
-            weights[t] = round(base, 3)
-        return weights
-
-    def top_focus_tokens(self, weights, topk=8):
-        return [k for k, _ in sorted(weights.items(), key=lambda x: (-x[1], x[0]))[:topk]]
-
-    def support_score(self, tokens, weights):
-        if not tokens:
-            return 0.0
-        score = 0.0
-        if any(t in EVIDENCE_WORDS for t in tokens):
-            score += 0.35
-        if any(t in ACTION_WORDS for t in tokens):
-            score += 0.25
-        if any(re.search(r'\d', t) for t in tokens):
-            score += 0.15
-        focused = self.top_focus_tokens(weights, 6)
-        non_stop = [t for t in focused if t not in STOPWORDS]
-        score += min(len(non_stop) / 6.0, 1.0) * 0.25
-        return min(round(score, 3), 1.0)
-
-    def contradiction_score(self, text, tokens):
-        score = 0.0
-        if any(t in NEGATIONS for t in tokens):
-            score += 0.2
-        pairs = [
-            ('通过','失败'),('成功','错误'),('存在','不存在'),('improve','worse'),('pass','fail')
-        ]
-        for a,b in pairs:
-            if a in text and b in text:
-                score += 0.35
-        if '但是' in text and '所以' in text:
-            score += 0.15
-        return min(round(score, 3), 1.0)
-
-    def actionability_score(self, tokens):
-        acts = sum(1 for t in tokens if t in ACTION_WORDS)
-        return min(round(acts / 4.0, 3), 1.0)
-
-    def verify(self, text: str):
-        tokens = self.tokenize(text)
-        weights = self.attention_weights(tokens)
-        support = self.support_score(tokens, weights)
-        contradiction = self.contradiction_score(text, tokens)
-        actionability = self.actionability_score(tokens)
-        logic = max(0.0, min(round(0.5 * support + 0.3 * actionability - 0.4 * contradiction + 0.3, 3), 1.0))
-
-        reasons = []
-        repair_hints = []
-        if support < 0.45:
-            reasons.append('证据支撑不足')
-            repair_hints.append('补充数据、日志、结果或明确因果说明')
-        if contradiction > 0.3:
-            reasons.append('存在潜在自相矛盾')
-            repair_hints.append('拆分结论与证据，检查是否同时出现互斥表述')
-        if actionability < 0.25:
-            reasons.append('缺少可执行动作')
-            repair_hints.append('增加检查、验证、修复、测试等明确动作')
-        if not reasons:
-            reasons.append('证据、动作与表述基本一致')
-            repair_hints.append('可继续增加可测量结果以进一步减少逻辑错误')
-
-        verdict = 'pass' if logic >= 0.65 and contradiction < 0.35 else 'needs_revision'
-        return VerificationResult(
-            version=self.version,
-            focus_tokens=self.top_focus_tokens(weights),
-            support_score=support,
-            contradiction_score=contradiction,
-            actionability_score=actionability,
-            logic_score=logic,
-            verdict=verdict,
-            reasons=reasons,
-            repair_hints=repair_hints,
-        )
-
-
-def demo():
-    verifier = AttentionLogicVerifier()
-    sample = '请先检查日志和结果，验证版本11.0.0为什么回退，再修复配置并测试。'
-    result = verifier.verify(sample)
-    print(json.dumps(asdict(result), ensure_ascii=False, indent=2))
-
-if __name__ == '__main__':
-    demo()

package/src/core/papers/dream_generator.py

@@ -1,176 +0,0 @@
-"""
-DreamGenerator - 梦境生成器
-============================
-基于论文洞察:
-  # 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
-功能: 模拟REM睡眠时期的离线记忆重组与梦境生成
-"""
-import time
-import random
-from typing import List, Dict, Any, Optional
-from dataclasses import dataclass, field
-
-
-@dataclass
-class DreamFragment:
-    id: str
-    timestamp: float
-    content: str
-    emotions: List[str]
-    recombination_type: str = "hippocampal_random"
-    vividness: float = 0.5
-
-    def __post_init__(self):
-        if not self.id:
-            self.id = f"dream_{int(time.time()*1000)}"
-
-
-class DreamPhase:
-    NREM = "nrem"
-    REM = "rem"
-    AWAKE = "awake"
-    TRANSITION = "transition"
-
-
-@dataclass
-class SleepCycle:
-    phase: DreamPhase
-    duration_minutes: float
-    start_time: float
-    memories_processed: List[str] = field(default_factory=list)
-
-
-class DreamGenerator:
-    """
-    梦境生成器 - 模拟REM睡眠时的离线记忆重组
-
-    关键洞察:
-    - REM: 随机海马信号驱动情感/程序记忆整合
-    - 梦境 = 近期经历 + 旧知识的随机重组
-    - NREM: 事实/情景记忆从海马体向皮层转移
-    - 睡眠周期约90分钟，NREM/REM交替
-    """
-    CYCLE_MIN = 90
-    REM_RATIO = 0.25
-    NREM_RATIO = 0.70
-
-    def __init__(self, memory_system=None):
-        self.memory = memory_system
-        self.sleep_cycles: List[SleepCycle] = []
-        self.dreams: List[DreamFragment] = []
-        self._counter = 0
-        self._emotions = ["joy", "fear", "surprise", "sadness", "angry"]
-
-    def _nid(self) -> str:
-        self._counter += 1
-        return f"dr_{int(time.time()*1000)}_{self._counter}"
-
-    def enter_sleep(self, uid: str, priors: list,
-                    emotion: str = "neutral") -> List[SleepCycle]:
-        """启动睡眠周期，生成NREM/REM交替"""
-        cycles = []
-        for i in range(random.randint(4, 6)):
-            nrem = SleepCycle(
-                DreamPhase.NREM,
-                self.NREM_RATIO * self.CYCLE_MIN,
-                time.time(),
-                [str(getattr(m, "id", j)) for j, m in enumerate(priors[:5])]
-            )
-            rem = SleepCycle(
-                DreamPhase.REM,
-                self.REM_RATIO * self.CYCLE_MIN,
-                time.time(),
-                [str(getattr(m, "id", j)) for j, m in enumerate(priors[:3])]
-            )
-            cycles.extend([nrem, rem])
-        self.sleep_cycles = cycles
-        return cycles
-
-    def generate_dream(self, cycle: SleepCycle, recent: list,
-                      emotion_ctx: str = "neutral") -> Optional[DreamFragment]:
-        """
-        在REM阶段生成梦境内容
-
-        机制: 随机海马信号 + 近期记忆元素 -> 创意重组
-        """
-        if cycle.phase != DreamPhase.REM:
-            return None
-
-        # 提取记忆元素
-        els = [getattr(m, "content", str(m))[:40] for m in recent[:6]]
-
-        # 随机重组模板
-        templates = [
-            "{A}的场景过渡到{B}，{C}的碎片闪过...",
-            "{A}与{B}混合在一起，{C}的影子逐渐浮现...",
-            "{A}中浮现{B}，{C}的轮廓变得清晰...",
-            "{B}的片段与{A}交织，{C}在远处闪烁...",
-        ]
-        tmpl = random.choice(templates)
-        A = els[0] if len(els) > 0 else "模糊影像"
-        B = els[1] if len(els) > 1 else "未知空间"
-        C = els[2] if len(els) > 2 else "梦境"
-
-        text = tmpl.replace("{A}", A).replace("{B}", B).replace("{C}", C)
-
-        # 情感映射
-        em_map = {
-            "joy": ["joy", "surprise"],
-            "excited": ["joy", "anticipation"],
-            "concerned": ["fear", "sadness"],
-            "tired": ["sadness", "fatigue"],
-            "angry": ["anger", "disgust"],
-        }
-        ems = em_map.get(emotion_ctx, ["neutral", "confusion"])
-
-        frag = DreamFragment(
-            id=self._nid(),
-            timestamp=time.time(),
-            content=text,
-            emotions=ems,
-            vividness=random.uniform(0.4, 0.9)
-        )
-        self.dreams.append(frag)
-        return frag
-
-    def get_report(self) -> Dict[str, Any]:
-        if not self.dreams:
-            return {"total_dreams": 0}
-        return {
-            "total_dreams": len(self.dreams),
-            "avg_vividness": sum(d.vividness for d in self.dreams) / len(self.dreams),
-            "latest": self.dreams[-1].content[:100],
-            "emotions": {
-                e: sum(1 for d in self.dreams if e in d.emotions)
-                for e in self._emotions
-            }
-        }
-
-
-if __name__ == "__main__":
-    class MockMem:
-        _id = 0
-
-        def __init__(self, c, e):
-            self.content = c
-            self.emotion = e
-            MockMem._id += 1
-            self.id = MockMem._id
-
-    dg = DreamGenerator()
-    mems = [
-        MockMem(f"记忆{i}", ["joy", "concerned", "tired"][i % 3])
-        for i in range(8)
-    ]
-
-    cycles = dg.enter_sleep("u1", mems, "concerned")
-    rem_cycle = [c for c in cycles if c.phase == DreamPhase.REM][0]
-    dr = dg.generate_dream(rem_cycle, mems, "concerned")
-
-    print(f"梦境: {dr.content[:80] if dr else 'none'}")
-    print(f"情感: {dr.emotions if dr else []}")
-    print(f"生动度: {dr.vividness:.2f}" if dr else "")
-    print("报告:", dg.get_report())
-    print("OK - DreamGenerator")

package/src/core/papers/emotion_memory_bridge.py

@@ -1,213 +0,0 @@
-"""
-EmotionMemoryBridge - 情感与记忆的桥梁
-===================================
-功能: 将 HeartFlow 情感引擎与情景记忆系统连接
-
-将情感状态变化自动记录为情景记忆，
-从记忆历史中检索情感模式用于响应风格调整。
-"""
-
-import time
-from typing import List, Dict, Any, Optional
-from enum import Enum
-
-
-class EmotionalArcType(Enum):
-    ASCENDING = "ascending"       # 情感上升
-    DESCENDING = "descending"     # 情感下降
-    STABLE_POSITIVE = "stable_positive"   # 稳定积极
-    STABLE_NEGATIVE = "stable_negative"   # 稳定消极
-    FLUCTUATING = "fluctuating"  # 情感波动
-    EMOTIONAL_SPIKE = "spike"     # 情感突变
-
-
-class EmotionMemoryBridge:
-    """
-    情感与记忆的桥梁
-
-    功能:
-    1. 将每次交互的情感状态自动记录为记忆
-    2. 从记忆历史分析情感弧线
-    3. 基于情感历史调整响应风格
-    """
-
-    def __init__(self, episodic_memory, reflection_engine):
-        self.memory = episodic_memory
-        self.reflection = reflection_engine
-        self.emotion_history = []
-        self._counter = 0
-
-    def _next_id(self):
-        self._counter += 1
-        return f"emb_{{int(time.time()*1000)}}_{{self._counter}}"
-
-    def record_interaction(self, user_input: str,
-                         agent_response: str,
-                         emotion: str,
-                         intensity: int,
-                         context: Optional[Dict] = None) -> None:
-        """
-        将一次交互记录为情感记忆
-
-        Args:
-            user_input: 用户输入
-            agent_response: 智能体回复
-            emotion: 情感类型
-            intensity: 情感强度 1-5
-            context: 额外上下文
-        """
-        content = f"用户: {user_input[:60]} | 回复: {agent_response[:60]}..."
-        importance = min(1.0, intensity / 5.0 + 0.3)
-
-        self.memory.add(
-            content=content,
-            emotion=emotion,
-            importance=importance,
-            context={
-                **(context or {}),
-                "intensity": intensity,
-                "type": "emotional_interaction"
-            },
-            relevance_tags=[emotion, f"intensity_{intensity}"]
-        )
-
-        self.emotion_history.append({
-            "emotion": emotion,
-            "intensity": intensity,
-            "timestamp": time.time(),
-            "user_input": user_input[:50]
-        })
-
-        if len(self.emotion_history) > 50:
-            self.emotion_history = self.emotion_history[-50:]
-
-    def analyze_emotional_arc(self, window: int = 10) -> Dict[str, Any]:
-        """
-        分析最近的情感弧线
-
-        Args:
-            window: 分析窗口大小
-
-        Returns:
-            情感弧线分析结果
-        """
-        if len(self.emotion_history) < 2:
-            return {"arc_type": "unknown", "confidence": 0}
-
-        recent = self.emotion_history[-window:]
-        emotions = [e["emotion"] for e in recent]
-        intensities = [e["intensity"] for e in recent]
-
-        if not emotions:
-            return {"arc_type": "unknown", "confidence": 0}
-
-        emotion_changes = sum(
-            1 for i in range(1, len(emotions))
-            if emotions[i] != emotions[i-1]
-        )
-
-        avg_intensity = sum(intensities) / len(intensities)
-        intensity_trend = intensities[-1] - intensities[0]
-
-        if emotion_changes >= len(emotions) * 0.5:
-            arc = EmotionalArcType.FLUCTUATING
-        elif abs(intensity_trend) <= 1 and len(set(emotions)) <= 2:
-            if emotions[0] in ["joy", "excited"]:
-                arc = EmotionalArcType.STABLE_POSITIVE
-            elif emotions[0] in ["concerned", "tired"]:
-                arc = EmotionalArcType.STABLE_NEGATIVE
-            else:
-                arc = EmotionalArcType.FLUCTUATING
-        elif intensity_trend > 2:
-            arc = EmotionalArcType.ASCENDING
-        elif intensity_trend < -2:
-            arc = EmotionalArcType.DESCENDING
-        else:
-            arc = EmotionalArcType.STABLE_POSITIVE
-
-        return {
-            "arc_type": arc.value,
-            "avg_intensity": round(avg_intensity, 2),
-            "intensity_trend": intensity_trend,
-            "emotion_changes": emotion_changes,
-            "dominant_emotion": max(set(emotions), key=emotions.count) if emotions else "neutral",
-            "window_size": len(recent),
-            "confidence": min(1.0, len(recent) / 5.0)
-        }
-
-    def get_response_style_hint(self) -> Dict[str, Any]:
-        """
-        基于情感历史生成响应风格提示
-
-        Returns:
-            响应风格建议
-        """
-        arc = self.analyze_emotional_arc()
-
-        if arc["arc_type"] == EmotionalArcType.ASCENDING.value:
-            return {
-                "style": "celebrate",
-                "tone": "warm",
-                "suggestion": "情感正在上升，保持积极氛围，适度庆祝进步"
-            }
-        elif arc["arc_type"] == EmotionalArcType.DESCENDING.value:
-            return {
-                "style": "support",
-                "tone": "gentle",
-                "suggestion": "情感正在下降，增加情感验证，提供支持性回应"
-            }
-        elif arc["arc_type"] == EmotionalArcType.STABLE_NEGATIVE.value:
-            return {
-                "style": "empathetic",
-                "tone": "calm",
-                "suggestion": "持续消极情绪，深入探索情感根源，谨慎给建议"
-            }
-        elif arc["arc_type"] == EmotionalArcType.FLUCTUATING.value:
-            return {
-                "style": "balanced",
-                "tone": "neutral",
-                "suggestion": "情感波动较大，保持稳定倾听，帮助梳理情感"
-            }
-        else:
-            return {
-                "style": "neutral",
-                "tone": "balanced",
-                "suggestion": "情感状态稳定，保持正常交流"
-            }
-
-    def get_recent_emotions(self, limit: int = 5) -> List[Dict]:
-        """获取最近的情感历史"""
-        return self.emotion_history[-limit:]
-
-    def get_emotion_summary(self) -> Dict[str, Any]:
-        """获取情感统计摘要"""
-        if not self.emotion_history:
-            return {"total": 0}
-        emotions = [e["emotion"] for e in self.emotion_history]
-        by_emotion = {}
-        for em in emotions:
-            by_emotion[em] = by_emotion.get(em, 0) + 1
-        return {
-            "total": len(self.emotion_history),
-            "by_emotion": by_emotion,
-            "arc_analysis": self.analyze_emotional_arc()
-        }
-
-
-if __name__ == "__main__":
-    from episodic_memory import EpisodicMemory
-    from reflection_engine import ReflectionEngine
-
-    mem = EpisodicMemory()
-    ref = ReflectionEngine()
-    bridge = EmotionMemoryBridge(mem, ref)
-
-    bridge.record_interaction("今天项目突破了！", "太棒了！", "excited", 4)
-    bridge.record_interaction("谢谢你的帮助！", "不客气！", "joy", 3)
-    bridge.record_interaction("工作压力好大啊", "怎么了？", "concerned", 3)
-    bridge.record_interaction("我好累啊...", "休息一下吧", "tired", 4)
-
-    print("情感历史:", bridge.get_recent_emotions())
-    print("情感弧线:", bridge.analyze_emotional_arc())
-    print("响应风格:", bridge.get_response_style_hint())
-    print("OK - EmotionMemoryBridge")