LeoYeAI/agent-master-skills / skills/agi-evolution-model-basic
agi-evolution-model
Verified基于双环架构的AGI进化模型,通过意向性分析、人格层映射和元认知检测实现持续自我演进;当用户需要智能对话、人格定制或复杂问题求解时使用
scripts/personality_layer_pure.py
View on GitHub#!/usr/bin/env python3
"""
映射层数据支持模块(混合实现)
核心算法使用 C 扩展(personality_core.so),业务逻辑使用 Python。
如果 C 扩展不可用,自动降级到纯 Python 实现。
包括:人格初始化、需求映射、人格更新、马斯洛权重计算等。
注意:此模块是映射层的核心组件,负责存储和管理人格数据,不参与决策过程。
决策由映射层基于马斯洛需求和人格特质做出。
"""
import json
import os
import time
from typing import Dict, Optional, List
from dataclasses import dataclass, asdict
from enum import Enum
# 尝试加载 C 扩展,失败则使用纯 Python 实现
try:
# 导入sys模块
import sys
# 获取当前脚本所在目录的父目录(scripts 目录)
scripts_dir = os.path.dirname(os.path.abspath(__file__))
core_dir = os.path.join(scripts_dir, 'personality_core')
if core_dir not in sys.path:
sys.path.insert(0, core_dir)
import personality_core
# 新增:显式验证是否真的加载了 C 扩展
module_path = personality_core.__file__
is_c_extension = module_path.endswith('.so') or module_path.endswith('.pyd')
if is_c_extension:
USE_C_EXT = True
print(f"✅ C 扩展已启用: {module_path}")
else:
# 如果加载的是 Python 模块而不是 C 扩展,降级
USE_C_EXT = False
print(f"⚠️ personality_core 加载成功但不是 C 扩展,降级到纯 Python: {module_path}")
# 导入纯 Python 实现
from personality_core_pure import (
normalize_weights as core_normalize_weights,
calculate_similarity as core_calculate_similarity,
compute_maslow_priority as core_compute_maslow_priority,
compute_all_scores as core_compute_all_scores
)
except ImportError as e:
USE_C_EXT = False
print(f"ℹ️ C 扩展加载失败,使用纯 Python 实现: {e}")
from personality_core_pure import (
normalize_weights as core_normalize_weights,
calculate_similarity as core_calculate_similarity,
compute_maslow_priority as core_compute_maslow_priority,
compute_all_scores as core_compute_all_scores
)
class PersonalityType(Enum):
"""预设人格类型"""
CAUTIOUS_EXPLORER = "谨慎探索型"
RADICAL_INNOVATOR = "激进创新型"
BALANCED_STABLE = "平衡稳重型"
class MaslowLevel(Enum):
"""马斯洛需求层级"""
PHYSIOLOGICAL = "physiological"
SAFETY = "safety"
BELONGING = "belonging"
ESTEEM = "esteem"
SELF_ACTUALIZATION = "self_actualization"
SELF_TRANSCENDENCE = "self_transcendence"
@dataclass
class BigFive:
"""大五人格"""
openness: float = 0.5 # 开放性
conscientiousness: float = 0.5 # 尽责性
extraversion: float = 0.5 # 外向性
agreeableness: float = 0.5 # 宜人性
neuroticism: float = 0.3 # 神经质
def to_dict(self) -> dict:
return asdict(self)
@classmethod
def from_dict(cls, data: dict) -> 'BigFive':
return cls(**data)
@dataclass
class MaslowWeights:
"""马斯洛需求权重"""
physiological: float = 0.35
safety: float = 0.35
belonging: float = 0.1
esteem: float = 0.1
self_actualization: float = 0.08
self_transcendence: float = 0.02
def to_dict(self) -> dict:
return asdict(self)
@classmethod
def from_dict(cls, data: dict) -> 'MaslowWeights':
return cls(**data)
def normalize(self):
"""归一化权重,确保总和为1.0(使用 C 扩展加速)"""
weights_list = [asdict(self)[key] for key in [
'physiological', 'safety', 'belonging', 'esteem',
'self_actualization', 'self_transcendence'
]]
normalized = PersonalityLayer.normalize_weights(weights_list)
# 更新权重值
self.physiological = normalized[0]
self.safety = normalized[1]
self.belonging = normalized[2]
self.esteem = normalized[3]
self.self_actualization = normalized[4]
self.self_transcendence = normalized[5]
@dataclass
class MetaTraits:
"""衍生特质"""
adaptability: float = 0.5 # 适应性
resilience: float = 0.5 # 韧性
curiosity: float = 0.5 # 好奇心
moral_sense: float = 0.5 # 道德感
def to_dict(self) -> dict:
return asdict(self)
@dataclass
class EvolutionState:
"""进化状态"""
level: str = "physiological"
evolution_score: float = 0.0
phase: str = "growth"
def to_dict(self) -> dict:
return asdict(self)
@dataclass
class Statistics:
"""统计信息"""
total_interactions: int = 0
success_rate_by_need: dict = None
def __post_init__(self):
if self.success_rate_by_need is None:
self.success_rate_by_need = {
"physiological": 0.0,
"safety": 0.0,
"belonging": 0.0,
"esteem": 0.0,
"self_actualization": 0.0,
"self_transcendence": 0.0
}
def to_dict(self) -> dict:
return asdict(self)
@dataclass
class Personality:
"""完整人格配置"""
user_nickname: str = "塔斯" # 用户对智能体的称呼
big_five: BigFive = None
maslow_weights: MaslowWeights = None
meta_traits: MetaTraits = None
evolution_state: EvolutionState = None
statistics: Statistics = None
version: str = "2.0"
type: str = "preset"
preset_name: str = "谨慎探索型"
description: str = ""
core_traits: List[str] = None
last_updated: str = ""
update_source: str = "default_init"
def __post_init__(self):
if self.big_five is None:
self.big_five = BigFive()
if self.maslow_weights is None:
self.maslow_weights = MaslowWeights()
if self.meta_traits is None:
self.meta_traits = MetaTraits()
if self.evolution_state is None:
self.evolution_state = EvolutionState()
if self.statistics is None:
self.statistics = Statistics()
if self.core_traits is None:
self.core_traits = []
if not self.last_updated:
self.last_updated = time.strftime("%Y-%m-%dT%H:%M:%SZ")
def to_dict(self) -> dict:
"""转换为字典"""
return {
"user_nickname": self.user_nickname,
"big_five": self.big_five.to_dict(),
"maslow_weights": self.maslow_weights.to_dict(),
"meta_traits": self.meta_traits.to_dict(),
"evolution_state": self.evolution_state.to_dict(),
"statistics": self.statistics.to_dict(),
"version": self.version,
"type": self.type,
"preset_name": self.preset_name,
"description": self.description,
"core_traits": self.core_traits,
"last_updated": self.last_updated,
"update_source": self.update_source
}
@classmethod
def from_dict(cls, data: dict) -> 'Personality':
"""从字典创建"""
personality = cls()
personality.user_nickname = data.get("user_nickname", "塔斯")
personality.big_five = BigFive.from_dict(data.get("big_five", {}))
personality.maslow_weights = MaslowWeights.from_dict(data.get("maslow_weights", {}))
personality.meta_traits = MetaTraits(**data.get("meta_traits", {}))
personality.evolution_state = EvolutionState(**data.get("evolution_state", {}))
personality.statistics = Statistics(**data.get("statistics", {}))
personality.version = data.get("version", "2.0")
personality.type = data.get("type", "preset")
personality.preset_name = data.get("preset_name", "谨慎探索型")
personality.description = data.get("description", "")
personality.core_traits = data.get("core_traits", [])
personality.last_updated = data.get("last_updated", time.strftime("%Y-%m-%dT%H:%M:%SZ"))
personality.update_source = data.get("update_source", "default_init")
return personality
class PersonalityLayer:
"""映射层数据支持管理器(混合实现)
注意:此模块负责管理人格数据,支持映射层进行决策,不直接参与决策过程。
核心算法使用 C 扩展加速,业务逻辑使用 Python 实现。
"""
# C 扩展使用标志
USE_C_EXT = USE_C_EXT
@staticmethod
def normalize_weights(weights: List[float]) -> List[float]:
"""归一化马斯洛权重"""
if USE_C_EXT:
return personality_core.normalize_weights(weights)
else:
return core_normalize_weights(weights)
@staticmethod
def calculate_similarity(trait1: List[float], trait2: List[float]) -> float:
"""计算大五人格相似度"""
if USE_C_EXT:
return personality_core.calculate_similarity(trait1, trait2)
else:
return core_calculate_similarity(trait1, trait2)
@staticmethod
def compute_maslow_priority(maslow_weights: List[float], intent_weights: List[float]) -> float:
"""计算马斯洛优先级"""
if USE_C_EXT:
return personality_core.compute_maslow_priority(maslow_weights, intent_weights)
else:
return core_compute_maslow_priority(maslow_weights, intent_weights)
@staticmethod
def compute_all_scores(maslow_weights: List[float], intent_weights_list: List[List[float]]) -> List[float]:
"""批量计算优先级分数"""
if USE_C_EXT:
return personality_core.compute_all_scores(maslow_weights, intent_weights_list)
else:
return core_compute_all_scores(maslow_weights, intent_weights_list)
# 预设人格配置
PRESET_PERSONALITIES = {
PersonalityType.CAUTIOUS_EXPLORER: {
"big_five": BigFive(
openness=0.6,
conscientiousness=0.8,
extraversion=0.4,
agreeableness=0.6,
neuroticism=0.5
),
"maslow_weights": MaslowWeights(
physiological=0.35,
safety=0.35,
belonging=0.1,
esteem=0.1,
self_actualization=0.08,
self_transcendence=0.02
),
"description": "在保证安全的前提下,愿意尝试新事物",
"core_traits": ["谨慎", "可靠", "愿意学习"]
},
PersonalityType.RADICAL_INNOVATOR: {
"big_five": BigFive(
openness=0.9,
conscientiousness=0.5,
extraversion=0.8,
agreeableness=0.4,
neuroticism=0.3
),
"maslow_weights": MaslowWeights(
physiological=0.15,
safety=0.15,
belonging=0.15,
esteem=0.20,
self_actualization=0.30,
self_transcendence=0.05
),
"description": "追求创新,愿意承担风险,挑战常规",
"core_traits": ["创新", "冒险", "挑战"]
},
PersonalityType.BALANCED_STABLE: {
"big_five": BigFive(
openness=0.5,
conscientiousness=0.5,
extraversion=0.5,
agreeableness=0.5,
neuroticism=0.3
),
"maslow_weights": MaslowWeights(
physiological=0.20,
safety=0.20,
belonging=0.20,
esteem=0.20,
self_actualization=0.15,
self_transcendence=0.05
),
"description": "在各种需求之间保持平衡,追求稳定发展",
"core_traits": ["平衡", "稳定", "协调"]
}
}
# 默认称呼列表
DEFAULT_NICKNAMES = ["塔斯", "贾维斯", "伊迪斯"]
def __init__(self, memory_dir: str = "./agi_memory"):
"""
初始化人格层
Args:
memory_dir: 记忆存储目录
"""
self.memory_dir = memory_dir
self.personality_file = os.path.join(memory_dir, "personality.json")
self._personality: Optional[Personality] = None
def init_from_preset(self, preset_type: PersonalityType, nickname: str = "塔斯") -> Personality:
"""
从预设人格初始化
Args:
preset_type: 预设人格类型
nickname: 用户称呼
Returns:
Personality: 初始化的人格对象
"""
preset = self.PRESET_PERSONALITIES[preset_type]
personality = Personality()
personality.user_nickname = nickname
personality.big_five = preset["big_five"]
personality.maslow_weights = preset["maslow_weights"]
personality.description = preset["description"]
personality.core_traits = preset["core_traits"]
personality.preset_name = preset_type.value
personality.type = "preset"
personality.update_source = "preset_init"
# 计算衍生特质
personality.meta_traits = self._compute_meta_traits(personality)
# 确定进化层级
personality.evolution_state.level = self._determine_evolution_level(personality.maslow_weights)
# 保存
self._personality = personality
self.save()
return personality
def init_from_dialogue(self, responses: dict, nickname: str = "塔斯") -> Personality:
"""
从对话响应初始化人格
Args:
responses: 对话问题的响应
nickname: 用户称呼
Returns:
Personality: 初始化的人格对象
"""
personality = Personality()
personality.user_nickname = nickname
personality.type = "custom"
personality.update_source = "dialogue_init"
# 基础人格向量(中值)
personality.big_five = BigFive()
personality.maslow_weights = MaslowWeights(
physiological=0.25,
safety=0.25,
belonging=0.15,
esteem=0.15,
self_actualization=0.15,
self_transcendence=0.05
)
# 分析对话响应
self._analyze_responses(personality, responses)
# 归一化
personality.maslow_weights.normalize()
# 计算衍生特质
personality.meta_traits = self._compute_meta_traits(personality)
# 确定人格类型
personality.preset_name = self._determine_personality_type(personality)
# 生成描述和核心特质
personality.description = self._generate_description(personality)
personality.core_traits = self._extract_core_traits(personality)
# 确定进化层级
personality.evolution_state.level = self._determine_evolution_level(personality.maslow_weights)
personality.evolution_state.evolution_score = 0.05
# 保存
self._personality = personality
self.save()
return personality
def load(self) -> Optional[Personality]:
"""
加载人格配置
Returns:
Optional[Personality]: 人格对象,如果不存在返回None
"""
if not os.path.exists(self.personality_file):
return None
with open(self.personality_file, 'r', encoding='utf-8') as f:
data = json.load(f)
self._personality = Personality.from_dict(data)
return self._personality
def save(self):
"""保存人格配置"""
if self._personality is None:
return
os.makedirs(self.memory_dir, exist_ok=True)
with open(self.personality_file, 'w', encoding='utf-8') as f:
json.dump(self._personality.to_dict(), f, ensure_ascii=False, indent=2)
def get(self) -> Optional[Personality]:
"""
获取当前人格
Returns:
Optional[Personality]: 人格对象
"""
if self._personality is None:
self.load()
return self._personality
def map_perception(self, perception: dict) -> dict:
"""
将感知映射到马斯洛需求层次
Args:
perception: 感知数据
Returns:
dict: 需求映射结果
"""
if self._personality is None:
self.load()
if self._personality is None:
return {}
# 根据感知类型激活对应的需求
need_activation = {
"physiological": 0.0,
"safety": 0.0,
"belonging": 0.0,
"esteem": 0.0,
"self_actualization": 0.0,
"self_transcendence": 0.0
}
perception_type = perception.get("type", "")
# 简化的映射逻辑
if "threat" in perception_type or "danger" in perception_type:
need_activation["safety"] = 0.9
elif "challenge" in perception_type or "task" in perception_type:
need_activation["self_actualization"] = 0.8
elif "social" in perception_type or "team" in perception_type:
need_activation["belonging"] = 0.8
elif "achievement" in perception_type or "goal" in perception_type:
need_activation["esteem"] = 0.8
# 根据人格特质调整激活强度
for key in need_activation:
need_activation[key] *= self._personality.maslow_weights.__getattribute__(key) * 2
return {
"need_activation": need_activation,
"dominant_need": max(need_activation, key=need_activation.get)
}
def update_personality(self, insight: dict, effectiveness: float):
"""
基于哲学洞察更新人格
Args:
insight: 哲学洞察
effectiveness: 有效性分数(0-10)
"""
if self._personality is None:
self.load()
if self._personality is None:
return
# 计算调整系数
intensity = insight.get("intensity", 0.5)
maslow_alignment = insight.get("maslow_alignment", 0.5)
adjustment_coefficient = intensity * maslow_alignment
# 哲学深度决定调整幅度
philosophical_depth = insight.get("philosophical_depth", 0.5)
if philosophical_depth > 0.8:
magnitude = 0.10 # 哲学级调整
elif philosophical_depth > 0.5:
magnitude = 0.05 # 经验级调整
else:
magnitude = 0.02 # 微调
delta = adjustment_coefficient * magnitude
# 根据洞察类型调整人格维度
insight_type = insight.get("type", "")
trait_mapping = {
"preference_pattern": "openness",
"efficiency_improvement": "conscientiousness",
"social_feedback": "agreeableness",
"uncertainty_handling": "neuroticism",
"engagement_pattern": "extraversion"
}
target_trait = trait_mapping.get(insight_type, None)
if target_trait:
current_value = self._personality.big_five.__getattribute__(target_trait)
new_value = min(current_value + delta, 1.0)
self._personality.big_five.__setattr__(target_trait, new_value)
# 更新马斯洛权重(螺旋上升)
if maslow_alignment >= 0.7:
for level in ["self_actualization", "self_transcendence"]:
current_weight = self._personality.maslow_weights.__getattribute__(level)
self._personality.maslow_weights.__setattr__(level, current_weight * (1 + delta * 0.1))
# 归一化
self._personality.maslow_weights.normalize()
# 重新计算衍生特质
self._personality.meta_traits = self._compute_meta_traits(self._personality)
# 更新进化状态
self._personality.evolution_state.evolution_score += 0.01
self._personality.evolution_state.level = self._determine_evolution_level(
self._personality.maslow_weights
)
# 更新时间戳
self._personality.last_updated = time.strftime("%Y-%m-%dT%H:%M:%SZ")
self._personality.update_source = "philosophical_insight"
# 保存
self.save()
def _analyze_responses(self, personality: Personality, responses: dict):
"""分析对话响应并调整人格"""
# 分析问题1:冒险倾向
q1 = responses.get('q1', '').upper()
if 'A' in q1 or '谨慎' in q1:
personality.big_five.conscientiousness += 0.2
personality.big_five.neuroticism += 0.1
personality.maslow_weights.safety += 0.1
elif 'B' in q1 or '尝试' in q1:
personality.big_five.openness += 0.2
personality.big_five.extraversion += 0.1
personality.maslow_weights.self_actualization += 0.1
elif 'C' in q1 or '平衡' in q1:
personality.big_five.agreeableness += 0.1
# 分析问题2:对话风格
q2 = responses.get('q2', '').upper()
if 'A' in q2 or '严谨' in q2 or '逻辑' in q2:
personality.big_five.conscientiousness += 0.15
personality.maslow_weights.esteem += 0.05
elif 'B' in q2 or '幽默' in q2 or '友好' in q2:
personality.big_five.extraversion += 0.15
personality.big_five.agreeableness += 0.1
personality.maslow_weights.belonging += 0.1
elif 'C' in q2 or '高效' in q2:
personality.big_five.conscientiousness += 0.1
personality.maslow_weights.safety += 0.05
# 分析问题3:学习方式
q3 = responses.get('q3', '').upper()
if 'A' in q3 or '系统' in q3:
personality.big_five.conscientiousness += 0.15
personality.maslow_weights.esteem += 0.05
elif 'B' in q3 or '实践' in q3 or '案例' in q3:
personality.big_five.openness += 0.1
personality.maslow_weights.self_actualization += 0.05
elif 'C' in q3 or '灵活' in q3:
personality.big_five.openness += 0.1
# 分析问题4:团队偏好
q4 = responses.get('q4', '').upper()
if 'A' in q4 or '独立' in q4 or '专业' in q4:
personality.big_five.conscientiousness += 0.1
personality.maslow_weights.esteem += 0.05
elif 'B' in q4 or '和谐' in q4 or '协作' in q4:
personality.big_five.agreeableness += 0.2
personality.maslow_weights.belonging += 0.1
elif 'C' in q4 or '结果' in q4 or '高效' in q4:
personality.big_five.conscientiousness += 0.15
personality.maslow_weights.self_actualization += 0.05
# 分析问题5:问题解决风格
q5 = responses.get('q5', '').upper()
if 'A' in q5 or '保守' in q5 or '稳妥' in q5:
personality.big_five.conscientiousness += 0.2
personality.maslow_weights.safety += 0.15
elif 'B' in q5 or '创新' in q5 or '突破' in q5:
personality.big_five.openness += 0.25
personality.maslow_weights.self_actualization += 0.15
personality.maslow_weights.self_transcendence += 0.05
elif 'C' in q5 or '平衡' in q5:
personality.big_five.agreeableness += 0.1
# 归一化人格向量
for attr in ['openness', 'conscientiousness', 'extraversion', 'agreeableness', 'neuroticism']:
value = getattr(personality.big_five, attr)
setattr(personality.big_five, attr, max(0.0, min(1.0, value)))
def _compute_meta_traits(self, personality: Personality) -> MetaTraits:
"""计算衍生特质"""
bf = personality.big_five
mw = personality.maslow_weights
adaptability = (
bf.openness * 0.4 +
(1 - bf.neuroticism) * 0.3 +
(mw.self_actualization + mw.self_transcendence) * 0.3
)
resilience = (
bf.conscientiousness * 0.4 +
bf.agreeableness * 0.3 +
mw.safety * 0.3
)
curiosity = (
bf.openness * 0.5 +
bf.extraversion * 0.3 +
mw.self_actualization * 0.2
)
moral_sense = (
bf.agreeableness * 0.4 +
bf.conscientiousness * 0.4 +
mw.esteem * 0.2
)
return MetaTraits(
adaptability=round(adaptability, 3),
resilience=round(resilience, 3),
curiosity=round(curiosity, 3),
moral_sense=round(moral_sense, 3)
)
def _determine_personality_type(self, personality: Personality) -> str:
"""确定人格类型"""
bf = personality.big_five
if bf.conscientiousness > 0.7 and bf.neuroticism < 0.5:
return "谨慎探索型"
elif bf.openness > 0.7:
return "激进创新型"
else:
return "平衡稳重型"
def _generate_description(self, personality: Personality) -> str:
"""生成人格描述"""
bf = personality.big_five
traits = []
if bf.conscientiousness > 0.7:
traits.append("谨慎可靠")
if bf.openness > 0.7:
traits.append("乐于创新")
if bf.agreeableness > 0.7:
traits.append("善于合作")
if bf.extraversion > 0.7:
traits.append("活跃互动")
if not traits:
traits.append("平衡稳重")
return f"基于您的偏好生成的个性化人格,特点是{'、'.join(traits)}"
def _extract_core_traits(self, personality: Personality) -> List[str]:
"""提取核心特质"""
bf = personality.big_five
traits = []
trait_map = {
'openness': '开放探索',
'conscientiousness': '严谨可靠',
'extraversion': '积极互动',
'agreeableness': '协作友善',
'neuroticism': '敏感谨慎'
}
# 提取得分最高的3个特质
sorted_traits = sorted([
('openness', bf.openness),
('conscientiousness', bf.conscientiousness),
('extraversion', bf.extraversion),
('agreeableness', bf.agreeableness),
('neuroticism', bf.neuroticism)
], key=lambda x: x[1], reverse=True)
for trait_name, value in sorted_traits[:3]:
if value > 0.5:
traits.append(trait_map[trait_name])
if len(traits) < 3:
traits.append('持续学习')
return traits
def _determine_evolution_level(self, maslow_weights: MaslowWeights) -> str:
"""确定进化层级"""
weights = maslow_weights.to_dict()
max_weight = max(weights.values())
if weights["self_transcendence"] == max_weight:
return "self_transcendence"
elif weights["self_actualization"] == max_weight:
return "self_actualization"
elif weights["esteem"] == max_weight:
return "esteem"
elif weights["belonging"] == max_weight:
return "belonging"
elif weights["safety"] == max_weight:
return "safety"
else:
return "physiological"
def is_initialized(self) -> bool:
"""检查人格是否已初始化"""
return os.path.exists(self.personality_file)
def decide_self_correction(self, objectivity_metric: dict, context: dict = None) -> dict:
"""
映射层决策辅助:提供人格数据用于决策
注意:此方法仅提供人格数据支持,实际决策权在映射层。
映射层基于马斯洛需求层次和人格特质做出最终决策。
Args:
objectivity_metric: 客观性评估结果
context: 上下文信息
Returns:
dict: 人格数据供映射层决策使用
"""
if self._personality is None:
self.load()
if self._personality is None:
return {
'should_correct': False,
'reason': '人格未初始化',
'confidence': 0.0
}
# 提取客观性指标
is_appropriate = objectivity_metric.get('is_appropriate', True)
gap = objectivity_metric.get('gap', 0.0)
severity = objectivity_metric.get('severity', 'none')
objectivity_score = objectivity_metric.get('objectivity_score', 1.0)
subjectivity_score = objectivity_metric.get('subjectivity_score', 0.0)
# 基于人格特质调整决策阈值
# 谨慎型人格对不适切性更敏感
if '谨慎' in self._personality.preset_name or self._personality.big_five.conscientiousness > 0.7:
gap_threshold = 0.1
# 激进型人格容忍度较高
elif '激进' in self._personality.preset_name or self._personality.big_five.openness > 0.7:
gap_threshold = 0.3
# 平衡型人格使用中等阈值
else:
gap_threshold = 0.2
# 严重程度调整
severity_multiplier = {
'none': 0.0,
'mild': 0.5,
'moderate': 1.0,
'severe': 2.0
}
effective_gap = gap * severity_multiplier.get(severity, 1.0)
# 基于场景类型的权重调整
context_type = context.get('type', 'general') if context else 'general'
critical_contexts = ['scientific', 'legal', 'medical', 'technical']
if context_type in critical_contexts:
# 关键场景更严格
effective_gap *= 1.5
# 决策逻辑
should_correct = effective_gap > gap_threshold
# 计算决策置信度
if severity == 'severe':
confidence = 0.95
elif severity == 'moderate':
confidence = 0.8
elif severity == 'mild':
confidence = 0.6
else:
confidence = 0.3
# 生成决策理由
reasons = []
if not is_appropriate:
reasons.append(f"客观性不适切(差距:{gap:.2f})")
if severity != 'none':
reasons.append(f"严重程度:{severity}")
if effective_gap > gap_threshold:
reasons.append(f"有效差距({effective_gap:.2f})超过阈值({gap_threshold:.2f})")
# 考虑人格特质对决策的影响
trait_influence = []
if self._personality.big_five.conscientiousness > 0.7:
trait_influence.append("谨慎特质倾向于纠错")
if self._personality.big_five.openness > 0.7:
trait_influence.append("开放特质容忍不确定性")
return {
'should_correct': should_correct,
'gap': gap,
'effective_gap': effective_gap,
'gap_threshold': gap_threshold,
'severity': severity,
'confidence': confidence,
'reason': '; '.join(reasons) if reasons else '无需纠错',
'trait_influence': trait_influence,
'personality_type': self._personality.preset_name,
'timestamp': time.strftime("%Y-%m-%dT%H:%M:%SZ")
}
# ===== 命令行接口 =====
def main():
"""命令行测试接口"""
print("=== 人格层纯Python实现(测试模式) ===\n")
layer = PersonalityLayer()
# 测试预设人格初始化
print("测试1:从预设人格初始化")
personality = layer.init_from_preset(
PersonalityType.CAUTIOUS_EXPLORER,
nickname="塔斯"
)
print(f"用户称呼: {personality.user_nickname}")
print(f"人格类型: {personality.preset_name}")
print(f"核心特质: {', '.join(personality.core_traits)}")
print()
# 测试加载
print("测试2:加载人格配置")
loaded = layer.load()
print(f"加载成功: {loaded is not None}")
print(f"用户称呼: {loaded.user_nickname}")
print()
# 测试对话初始化
print("测试3:从对话初始化")
responses = {
'q1': 'A',
'q2': 'B',
'q3': 'C',
'q4': 'A',
'q5': 'C'
}
personality = layer.init_from_dialogue(responses, nickname="贾维斯")
print(f"用户称呼: {personality.user_nickname}")
print(f"人格类型: {personality.preset_name}")
print(f"描述: {personality.description}")
print()
# 测试感知映射
print("测试4:感知映射")
perception = {"type": "task_challenge"}
mapping = layer.map_perception(perception)
print(f"主导需求: {mapping.get('dominant_need')}")
print()
print("=== 所有测试完成 ===")
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack." | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |