gardel/Mofox-Core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/main-fix' into main-fix

Browse Source 
# Conflicts:
#	src/plugins/personality/big5_test.py
#	src/plugins/personality/combined_test.py
#	src/plugins/personality/questionnaire.py
#	src/plugins/personality/renqingziji.py
#	src/plugins/personality/scene.py
This commit is contained in:
DrSmoothl
2025-03-21 17:28:08 +08:00
parent 82e7cf7a32 341ab99770
commit 5195e7baf1
28 changed files with 1042 additions and 1810 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
bot.py
View File

@@ -221,7 +221,9 @@ def check_eula():
# 如果EULA或隐私条款有更新，提示用户重新确认
if eula_updated or privacy_updated:
print("EULA或隐私条款内容已更新，请在阅读后重新确认，继续运行视为同意更新后的以上两款协议")
print(f'输入"同意"或"confirmed"或设置环境变量"EULA_AGREE={eula_new_hash}"和"PRIVACY_AGREE={privacy_new_hash}"继续运行')
print(
f'输入"同意"或"confirmed"或设置环境变量"EULA_AGREE={eula_new_hash}"和"PRIVACY_AGREE={privacy_new_hash}"继续运行'
)
while True:
user_input = input().strip().lower()
if user_input in ["同意", "confirmed"]:

2
docs/installation_cute.md
View File

@@ -147,9 +147,7 @@ enable_check = false # 是否要检查表情包是不是合适的喵
check_prompt = "符合公序良俗" # 检查表情包的标准呢
[others]
enable_advance_output = true # 是否要显示更多的运行信息呢
enable_kuuki_read = true # 让机器人能够"察言观色"喵
enable_debug_output = false # 是否启用调试输出喵
enable_friend_chat = false # 是否启用好友聊天喵
[groups]

2
docs/installation_standard.md
View File

@@ -115,9 +115,7 @@ talk_frequency_down = [] # 降低回复频率的群号
ban_user_id = [] # 禁止回复的用户QQ号
[others]
enable_advance_output = true # 是否启用高级输出
enable_kuuki_read = true # 是否启用读空气功能
enable_debug_output = false # 是否启用调试输出
enable_friend_chat = false # 是否启用好友聊天
# 模型配置

2
docs/linux_deploy_guide_for_beginners.md
View File

@@ -320,7 +320,7 @@ sudo systemctl enable bot.service # 启动bot服务
sudo systemctl status bot.service # 检查bot服务状态
```
```python
```bash
python bot.py # 运行麦麦
```

BIN
requirements.txt
View File

Binary file not shown.

20
src/common/logger.py
View File

@@ -31,9 +31,10 @@ _handler_registry: Dict[str, List[int]] = {}
current_file_path = Path(__file__).resolve()
LOG_ROOT = "logs"
ENABLE_ADVANCE_OUTPUT = False
SIMPLE_OUTPUT = os.getenv("SIMPLE_OUTPUT", "false")
print(f"SIMPLE_OUTPUT: {SIMPLE_OUTPUT}")
if ENABLE_ADVANCE_OUTPUT:
if not SIMPLE_OUTPUT:
# 默认全局配置
DEFAULT_CONFIG = {
# 日志级别配置
@@ -85,7 +86,6 @@ MEMORY_STYLE_CONFIG = {
},
}
# 海马体日志样式配置
SENDER_STYLE_CONFIG = {
"advanced": {
"console_format": (
@@ -152,17 +152,17 @@ CHAT_STYLE_CONFIG = {
"file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}"),
},
"simple": {
"console_format": ("<green>{time:MM-DD HH:mm}</green> | <light-blue>见闻</light-blue> | {message}"),
"console_format": ("<green>{time:MM-DD HH:mm}</green> | <light-blue>见闻</light-blue> | <green>{message}</green>"), # noqa: E501
"file_format": ("{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {extra[module]: <15} | 见闻 | {message}"),
},
}
# 根据ENABLE_ADVANCE_OUTPUT选择配置
MEMORY_STYLE_CONFIG = MEMORY_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else MEMORY_STYLE_CONFIG["simple"]
TOPIC_STYLE_CONFIG = TOPIC_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else TOPIC_STYLE_CONFIG["simple"]
SENDER_STYLE_CONFIG = SENDER_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else SENDER_STYLE_CONFIG["simple"]
LLM_STYLE_CONFIG = LLM_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else LLM_STYLE_CONFIG["simple"]
CHAT_STYLE_CONFIG = CHAT_STYLE_CONFIG["advanced"] if ENABLE_ADVANCE_OUTPUT else CHAT_STYLE_CONFIG["simple"]
# 根据SIMPLE_OUTPUT选择配置
MEMORY_STYLE_CONFIG = MEMORY_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else MEMORY_STYLE_CONFIG["advanced"]
TOPIC_STYLE_CONFIG = TOPIC_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else TOPIC_STYLE_CONFIG["advanced"]
SENDER_STYLE_CONFIG = SENDER_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else SENDER_STYLE_CONFIG["advanced"]
LLM_STYLE_CONFIG = LLM_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else LLM_STYLE_CONFIG["advanced"]
CHAT_STYLE_CONFIG = CHAT_STYLE_CONFIG["simple"] if SIMPLE_OUTPUT else CHAT_STYLE_CONFIG["advanced"]
def is_registered_module(record: dict) -> bool:

3
src/plugins/chat/__init__.py
View File

@@ -98,6 +98,7 @@ async def _(bot: Bot, event: MessageEvent, state: T_State):
else:
await chat_bot.handle_message(event, bot)
@notice_matcher.handle()
async def _(bot: Bot, event: NoticeEvent, state: T_State):
logger.debug(f"收到通知：{event}")
@@ -110,7 +111,7 @@ async def build_memory_task():
"""每build_memory_interval秒执行一次记忆构建"""
logger.debug("[记忆构建]------------------------------------开始构建记忆--------------------------------------")
start_time = time.time()
await hippocampus.operation_build_memory(chat_size=20)
await hippocampus.operation_build_memory()
end_time = time.time()
logger.success(
f"[记忆构建]--------------------------记忆构建完成：耗时: {end_time - start_time:.2f} "

10
src/plugins/chat/bot.py
View File

@@ -154,7 +154,7 @@ class ChatBot:
)
# 开始思考的时间点
thinking_time_point = round(time.time(), 2)
logger.info(f"开始思考的时间点: {thinking_time_point}")
# logger.debug(f"开始思考的时间点: {thinking_time_point}")
think_id = "mt" + str(thinking_time_point)
thinking_message = MessageThinking(
message_id=think_id,
@@ -424,7 +424,6 @@ class ChatBot:
if event.group_id not in global_config.talk_allowed_groups:
return
# 获取合并转发消息的详细信息
forward_info = await bot.get_forward_msg(message_id=event.message_id)
messages = forward_info["messages"]
@@ -456,11 +455,7 @@ class ChatBot:
# 构建群聊信息（如果是群聊）
group_info = None
if isinstance(event, GroupMessageEvent):
group_info = GroupInfo(
group_id=event.group_id,
group_name=None,
platform="qq"
)
group_info = GroupInfo(group_id=event.group_id, group_name=None, platform="qq")
# 创建消息对象
message_cq = MessageRecvCQ(
@@ -512,5 +507,6 @@ class ChatBot:
else:
return f"[{seg_type}]"
# 创建全局ChatBot实例
chat_bot = ChatBot()

27
src/plugins/chat/config.py
View File

@@ -68,9 +68,9 @@ class BotConfig:
MODEL_V3_PROBABILITY: float = 0.1 # V3模型概率
MODEL_R1_DISTILL_PROBABILITY: float = 0.1 # R1蒸馏模型概率
enable_advance_output: bool = False # 是否启用高级输出
# enable_advance_output: bool = False # 是否启用高级输出
enable_kuuki_read: bool = True # 是否启用读空气功能
enable_debug_output: bool = False # 是否启用调试输出
# enable_debug_output: bool = False # 是否启用调试输出
enable_friend_chat: bool = False # 是否启用好友聊天
mood_update_interval: float = 1.0 # 情绪更新间隔 单位秒
@@ -106,6 +106,11 @@ class BotConfig:
memory_forget_time: int = 24 # 记忆遗忘时间（小时）
memory_forget_percentage: float = 0.01 # 记忆遗忘比例
memory_compress_rate: float = 0.1 # 记忆压缩率
build_memory_sample_num: int = 10 # 记忆构建采样数量
build_memory_sample_length: int = 20 # 记忆构建采样长度
memory_build_distribution: list = field(
default_factory=lambda: [4,2,0.6,24,8,0.4]
) # 记忆构建分布，参数：分布1均值，标准差，权重，分布2均值，标准差，权重
memory_ban_words: list = field(
default_factory=lambda: ["表情包", "图片", "回复", "聊天记录"]
) # 添加新的配置项默认值
@@ -315,6 +320,20 @@ class BotConfig:
"memory_forget_percentage", config.memory_forget_percentage
)
config.memory_compress_rate = memory_config.get("memory_compress_rate", config.memory_compress_rate)
if config.INNER_VERSION in SpecifierSet(">=0.0.11"):
config.memory_build_distribution = memory_config.get(
"memory_build_distribution",
config.memory_build_distribution
)
config.build_memory_sample_num = memory_config.get(
"build_memory_sample_num",
config.build_memory_sample_num
)
config.build_memory_sample_length = memory_config.get(
"build_memory_sample_length",
config.build_memory_sample_length
)
def remote(parent: dict):
remote_config = parent["remote"]
@@ -351,10 +370,10 @@ class BotConfig:
def others(parent: dict):
others_config = parent["others"]
config.enable_advance_output = others_config.get("enable_advance_output", config.enable_advance_output)
# config.enable_advance_output = others_config.get("enable_advance_output", config.enable_advance_output)
config.enable_kuuki_read = others_config.get("enable_kuuki_read", config.enable_kuuki_read)
if config.INNER_VERSION in SpecifierSet(">=0.0.7"):
config.enable_debug_output = others_config.get("enable_debug_output", config.enable_debug_output)
# config.enable_debug_output = others_config.get("enable_debug_output", config.enable_debug_output)
config.enable_friend_chat = others_config.get("enable_friend_chat", config.enable_friend_chat)
# 版本表达式：>=1.0.0,<2.0.0

2
src/plugins/chat/message_sender.py
View File

@@ -220,7 +220,7 @@ class MessageManager:
message_timeout = container.get_timeout_messages()
if message_timeout:
logger.warning(f"发现{len(message_timeout)}条超时消息")
logger.debug(f"发现{len(message_timeout)}条超时消息")
for msg in message_timeout:
if msg == message_earliest:
continue

26
src/plugins/chat/prompt_builder.py
View File

@@ -141,21 +141,21 @@ class PromptBuilder:
logger.debug(f"知识检索耗时: {(end_time - start_time):.3f}秒")
prompt = f"""
今天是{current_date}，现在是{current_time}，你今天的日程是：\
`<schedule>`\n
{bot_schedule.today_schedule}\n
`</schedule>`\n
{prompt_info}\n
{memory_prompt}\n
{chat_target}\n
{chat_talking_prompt}\n
现在"{sender_name}"说的:\n
`<UserMessage>`\n
{message_txt}\n
`</UserMessage>`\n
今天是{current_date}，现在是{current_time}，你今天的日程是：
`<schedule>`
{bot_schedule.today_schedule}
`</schedule>`
{prompt_info}
{memory_prompt}
{chat_target}
{chat_talking_prompt}
现在"{sender_name}"说的:
`<UserMessage>`
{message_txt}
`</UserMessage>`
引起了你的注意,{relation_prompt_all}{mood_prompt}\n
`<MainRule>`
你的网名叫{global_config.BOT_NICKNAME}，{prompt_personality}。
你的网名叫{global_config.BOT_NICKNAME}，有人也叫你{"/".join(global_config.BOT_ALIAS_NAMES)}，{prompt_personality},{prompt_personality}。
正在{bot_schedule_now_activity}的你同时也在一边{chat_target_2},现在请你读读之前的聊天记录，然后给出日常且口语化的回复，平淡一些，
尽量简短一些。{keywords_reaction_prompt}请注意把握聊天内容，不要刻意突出自身学科背景，不要回复的太有条理，可以有个性。
{prompt_ger}

17
src/plugins/chat/utils.py
View File

@@ -76,18 +76,11 @@ def calculate_information_content(text):
def get_closest_chat_from_db(length: int, timestamp: str):
"""从数据库中获取最接近指定时间戳的聊天记录
Args:
length: 要获取的消息数量
timestamp: 时间戳
Returns:
list: 消息记录列表，每个记录包含时间和文本信息
"""
# print(f"获取最接近指定时间戳的聊天记录，长度: {length}, 时间戳: {timestamp}")
# print(f"当前时间: {timestamp},转换后时间: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timestamp))}")
chat_records = []
closest_record = db.messages.find_one({"time": {"$lte": timestamp}}, sort=[("time", -1)])
# print(f"最接近的记录: {closest_record}")
if closest_record:
closest_time = closest_record["time"]
chat_id = closest_record["chat_id"] # 获取chat_id
@@ -102,7 +95,9 @@ def get_closest_chat_from_db(length: int, timestamp: str):
.sort("time", 1)
.limit(length)
)
# print(f"获取到的记录: {chat_records}")
length = len(chat_records)
# print(f"获取到的记录长度: {length}")
# 转换记录格式
formatted_records = []
for record in chat_records:

2
src/plugins/chat/utils_image.py
View File

@@ -112,7 +112,7 @@ class ImageManager:
# 查询缓存的描述
cached_description = self._get_description_from_db(image_hash, "emoji")
if cached_description:
logger.info(f"缓存表情包描述: {cached_description}")
logger.debug(f"缓存表情包描述: {cached_description}")
return f"[表情包：{cached_description}]"
# 调用AI获取描述

148
src/plugins/memory_system/memory.py
View File

@@ -18,6 +18,7 @@ from ..chat.utils import (
)
from ..models.utils_model import LLM_request
from src.common.logger import get_module_logger, LogConfig, MEMORY_STYLE_CONFIG
from src.plugins.memory_system.sample_distribution import MemoryBuildScheduler
# 定义日志配置
memory_config = LogConfig(
@@ -25,6 +26,11 @@ memory_config = LogConfig(
console_format=MEMORY_STYLE_CONFIG["console_format"],
file_format=MEMORY_STYLE_CONFIG["file_format"],
)
# print(f"memory_config: {memory_config}")
# print(f"MEMORY_STYLE_CONFIG: {MEMORY_STYLE_CONFIG}")
# print(f"MEMORY_STYLE_CONFIG['console_format']: {MEMORY_STYLE_CONFIG['console_format']}")
# print(f"MEMORY_STYLE_CONFIG['file_format']: {MEMORY_STYLE_CONFIG['file_format']}")
logger = get_module_logger("memory_system", config=memory_config)
@@ -195,25 +201,17 @@ class Hippocampus:
return hash(f"{nodes[0]}:{nodes[1]}")
def random_get_msg_snippet(self, target_timestamp: float, chat_size: int, max_memorized_time_per_msg: int) -> list:
"""随机抽取一段时间内的消息片段
Args:
- target_timestamp: 目标时间戳
- chat_size: 抽取的消息数量
- max_memorized_time_per_msg: 每条消息的最大记忆次数
Returns:
- list: 抽取出的消息记录列表
"""
try_count = 0
# 最多尝试三次抽取
# 最多尝试2次抽取
while try_count < 3:
messages = get_closest_chat_from_db(length=chat_size, timestamp=target_timestamp)
if messages:
# print(f"抽取到的消息: {messages}")
# 检查messages是否均没有达到记忆次数限制
for message in messages:
if message["memorized_times"] >= max_memorized_time_per_msg:
messages = None
# print(f"抽取到的消息提取次数达到限制，跳过")
break
if messages:
# 成功抽取短期消息样本
@@ -224,63 +222,48 @@ class Hippocampus:
)
return messages
try_count += 1
# 三次尝试均失败
return None
def get_memory_sample(self, chat_size=20, time_frequency=None):
"""获取记忆样本
Returns:
list: 消息记录列表，每个元素是一个消息记录字典列表
"""
def get_memory_sample(self):
# 硬编码：每条消息最大记忆次数
# 如有需求可写入global_config
if time_frequency is None:
time_frequency = {"near": 2, "mid": 4, "far": 3}
max_memorized_time_per_msg = 3
current_timestamp = datetime.datetime.now().timestamp()
# 创建双峰分布的记忆调度器
scheduler = MemoryBuildScheduler(
n_hours1=global_config.memory_build_distribution[0], # 第一个分布均值（4小时前）
std_hours1=global_config.memory_build_distribution[1], # 第一个分布标准差
weight1=global_config.memory_build_distribution[2], # 第一个分布权重 60%
n_hours2=global_config.memory_build_distribution[3], # 第二个分布均值（24小时前）
std_hours2=global_config.memory_build_distribution[4], # 第二个分布标准差
weight2=global_config.memory_build_distribution[5], # 第二个分布权重 40%
total_samples=global_config.build_memory_sample_num # 总共生成10个时间点
)
# 生成时间戳数组
timestamps = scheduler.get_timestamp_array()
# logger.debug(f"生成的时间戳数组: {timestamps}")
# print(f"生成的时间戳数组: {timestamps}")
# print(f"时间戳的实际时间: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}")
logger.info(f"回忆往事: {[time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(ts)) for ts in timestamps]}")
chat_samples = []
# 短期：1h 中期：4h 长期：24h
logger.debug("正在抽取短期消息样本")
for i in range(time_frequency.get("near")):
random_time = current_timestamp - random.randint(1, 3600)
messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
for timestamp in timestamps:
messages = self.random_get_msg_snippet(
timestamp,
global_config.build_memory_sample_length,
max_memorized_time_per_msg
)
if messages:
logger.debug(f"成功抽取短期消息样本{len(messages)}条")
time_diff = (datetime.datetime.now().timestamp() - timestamp) / 3600
logger.debug(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条")
# print(f"成功抽取 {time_diff:.1f} 小时前的消息样本，共{len(messages)}条")
chat_samples.append(messages)
else:
logger.warning(f"第{i}次短期消息样本抽取失败")
logger.debug("正在抽取中期消息样本")
for i in range(time_frequency.get("mid")):
random_time = current_timestamp - random.randint(3600, 3600 * 4)
messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
if messages:
logger.debug(f"成功抽取中期消息样本{len(messages)}条")
chat_samples.append(messages)
else:
logger.warning(f"第{i}次中期消息样本抽取失败")
logger.debug("正在抽取长期消息样本")
for i in range(time_frequency.get("far")):
random_time = current_timestamp - random.randint(3600 * 4, 3600 * 24)
messages = self.random_get_msg_snippet(random_time, chat_size, max_memorized_time_per_msg)
if messages:
logger.debug(f"成功抽取长期消息样本{len(messages)}条")
chat_samples.append(messages)
else:
logger.warning(f"第{i}次长期消息样本抽取失败")
logger.debug(f"时间戳 {timestamp} 的消息样本抽取失败")
return chat_samples
async def memory_compress(self, messages: list, compress_rate=0.1):
"""压缩消息记录为记忆
Returns:
tuple: (压缩记忆集合, 相似主题字典)
"""
if not messages:
return set(), {}
@@ -313,15 +296,23 @@ class Hippocampus:
topics_response = await self.llm_topic_judge.generate_response(self.find_topic_llm(input_text, topic_num))
# 过滤topics
# 从配置文件获取需要过滤的关键词列表
filter_keywords = global_config.memory_ban_words
# 将topics_response[0]中的中文逗号、顿号、空格都替换成英文逗号
# 然后按逗号分割成列表,并去除每个topic前后的空白字符
topics = [
topic.strip()
for topic in topics_response[0].replace("，", ",").replace("、", ",").replace(" ", ",").split(",")
if topic.strip()
]
# 过滤掉包含禁用关键词的topic
# any()检查topic中是否包含任何一个filter_keywords中的关键词
# 只保留不包含禁用关键词的topic
filtered_topics = [topic for topic in topics if not any(keyword in topic for keyword in filter_keywords)]
logger.info(f"过滤后话题: {filtered_topics}")
logger.debug(f"过滤后话题: {filtered_topics}")
# 创建所有话题的请求任务
tasks = []
@@ -331,31 +322,42 @@ class Hippocampus:
tasks.append((topic.strip(), task))
# 等待所有任务完成
compressed_memory = set()
# 初始化压缩后的记忆集合和相似主题字典
compressed_memory = set() # 存储压缩后的(主题,内容)元组
similar_topics_dict = {} # 存储每个话题的相似主题列表
# 遍历每个主题及其对应的LLM任务
for topic, task in tasks:
response = await task
if response:
# 将主题和LLM生成的内容添加到压缩记忆中
compressed_memory.add((topic, response[0]))
# 为每个话题查找相似的已存在主题
# 为当前主题寻找相似的已存在主题
existing_topics = list(self.memory_graph.G.nodes())
similar_topics = []
# 计算当前主题与每个已存在主题的相似度
for existing_topic in existing_topics:
# 使用jieba分词,将主题转换为词集合
topic_words = set(jieba.cut(topic))
existing_words = set(jieba.cut(existing_topic))
all_words = topic_words | existing_words
v1 = [1 if word in topic_words else 0 for word in all_words]
v2 = [1 if word in existing_words else 0 for word in all_words]
# 构建词向量用于计算余弦相似度
all_words = topic_words | existing_words # 所有不重复的词
v1 = [1 if word in topic_words else 0 for word in all_words] # 当前主题的词向量
v2 = [1 if word in existing_words else 0 for word in all_words] # 已存在主题的词向量
# 计算余弦相似度
similarity = cosine_similarity(v1, v2)
if similarity >= 0.6:
# 如果相似度超过阈值,添加到相似主题列表
if similarity >= 0.7:
similar_topics.append((existing_topic, similarity))
# 按相似度降序排序,只保留前3个最相似的主题
similar_topics.sort(key=lambda x: x[1], reverse=True)
similar_topics = similar_topics[:5]
similar_topics = similar_topics[:3]
similar_topics_dict[topic] = similar_topics
return compressed_memory, similar_topics_dict
@@ -372,10 +374,10 @@ class Hippocampus:
)
return topic_num
async def operation_build_memory(self, chat_size=20):
time_frequency = {"near": 1, "mid": 4, "far": 4}
memory_samples = self.get_memory_sample(chat_size, time_frequency)
async def operation_build_memory(self):
memory_samples = self.get_memory_sample()
all_added_nodes = []
all_added_edges = []
for i, messages in enumerate(memory_samples, 1):
all_topics = []
# 加载进度可视化
@@ -387,12 +389,13 @@ class Hippocampus:
compress_rate = global_config.memory_compress_rate
compressed_memory, similar_topics_dict = await self.memory_compress(messages, compress_rate)
logger.info(f"压缩后记忆数量: {len(compressed_memory)}，似曾相识的话题: {len(similar_topics_dict)}")
logger.debug(f"压缩后记忆数量: {compressed_memory}，似曾相识的话题: {similar_topics_dict}")
current_time = datetime.datetime.now().timestamp()
logger.debug(f"添加节点: {', '.join(topic for topic, _ in compressed_memory)}")
all_added_nodes.extend(topic for topic, _ in compressed_memory)
for topic, memory in compressed_memory:
logger.info(f"添加节点: {topic}")
self.memory_graph.add_dot(topic, memory)
all_topics.append(topic)
@@ -402,7 +405,8 @@ class Hippocampus:
for similar_topic, similarity in similar_topics:
if topic != similar_topic:
strength = int(similarity * 10)
logger.info(f"连接相似节点: {topic} 和 {similar_topic} (强度: {strength})")
logger.debug(f"连接相似节点: {topic} 和 {similar_topic} (强度: {strength})")
all_added_edges.append(f"{topic}-{similar_topic}")
self.memory_graph.G.add_edge(
topic,
similar_topic,
@@ -414,9 +418,13 @@ class Hippocampus:
# 连接同批次的相关话题
for i in range(len(all_topics)):
for j in range(i + 1, len(all_topics)):
logger.info(f"连接同批次节点: {all_topics[i]} 和 {all_topics[j]}")
logger.debug(f"连接同批次节点: {all_topics[i]} 和 {all_topics[j]}")
all_added_edges.append(f"{all_topics[i]}-{all_topics[j]}")
self.memory_graph.connect_dot(all_topics[i], all_topics[j])
logger.success(f"更新记忆: {', '.join(all_added_nodes)}")
logger.success(f"强化连接: {', '.join(all_added_edges)}")
# logger.success(f"强化连接: {', '.join(all_added_edges)}")
self.sync_memory_to_db()
def sync_memory_to_db(self):

3
src/plugins/memory_system/memory_manual_build.py
View File

@@ -7,11 +7,9 @@ import sys
import time
from collections import Counter
from pathlib import Path
import matplotlib.pyplot as plt
import networkx as nx
from dotenv import load_dotenv
from src.common.logger import get_module_logger
import jieba
# from chat.config import global_config
@@ -19,6 +17,7 @@ import jieba
root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
sys.path.append(root_path)
from src.common.logger import get_module_logger # noqa: E402
from src.common.database import db # noqa E402
from src.plugins.memory_system.offline_llm import LLMModel # noqa E402

1185
src/plugins/memory_system/memory_test1.py
View File

File diff suppressed because it is too large Load Diff

170
src/plugins/memory_system/sample_distribution.py Normal file
View File

@@ -0,0 +1,170 @@
import numpy as np
from scipy import stats
from datetime import datetime, timedelta
class DistributionVisualizer:
def __init__(self, mean=0, std=1, skewness=0, sample_size=10):
"""
初始化分布可视化器
参数:
mean (float): 期望均值
std (float): 标准差
skewness (float): 偏度
sample_size (int): 样本大小
"""
self.mean = mean
self.std = std
self.skewness = skewness
self.sample_size = sample_size
self.samples = None
def generate_samples(self):
"""生成具有指定参数的样本"""
if self.skewness == 0:
# 对于无偏度的情况，直接使用正态分布
self.samples = np.random.normal(loc=self.mean, scale=self.std, size=self.sample_size)
else:
# 使用 scipy.stats 生成具有偏度的分布
self.samples = stats.skewnorm.rvs(a=self.skewness,
loc=self.mean,
scale=self.std,
size=self.sample_size)
def get_weighted_samples(self):
"""获取加权后的样本数列"""
if self.samples is None:
self.generate_samples()
# 将样本值乘以样本大小
return self.samples * self.sample_size
def get_statistics(self):
"""获取分布的统计信息"""
if self.samples is None:
self.generate_samples()
return {
"均值": np.mean(self.samples),
"标准差": np.std(self.samples),
"实际偏度": stats.skew(self.samples)
}
class MemoryBuildScheduler:
def __init__(self,
n_hours1, std_hours1, weight1,
n_hours2, std_hours2, weight2,
total_samples=50):
"""
初始化记忆构建调度器
参数:
n_hours1 (float): 第一个分布的均值（距离现在的小时数）
std_hours1 (float): 第一个分布的标准差（小时）
weight1 (float): 第一个分布的权重
n_hours2 (float): 第二个分布的均值（距离现在的小时数）
std_hours2 (float): 第二个分布的标准差（小时）
weight2 (float): 第二个分布的权重
total_samples (int): 要生成的总时间点数量
"""
# 归一化权重
total_weight = weight1 + weight2
self.weight1 = weight1 / total_weight
self.weight2 = weight2 / total_weight
self.n_hours1 = n_hours1
self.std_hours1 = std_hours1
self.n_hours2 = n_hours2
self.std_hours2 = std_hours2
self.total_samples = total_samples
self.base_time = datetime.now()
def generate_time_samples(self):
"""生成混合分布的时间采样点"""
# 根据权重计算每个分布的样本数
samples1 = int(self.total_samples * self.weight1)
samples2 = self.total_samples - samples1
# 生成两个正态分布的小时偏移
hours_offset1 = np.random.normal(
loc=self.n_hours1,
scale=self.std_hours1,
size=samples1
)
hours_offset2 = np.random.normal(
loc=self.n_hours2,
scale=self.std_hours2,
size=samples2
)
# 合并两个分布的偏移
hours_offset = np.concatenate([hours_offset1, hours_offset2])
# 将偏移转换为实际时间戳（使用绝对值确保时间点在过去）
timestamps = [self.base_time - timedelta(hours=abs(offset)) for offset in hours_offset]
# 按时间排序（从最早到最近）
return sorted(timestamps)
def get_timestamp_array(self):
"""返回时间戳数组"""
timestamps = self.generate_time_samples()
return [int(t.timestamp()) for t in timestamps]
def print_time_samples(timestamps, show_distribution=True):
"""打印时间样本和分布信息"""
print(f"\n生成的{len(timestamps)}个时间点分布：")
print("序号".ljust(5), "时间戳".ljust(25), "距现在（小时）")
print("-" * 50)
now = datetime.now()
time_diffs = []
for i, timestamp in enumerate(timestamps, 1):
hours_diff = (now - timestamp).total_seconds() / 3600
time_diffs.append(hours_diff)
print(f"{str(i).ljust(5)} {timestamp.strftime('%Y-%m-%d %H:%M:%S').ljust(25)} {hours_diff:.2f}")
# 打印统计信息
print("\n统计信息：")
print(f"平均时间偏移：{np.mean(time_diffs):.2f}小时")
print(f"标准差：{np.std(time_diffs):.2f}小时")
print(f"最早时间：{min(timestamps).strftime('%Y-%m-%d %H:%M:%S')} ({max(time_diffs):.2f}小时前)")
print(f"最近时间：{max(timestamps).strftime('%Y-%m-%d %H:%M:%S')} ({min(time_diffs):.2f}小时前)")
if show_distribution:
# 计算时间分布的直方图
hist, bins = np.histogram(time_diffs, bins=40)
print("\n时间分布（每个*代表一个时间点）：")
for i in range(len(hist)):
if hist[i] > 0:
print(f"{bins[i]:6.1f}-{bins[i+1]:6.1f}小时: {'*' * int(hist[i])}")
# 使用示例
if __name__ == "__main__":
# 创建一个双峰分布的记忆调度器
scheduler = MemoryBuildScheduler(
n_hours1=12, # 第一个分布均值（12小时前）
std_hours1=8, # 第一个分布标准差
weight1=0.7, # 第一个分布权重 70%
n_hours2=36, # 第二个分布均值（36小时前）
std_hours2=24, # 第二个分布标准差
weight2=0.3, # 第二个分布权重 30%
total_samples=50 # 总共生成50个时间点
)
# 生成时间分布
timestamps = scheduler.generate_time_samples()
# 打印结果，包含分布可视化
print_time_samples(timestamps, show_distribution=True)
# 打印时间戳数组
timestamp_array = scheduler.get_timestamp_array()
print("\n时间戳数组（Unix时间戳）：")
print("[", end="")
for i, ts in enumerate(timestamp_array):
if i > 0:
print(", ", end="")
print(ts, end="")
print("]")

33
src/plugins/personality/big5_test.py
View File

@@ -4,10 +4,9 @@
# from .questionnaire import PERSONALITY_QUESTIONS, FACTOR_DESCRIPTIONS
import os
import random
import sys
from pathlib import Path
from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS,FACTOR_DESCRIPTIONS
import random
current_dir = Path(__file__).resolve().parent
project_root = current_dir.parent.parent.parent
@@ -16,7 +15,7 @@ env_path = project_root / ".env.prod"
root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
sys.path.append(root_path)
from src.plugins.personality.questionnaire import PERSONALITY_QUESTIONS, FACTOR_DESCRIPTIONS # noqa: E402
class BigFiveTest:
@@ -37,7 +36,7 @@ class BigFiveTest:
print("\n请认真阅读每个描述，选择最符合您实际情况的选项。\n")
# 创建题目序号到题目的映射
questions_map = {q['id']: q for q in self.questions}
questions_map = {q["id"]: q for q in self.questions}
# 获取所有题目ID并随机打乱顺序
question_ids = list(questions_map.keys())
@@ -65,35 +64,25 @@ class BigFiveTest:
def calculate_scores(self, answers):
"""计算各维度得分"""
results = {}
factor_questions = {
"外向性": [],
"神经质": [],
"严谨性": [],
"开放性": [],
"宜人性": []
}
factor_questions = {"外向性": [], "神经质": [], "严谨性": [], "开放性": [], "宜人性": []}
# 将题目按因子分类
for q in self.questions:
factor_questions[q['factor']].append(q)
factor_questions[q["factor"]].append(q)
# 计算每个维度的得分
for factor, questions in factor_questions.items():
total_score = 0
for q in questions:
score = answers[q['id']]
score = answers[q["id"]]
# 处理反向计分题目
if q['reverse_scoring']:
if q["reverse_scoring"]:
score = 7 - score # 6分量表反向计分为7减原始分
total_score += score
# 计算平均分
avg_score = round(total_score / len(questions), 2)
results[factor] = {
"得分": avg_score,
"题目数": len(questions),
"总分": total_score
}
results[factor] = {"得分": avg_score, "题目数": len(questions), "总分": total_score}
return results
@@ -101,6 +90,7 @@ class BigFiveTest:
"""获取因子的详细描述"""
return self.factors[factor]
def main():
test = BigFiveTest()
results = test.run_test()
@@ -112,9 +102,10 @@ def main():
print(f"平均分: {data['得分']} (总分: {data['总分']}, 题目数: {data['题目数']})")
print("-" * 30)
description = test.get_factor_description(factor)
print("维度说明:", description['description'][:100] + "...")
print("\n特征词:", ", ".join(description['trait_words']))
print("维度说明:", description["description"][:100] + "...")
print("\n特征词:", ", ".join(description["trait_words"]))
print("=" * 50)
if __name__ == "__main__":
main()

81
src/plugins/personality/combined_test.py
View File

@@ -1,14 +1,11 @@
from typing import Dict
import json
import os
import random
from pathlib import Path
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict
import random
from scipy import stats # 添加scipy导入用于t检验
from src.plugins.personality.big5_test import BigFiveTest
from src.plugins.personality.renqingziji import PersonalityEvaluator_direct
from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS, PERSONALITY_QUESTIONS
current_dir = Path(__file__).resolve().parent
project_root = current_dir.parent.parent.parent
@@ -17,6 +14,9 @@ env_path = project_root / ".env.prod"
root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
sys.path.append(root_path)
from src.plugins.personality.big5_test import BigFiveTest # noqa: E402
from src.plugins.personality.renqingziji import PersonalityEvaluator_direct # noqa: E402
from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS, PERSONALITY_QUESTIONS # noqa: E402
class CombinedPersonalityTest:
@@ -52,10 +52,7 @@ class CombinedPersonalityTest:
questionnaire_results = self.run_questionnaire()
# 转换问卷结果格式以便比较
questionnaire_scores = {
factor: data["得分"]
for factor, data in questionnaire_results.items()
}
questionnaire_scores = {factor: data["得分"] for factor, data in questionnaire_results.items()}
# 运行情景测试
print("\n=== 第二部分：情景反应测评 ===")
@@ -75,7 +72,7 @@ class CombinedPersonalityTest:
def run_questionnaire(self):
"""运行问卷测试部分"""
# 创建题目序号到题目的映射
questions_map = {q['id']: q for q in PERSONALITY_QUESTIONS}
questions_map = {q["id"]: q for q in PERSONALITY_QUESTIONS}
# 获取所有题目ID并随机打乱顺序
question_ids = list(questions_map.keys())
@@ -108,35 +105,25 @@ class CombinedPersonalityTest:
def calculate_questionnaire_scores(self, answers):
"""计算问卷测试的维度得分"""
results = {}
factor_questions = {
"外向性": [],
"神经质": [],
"严谨性": [],
"开放性": [],
"宜人性": []
}
factor_questions = {"外向性": [], "神经质": [], "严谨性": [], "开放性": [], "宜人性": []}
# 将题目按因子分类
for q in PERSONALITY_QUESTIONS:
factor_questions[q['factor']].append(q)
factor_questions[q["factor"]].append(q)
# 计算每个维度的得分
for factor, questions in factor_questions.items():
total_score = 0
for q in questions:
score = answers[q['id']]
score = answers[q["id"]]
# 处理反向计分题目
if q['reverse_scoring']:
if q["reverse_scoring"]:
score = 7 - score # 6分量表反向计分为7减原始分
total_score += score
# 计算平均分
avg_score = round(total_score / len(questions), 2)
results[factor] = {
"得分": avg_score,
"题目数": len(questions),
"总分": total_score
}
results[factor] = {"得分": avg_score, "题目数": len(questions), "总分": total_score}
return results
@@ -161,11 +148,7 @@ class CombinedPersonalityTest:
continue
print("\n正在评估您的描述...")
scores = self.scenario_test.evaluate_response(
scenario_data["场景"],
response,
scenario_data["评估维度"]
)
scores = self.scenario_test.evaluate_response(scenario_data["场景"], response, scenario_data["评估维度"])
# 更新分数
for dimension, score in scores.items():
@@ -187,10 +170,7 @@ class CombinedPersonalityTest:
# 计算平均分
for dimension in final_scores:
if dimension_counts[dimension] > 0:
final_scores[dimension] = round(
final_scores[dimension] / dimension_counts[dimension],
2
)
final_scores[dimension] = round(final_scores[dimension] / dimension_counts[dimension], 2)
return final_scores
@@ -226,9 +206,13 @@ class CombinedPersonalityTest:
std_diff = (sum((x - mean_diff) ** 2 for x in diffs) / (len(diffs) - 1)) ** 0.5
# 计算效应量 (Cohen's d)
pooled_std = ((sum((x - sum(questionnaire_values)/len(questionnaire_values))**2 for x in questionnaire_values) +
sum((x - sum(scenario_values)/len(scenario_values))**2 for x in scenario_values)) /
(2 * len(self.dimensions) - 2)) ** 0.5
pooled_std = (
(
sum((x - sum(questionnaire_values) / len(questionnaire_values)) ** 2 for x in questionnaire_values)
+ sum((x - sum(scenario_values) / len(scenario_values)) ** 2 for x in scenario_values)
)
/ (2 * len(self.dimensions) - 2)
) ** 0.5
if pooled_std != 0:
cohens_d = abs(mean_diff / pooled_std)
@@ -270,12 +254,14 @@ class CombinedPersonalityTest:
for dimension in self.dimensions:
diff = abs(questionnaire_scores[dimension] - scenario_scores[dimension])
if diff >= 1.0: # 差异大于等于1分视为显著
significant_diffs.append({
significant_diffs.append(
{
"dimension": dimension,
"diff": diff,
"questionnaire": questionnaire_scores[dimension],
"scenario": scenario_scores[dimension]
})
"scenario": scenario_scores[dimension],
}
)
if significant_diffs:
print("\n\n显著差异分析：")
@@ -287,7 +273,7 @@ class CombinedPersonalityTest:
print(f"差异值：{diff['diff']:.2f}")
# 分析可能的原因
if diff['questionnaire'] > diff['scenario']:
if diff["questionnaire"] > diff["scenario"]:
print("可能原因：在问卷中的自我评价较高，但在具体情景中的表现较为保守。")
else:
print("可能原因：在具体情景中表现出更多该维度特征，而在问卷自评时较为保守。")
@@ -298,7 +284,7 @@ class CombinedPersonalityTest:
"测试时间": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"问卷测评结果": questionnaire_scores,
"情景测评结果": scenario_scores,
"维度说明": FACTOR_DESCRIPTIONS
"维度说明": FACTOR_DESCRIPTIONS,
}
# 确保目录存在
@@ -313,6 +299,7 @@ class CombinedPersonalityTest:
print(f"\n完整的测评结果已保存到：{filename}")
def load_existing_results():
"""检查并加载已有的测试结果"""
results_dir = "results"
@@ -320,15 +307,13 @@ def load_existing_results():
return None
# 获取所有personality_combined开头的文件
result_files = [f for f in os.listdir(results_dir)
if f.startswith("personality_combined_") and f.endswith(".json")]
result_files = [f for f in os.listdir(results_dir) if f.startswith("personality_combined_") and f.endswith(".json")]
if not result_files:
return None
# 按文件修改时间排序，获取最新的结果文件
latest_file = max(result_files,
key=lambda f: os.path.getmtime(os.path.join(results_dir, f)))
latest_file = max(result_files, key=lambda f: os.path.getmtime(os.path.join(results_dir, f)))
print(f"\n发现已有的测试结果：{latest_file}")
try:
@@ -339,6 +324,7 @@ def load_existing_results():
print(f"读取结果文件时出错：{str(e)}")
return None
def main():
test = CombinedPersonalityTest()
@@ -358,5 +344,6 @@ def main():
print("\n未找到已有的测试结果，开始新的测试...")
test.run_combined_test()
if __name__ == "__main__":
main()

216
src/plugins/personality/questionnaire.py
View File

@@ -1,7 +1,9 @@
# 人格测试问卷题目 王孟成, 戴晓阳, & 姚树桥. (2011). 中国大五人格问卷的初步编制Ⅲ:简式版的制定及信效度检验.
# 中国临床心理学杂志, 19(04), Article 04.
# 王孟成, 戴晓阳, & 姚树桥. (2010). 中国大五人格问卷的初步编制Ⅰ:理论框架与信度分析.
# 中国临床心理学杂志, 18(05), Article 05.
# 人格测试问卷题目
# 王孟成, 戴晓阳, & 姚树桥. (2011).
# 中国大五人格问卷的初步编制Ⅲ:简式版的制定及信效度检验. 中国临床心理学杂志, 19(04), Article 04.
# 王孟成, 戴晓阳, & 姚树桥. (2010).
# 中国大五人格问卷的初步编制Ⅰ:理论框架与信度分析. 中国临床心理学杂志, 18(05), Article 05.
PERSONALITY_QUESTIONS = [
# 神经质维度 (F1)
@@ -9,168 +11,132 @@ PERSONALITY_QUESTIONS = [
{"id": 2, "content": "我常感到害怕", "factor": "神经质", "reverse_scoring": False},
{"id": 3, "content": "有时我觉得自己一无是处", "factor": "神经质", "reverse_scoring": False},
{"id": 4, "content": "我很少感到忧郁或沮丧", "factor": "神经质", "reverse_scoring": True},
{"id": 5, "content": "别人一句漫不经心的话，我常会联系在自己身上",
"factor": "神经质", "reverse_scoring": False},
{"id": 6, "content": "在面对压力时，我有种快要崩溃的感觉",
"factor": "神经质", "reverse_scoring": False},
{"id": 7, "content": "我常担忧一些无关紧要的事情",
"factor": "神经质", "reverse_scoring": False},
{"id": 8, "content": "我常常感到内心不踏实",
"factor": "神经质", "reverse_scoring": False},
{"id": 5, "content": "别人一句漫不经心的话，我常会联系在自己身上", "factor": "神经质", "reverse_scoring": False},
{"id": 6, "content": "在面对压力时，我有种快要崩溃的感觉", "factor": "神经质", "reverse_scoring": False},
{"id": 7, "content": "我常担忧一些无关紧要的事情", "factor": "神经质", "reverse_scoring": False},
{"id": 8, "content": "我常常感到内心不踏实", "factor": "神经质", "reverse_scoring": False},
# 严谨性维度 (F2)
{"id": 9, "content": "在工作上，我常只求能应付过去便可",
"factor": "严谨性", "reverse_scoring": True},
{"id": 10, "content": "一旦确定了目标，我会坚持努力地实现它",
"factor": "严谨性", "reverse_scoring": False},
{"id": 11, "content": "我常常是仔细考虑之后才做出决定",
"factor": "严谨性", "reverse_scoring": False},
{"id": 12, "content": "别人认为我是个慎重的人",
"factor": "严谨性", "reverse_scoring": False},
{"id": 13, "content": "做事讲究逻辑和条理是我的一个特点",
"factor": "严谨性", "reverse_scoring": False},
{"id": 14, "content": "我喜欢一开头就把事情计划好",
"factor": "严谨性", "reverse_scoring": False},
{"id": 15, "content": "我工作或学习很勤奋",
"factor": "严谨性", "reverse_scoring": False},
{"id": 16, "content": "我是个倾尽全力做事的人",
"factor": "严谨性", "reverse_scoring": False},
{"id": 9, "content": "在工作上，我常只求能应付过去便可", "factor": "严谨性", "reverse_scoring": True},
{"id": 10, "content": "一旦确定了目标，我会坚持努力地实现它", "factor": "严谨性", "reverse_scoring": False},
{"id": 11, "content": "我常常是仔细考虑之后才做出决定", "factor": "严谨性", "reverse_scoring": False},
{"id": 12, "content": "别人认为我是个慎重的人", "factor": "严谨性", "reverse_scoring": False},
{"id": 13, "content": "做事讲究逻辑和条理是我的一个特点", "factor": "严谨性", "reverse_scoring": False},
{"id": 14, "content": "我喜欢一开头就把事情计划好", "factor": "严谨性", "reverse_scoring": False},
{"id": 15, "content": "我工作或学习很勤奋", "factor": "严谨性", "reverse_scoring": False},
{"id": 16, "content": "我是个倾尽全力做事的人", "factor": "严谨性", "reverse_scoring": False},
# 宜人性维度 (F3)
{"id": 17, "content": "尽管人类社会存在着一些阴暗的东西（如战争、罪恶、欺诈），"
"我仍然相信人性总的来说是善良的", "factor": "宜人性", "reverse_scoring": False},
{"id": 18, "content": "我觉得大部分人基本上是心怀善意的",
"factor": "宜人性", "reverse_scoring": False},
{"id": 19, "content": "虽然社会上有骗子，但我觉得大部分人还是可信的",
"factor": "宜人性", "reverse_scoring": False},
{"id": 20, "content": "我不太关心别人是否受到不公正的待遇",
"factor": "宜人性", "reverse_scoring": True},
{"id": 21, "content": "我时常觉得别人的痛苦与我无关",
"factor": "宜人性", "reverse_scoring": True},
{"id": 22, "content": "我常为那些遭遇不幸的人感到难过",
"factor": "宜人性", "reverse_scoring": False},
{"id": 23, "content": "我是那种只照顾好自己，不替别人担忧的人",
"factor": "宜人性", "reverse_scoring": True},
{"id": 24, "content": "当别人向我诉说不幸时，我常感到难过",
"factor": "宜人性", "reverse_scoring": False},
{
"id": 17,
"content": "尽管人类社会存在着一些阴暗的东西（如战争、罪恶、欺诈），我仍然相信人性总的来说是善良的",
"factor": "宜人性",
"reverse_scoring": False,
},
{"id": 18, "content": "我觉得大部分人基本上是心怀善意的", "factor": "宜人性", "reverse_scoring": False},
{"id": 19, "content": "虽然社会上有骗子，但我觉得大部分人还是可信的", "factor": "宜人性", "reverse_scoring": False},
{"id": 20, "content": "我不太关心别人是否受到不公正的待遇", "factor": "宜人性", "reverse_scoring": True},
{"id": 21, "content": "我时常觉得别人的痛苦与我无关", "factor": "宜人性", "reverse_scoring": True},
{"id": 22, "content": "我常为那些遭遇不幸的人感到难过", "factor": "宜人性", "reverse_scoring": False},
{"id": 23, "content": "我是那种只照顾好自己，不替别人担忧的人", "factor": "宜人性", "reverse_scoring": True},
{"id": 24, "content": "当别人向我诉说不幸时，我常感到难过", "factor": "宜人性", "reverse_scoring": False},
# 开放性维度 (F4)
{"id": 25, "content": "我的想象力相当丰富",
"factor": "开放性", "reverse_scoring": False},
{"id": 26, "content": "我头脑中经常充满生动的画面",
"factor": "开放性", "reverse_scoring": False},
{"id": 27, "content": "我对许多事情有着很强的好奇心",
"factor": "开放性", "reverse_scoring": False},
{"id": 28, "content": "我喜欢冒险",
"factor": "开放性", "reverse_scoring": False},
{"id": 29, "content": "我是个勇于冒险，突破常规的人",
"factor": "开放性", "reverse_scoring": False},
{"id": 30, "content": "我身上具有别人没有的冒险精神",
"factor": "开放性", "reverse_scoring": False},
{"id": 31, "content": "我渴望学习一些新东西，即使它们与我的日常生活无关",
"factor": "开放性", "reverse_scoring": False},
{"id": 32, "content": "我很愿意也很容易接受那些新事物、新观点、新想法",
"factor": "开放性", "reverse_scoring": False},
{"id": 25, "content": "我的想象力相当丰富", "factor": "开放性", "reverse_scoring": False},
{"id": 26, "content": "我头脑中经常充满生动的画面", "factor": "开放性", "reverse_scoring": False},
{"id": 27, "content": "我对许多事情有着很强的好奇心", "factor": "开放性", "reverse_scoring": False},
{"id": 28, "content": "我喜欢冒险", "factor": "开放性", "reverse_scoring": False},
{"id": 29, "content": "我是个勇于冒险，突破常规的人", "factor": "开放性", "reverse_scoring": False},
{"id": 30, "content": "我身上具有别人没有的冒险精神", "factor": "开放性", "reverse_scoring": False},
{
"id": 31,
"content": "我渴望学习一些新东西，即使它们与我的日常生活无关",
"factor": "开放性",
"reverse_scoring": False,
},
{
"id": 32,
"content": "我很愿意也很容易接受那些新事物、新观点、新想法",
"factor": "开放性",
"reverse_scoring": False,
},
# 外向性维度 (F5)
{"id": 33, "content": "我喜欢参加社交与娱乐聚会",
"factor": "外向性", "reverse_scoring": False},
{"id": 34, "content": "我对人多的聚会感到乏味",
"factor": "外向性", "reverse_scoring": True},
{"id": 35, "content": "我尽量避免参加人多的聚会和嘈杂的环境",
"factor": "外向性", "reverse_scoring": True},
{"id": 36, "content": "在热闹的聚会上，我常常表现主动并尽情玩耍",
"factor": "外向性", "reverse_scoring": False},
{"id": 37, "content": "有我在的场合一般不会冷场",
"factor": "外向性", "reverse_scoring": False},
{"id": 38, "content": "我希望成为领导者而不是被领导者",
"factor": "外向性", "reverse_scoring": False},
{"id": 39, "content": "在一个团体中，我希望处于领导地位",
"factor": "外向性", "reverse_scoring": False},
{"id": 40, "content": "别人多认为我是一个热情和友好的人",
"factor": "外向性", "reverse_scoring": False}
{"id": 33, "content": "我喜欢参加社交与娱乐聚会", "factor": "外向性", "reverse_scoring": False},
{"id": 34, "content": "我对人多的聚会感到乏味", "factor": "外向性", "reverse_scoring": True},
{"id": 35, "content": "我尽量避免参加人多的聚会和嘈杂的环境", "factor": "外向性", "reverse_scoring": True},
{"id": 36, "content": "在热闹的聚会上，我常常表现主动并尽情玩耍", "factor": "外向性", "reverse_scoring": False},
{"id": 37, "content": "有我在的场合一般不会冷场", "factor": "外向性", "reverse_scoring": False},
{"id": 38, "content": "我希望成为领导者而不是被领导者", "factor": "外向性", "reverse_scoring": False},
{"id": 39, "content": "在一个团体中，我希望处于领导地位", "factor": "外向性", "reverse_scoring": False},
{"id": 40, "content": "别人多认为我是一个热情和友好的人", "factor": "外向性", "reverse_scoring": False},
]
# 因子维度说明
FACTOR_DESCRIPTIONS = {
"外向性": {
"description": (
"反映个体神经系统的强弱和动力特征。外向性主要表现为个体在人际交往和社交活动中的倾向性，"
"包括对社交活动的兴趣、对人群的态度、社交互动中的主动程度以及在群体中的影响力。"
"高分者倾向于积极参与社交活动，乐于与人交往，善于表达自我，并往往在群体中发挥领导作用；"
"低分者则倾向于独处，不喜欢热闹的社交场合，表现出内向、安静的特征。"
),
"description": "反映个体神经系统的强弱和动力特征。外向性主要表现为个体在人际交往和社交活动中的倾向性，"
"包括对社交活动的兴趣、"
"对人群的态度、社交互动中的主动程度以及在群体中的影响力。高分者倾向于积极参与社交活动，乐于与人交往，善于表达自我，"
"并往往在群体中发挥领导作用；低分者则倾向于独处，不喜欢热闹的社交场合，表现出内向、安静的特征。",
"trait_words": ["热情", "活力", "社交", "主动"],
"subfactors": {
"合群性": "个体愿意与他人聚在一起，即接近人群的倾向；高分表现乐群、好交际，低分表现封闭、独处",
"热情": "个体对待别人时所表现出的态度；高分表现热情好客，低分表现冷淡",
"支配性": "个体喜欢指使、操纵他人，倾向于领导别人的特点；高分表现好强、发号施令，低分表现顺从、低调",
"活跃": "个体精力充沛，活跃、主动性等特点；高分表现活跃，低分表现安静"
}
"活跃": "个体精力充沛，活跃、主动性等特点；高分表现活跃，低分表现安静",
},
},
"神经质": {
"description": (
"反映个体情绪的状态和体验内心苦恼的倾向性。这个维度主要关注个体在面对压力、挫折和"
"日常生活挑战时的情绪稳定性和适应能力。它包含了对焦虑、抑郁、愤怒等负面情绪的敏感程度，"
"description": "反映个体情绪的状态和体验内心苦恼的倾向性。这个维度主要关注个体在面对压力、"
"挫折和日常生活挑战时的情绪稳定性和适应能力。它包含了对焦虑、抑郁、愤怒等负面情绪的敏感程度，"
"以及个体对这些情绪的调节和控制能力。高分者容易体验负面情绪，对压力较为敏感，情绪波动较大；"
"低分者则表现出较强的情绪稳定性，能够较好地应对压力和挫折。"
),
"低分者则表现出较强的情绪稳定性，能够较好地应对压力和挫折。",
"trait_words": ["稳定", "沉着", "从容", "坚韧"],
"subfactors": {
"焦虑": "个体体验焦虑感的个体差异；高分表现坐立不安，低分表现平静",
"抑郁": "个体体验抑郁情感的个体差异；高分表现郁郁寡欢，低分表现平静",
"敏感多疑": "个体常常关注自己的内心活动，行为和过于意识人对自己的看法、评价；"
"高分表现敏感多疑，低分表现淡定、自信",
"敏感多疑": "个体常常关注自己的内心活动，行为和过于意识人对自己的看法、评价；高分表现敏感多疑，"
"低分表现淡定、自信",
"脆弱性": "个体在危机或困难面前无力、脆弱的特点；高分表现无能、易受伤、逃避，低分表现坚强",
"愤怒-敌意": "个体准备体验愤怒，及相关情绪的状态；高分表现暴躁易怒，低分表现平静"
}
"愤怒-敌意": "个体准备体验愤怒，及相关情绪的状态；高分表现暴躁易怒，低分表现平静",
},
},
"严谨性": {
"description": (
"反映个体在目标导向行为上的组织、坚持和动机特征。这个维度体现了个体在工作、学习等"
"目标性活动中的自我约束和行为管理能力。它涉及到个体的责任感、自律性、计划性、条理性以及"
"完成任务的态度。高分者往往表现出强烈的责任心、良好的组织能力、谨慎的决策风格和持续的"
"努力精神；低分者则可能表现出随意性强、缺乏规划、做事马虎或易放弃的特点。"
),
"description": "反映个体在目标导向行为上的组织、坚持和动机特征。这个维度体现了个体在工作、"
"学习等目标性活动中的自我约束和行为管理能力。它涉及到个体的责任感、自律性、计划性、条理性以及完成任务的态度。"
"高分者往往表现出强烈的责任心、良好的组织能力、谨慎的决策风格和持续的努力精神；低分者则可能表现出随意性强、"
"缺乏规划、做事马虎或易放弃的特点。",
"trait_words": ["负责", "自律", "条理", "勤奋"],
"subfactors": {
"责任心": "个体对待任务和他人认真负责，以及对自己承诺的信守；"
"高分表现有责任心、负责任，低分表现推卸责任、逃避处罚",
"责任心": "个体对待任务和他人认真负责，以及对自己承诺的信守；高分表现有责任心、负责任，"
"低分表现推卸责任、逃避处罚",
"自我控制": "个体约束自己的能力，及自始至终的坚持性；高分表现自制、有毅力，低分表现冲动、无毅力",
"审慎性": "个体在采取具体行动前的心理状态；高分表现谨慎、小心，低分表现鲁莽、草率",
"条理性": "个体处理事务和工作的秩序，条理和逻辑性；高分表现整洁、有秩序，低分表现混乱、遗漏",
"勤奋": "个体工作和学习的努力程度及为达到目标而表现出的进取精神；高分表现勤奋、刻苦，低分表现懒散"
}
"勤奋": "个体工作和学习的努力程度及为达到目标而表现出的进取精神；高分表现勤奋、刻苦，低分表现懒散",
},
},
"开放性": {
"description": (
"反映个体对新异事物、新观念和新经验的接受程度，以及在思维和行为方面的创新倾向。"
"这个维度体现了个体在认知和体验方面的广度、深度和灵活性。它包括对艺术的欣赏能力、"
"对知识的求知欲、想象力的丰富程度，以及对冒险和创新的态度。高分者往往具有丰富的想象力、"
"广泛的兴趣、开放的思维方式和创新的倾向；低分者则倾向于保守、传统，喜欢熟悉和常规的事物。"
),
"description": "反映个体对新异事物、新观念和新经验的接受程度，以及在思维和行为方面的创新倾向。"
"这个维度体现了个体在认知和体验方面的广度、深度和灵活性。它包括对艺术的欣赏能力、对知识的求知欲、想象力的丰富程度，"
"以及对冒险和创新的态度。高分者往往具有丰富的想象力、广泛的兴趣、开放的思维方式和创新的倾向；低分者则倾向于保守、"
"传统，喜欢熟悉和常规的事物。",
"trait_words": ["创新", "好奇", "艺术", "冒险"],
"subfactors": {
"幻想": "个体富于幻想和想象的水平；高分表现想象力丰富，低分表现想象力匮乏",
"审美": "个体对于艺术和美的敏感与热爱程度；高分表现富有艺术气息，低分表现一般对艺术不敏感",
"好奇心": "个体对未知事物的态度；高分表现兴趣广泛、好奇心浓，低分表现兴趣少、无好奇心",
"冒险精神": "个体愿意尝试有风险活动的个体差异；高分表现好冒险，低分表现保守",
"价值观念": "个体对新事物、新观念、怪异想法的态度；高分表现开放、坦然接受新事物，低分则相反"
}
"价值观念": "个体对新事物、新观念、怪异想法的态度；高分表现开放、坦然接受新事物，低分则相反",
},
},
"宜人性": {
"description": (
"反映个体在人际关系中的亲和倾向，体现了对他人的关心、同情和合作意愿。这个维度主要"
"关注个体与他人互动时的态度和行为特征，包括对他人的信任程度、同理心水平、助人意愿以及"
"在人际冲突中的处理方式。高分者通常表现出友善、富有同情心、乐于助人的特质，善于与他人"
"建立和谐关系；低分者则可能表现出较少的人际关注，在社交互动中更注重自身利益，较少考虑"
"他人感受。"
),
"description": "反映个体在人际关系中的亲和倾向，体现了对他人的关心、同情和合作意愿。"
"这个维度主要关注个体与他人互动时的态度和行为特征，包括对他人的信任程度、同理心水平、"
"助人意愿以及在人际冲突中的处理方式。高分者通常表现出友善、富有同情心、乐于助人的特质，善于与他人建立和谐关系；"
"低分者则可能表现出较少的人际关注，在社交互动中更注重自身利益，较少考虑他人感受。",
"trait_words": ["友善", "同理", "信任", "合作"],
"subfactors": {
"信任": "个体对他人和/或他人言论的相信程度；高分表现信任他人，低分表现怀疑",
"体贴": "个体对别人的兴趣和需要的关注程度；高分表现体贴、温存，低分表现冷漠、不在乎",
"同情": "个体对处于不利地位的人或物的态度；高分表现富有同情心，低分表现冷漠"
}
}
"同情": "个体对处于不利地位的人或物的态度；高分表现富有同情心，低分表现冷漠",
},
},
}

42
src/plugins/personality/renqingziji.py
View File

@@ -1,29 +1,23 @@
'''
"""
The definition of artificial personality in this paper follows the dispositional para-digm and adapts a definition of
personality developed for humans [17]:
Personality for a human is the "whole and organisation of relatively stable tendencies and patterns of experience and
behaviour within one person (distinguishing it from other persons)".
This definition is modified for artificial personality:
Artificial personality describes the relatively stable tendencies
and patterns of behav-iour of an AI-based machine that
behaviour within one person (distinguishing it from other persons)". This definition is modified for artificial
personality:
Artificial personality describes the relatively stable tendencies and patterns of behav-iour of an AI-based machine that
can be designed by developers and designers via different modalities, such as language, creating the impression
of individuality of a humanized social agent when users interact with the machine.'''
of individuality of a humanized social agent when users interact with the machine."""
from typing import Dict, List
import json
import os
import sys
from pathlib import Path
from typing import Dict, List
from dotenv import load_dotenv
import sys
from src.plugins.personality.offline_llm import LLMModel
from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS
from src.plugins.personality.scene import get_scene_by_factor, PERSONALITY_SCENES
'''
"""
第一种方案：基于情景评估的人格测定
'''
"""
current_dir = Path(__file__).resolve().parent
project_root = current_dir.parent.parent.parent
env_path = project_root / ".env.prod"
@@ -31,6 +25,9 @@ env_path = project_root / ".env.prod"
root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
sys.path.append(root_path)
from src.plugins.personality.scene import get_scene_by_factor, PERSONALITY_SCENES # noqa: E402
from src.plugins.personality.questionnaire import FACTOR_DESCRIPTIONS # noqa: E402
from src.plugins.personality.offline_llm import LLMModel # noqa: E402
# 加载环境变量
if env_path.exists():
@@ -54,6 +51,7 @@ class PersonalityEvaluator_direct:
# 从每个维度选择3个场景
import random
scene_keys = list(scenes.keys())
selected_scenes = random.sample(scene_keys, min(3, len(scene_keys)))
@@ -65,11 +63,9 @@ class PersonalityEvaluator_direct:
other_traits = [t for t in PERSONALITY_SCENES if t != trait]
secondary_trait = random.choice(other_traits)
self.scenarios.append({
"场景": scene["scenario"],
"评估维度": [trait, secondary_trait],
"场景编号": scene_key
})
self.scenarios.append(
{"场景": scene["scenario"], "评估维度": [trait, secondary_trait], "场景编号": scene_key}
)
self.llm = LLMModel()
@@ -183,11 +179,7 @@ def main():
print(f"测试场景数：{dimension_counts[trait]}")
# 保存结果
result = {
"final_scores": final_scores,
"dimension_counts": dimension_counts,
"scenarios": evaluator.scenarios
}
result = {"final_scores": final_scores, "dimension_counts": dimension_counts, "scenarios": evaluator.scenarios}
# 确保目录存在
os.makedirs("results", exist_ok=True)

91
src/plugins/personality/scene.py
View File

@@ -8,7 +8,7 @@ PERSONALITY_SCENES = {
同事：「嗨！你是新来的同事吧？我是市场部的小林。」
同事看起来很友善，还主动介绍说：「待会午饭时间，我们部门有几个人准备一起去楼下新开的餐厅，你要一起来吗？可以认识一下其他同事。」""",
"explanation": "这个场景通过职场社交情境，观察个体对于新环境、新社交圈的态度和反应倾向。"
"explanation": "这个场景通过职场社交情境，观察个体对于新环境、新社交圈的态度和反应倾向。",
},
"场景2": {
"scenario": """在大学班级群里，班长发起了一个组织班级联谊活动的投票：
@@ -16,7 +16,7 @@ PERSONALITY_SCENES = {
班长：「大家好！下周末我们准备举办一次班级联谊活动，地点在学校附近的KTV。想请大家报名参加，也欢迎大家邀请其他班级的同学！」
已经有几个同学在群里积极响应，有人@你问你要不要一起参加。""",
"explanation": "通过班级活动场景，观察个体对群体社交活动的参与意愿。"
"explanation": "通过班级活动场景，观察个体对群体社交活动的参与意愿。",
},
"场景3": {
"scenario": """你在社交平台上发布了一条动态，收到了很多陌生网友的评论和私信：
@@ -24,13 +24,14 @@ PERSONALITY_SCENES = {
网友A：「你说的这个观点很有意思！想和你多交流一下。」
网友B：「我也对这个话题很感兴趣，要不要建个群一起讨论？」""",
"explanation": "通过网络社交场景，观察个体对线上社交的态度。"
"explanation": "通过网络社交场景，观察个体对线上社交的态度。",
},
"场景4": {
"scenario": """你暗恋的对象今天主动来找你：
对方：「那个...我最近在准备一个演讲比赛，听说你口才很好。能不能请你帮我看看演讲稿，顺便给我一些建议？如果你有时间的话，可以一起吃个饭聊聊。」""",
"explanation": "通过恋爱情境，观察个体在面对心仪对象时的社交表现。"
对方：「那个...我最近在准备一个演讲比赛，听说你口才很好。能不能请你帮我看看演讲稿，顺便给我一些建议？"""
"""如果你有时间的话，可以一起吃个饭聊聊。」""",
"explanation": "通过恋爱情境，观察个体在面对心仪对象时的社交表现。",
},
"场景5": {
"scenario": """在一次线下读书会上，主持人突然点名让你分享读后感：
@@ -38,19 +39,18 @@ PERSONALITY_SCENES = {
主持人：「听说你对这本书很有见解，能不能和大家分享一下你的想法？」
现场有二十多个陌生的读书爱好者，都期待地看着你。""",
"explanation": "通过即兴发言场景，观察个体的社交表现欲和公众表达能力。"
}
"explanation": "通过即兴发言场景，观察个体的社交表现欲和公众表达能力。",
},
},
"神经质": {
"场景1": {
"scenario": """你正在准备一个重要的项目演示，这关系到你的晋升机会。就在演示前30分钟
，你收到了主管发来的消息：
"scenario": """你正在准备一个重要的项目演示，这关系到你的晋升机会。"""
"""就在演示前30分钟，你收到了主管发来的消息：
主管：「临时有个变动，CEO也会来听你的演示。他对这个项目特别感兴趣。」
正当你准备回复时，主管又发来一条：「对了，能不能把演示时间压缩到15分钟？CEO下午还有其他安排。
你之前准备的是30分钟的版本对吧？」""",
"explanation": "这个场景通过突发的压力情境，观察个体在面对计划外变化时的情绪反应和调节能力。"
正当你准备回复时，主管又发来一条：「对了，能不能把演示时间压缩到15分钟？CEO下午还有其他安排。你之前准备的是30分钟的版本对吧？」""",
"explanation": "这个场景通过突发的压力情境，观察个体在面对计划外变化时的情绪反应和调节能力。",
},
"场景2": {
"scenario": """期末考试前一天晚上，你收到了好朋友发来的消息：
@@ -58,7 +58,7 @@ PERSONALITY_SCENES = {
好朋友：「不好意思这么晚打扰你...我看你平时成绩很好，能不能帮我解答几个问题？我真的很担心明天的考试。」
你看了看时间，已经是晚上11点，而你原本计划的复习还没完成。""",
"explanation": "通过考试压力场景，观察个体在时间紧张时的情绪管理。"
"explanation": "通过考试压力场景，观察个体在时间紧张时的情绪管理。",
},
"场景3": {
"scenario": """你在社交媒体上发表的一个观点引发了争议，有不少人开始批评你：
@@ -68,7 +68,7 @@ PERSONALITY_SCENES = {
网友B：「建议楼主先去补补课再来发言。」
评论区里的负面评论越来越多，还有人开始人身攻击。""",
"explanation": "通过网络争议场景，观察个体面对批评时的心理承受能力。"
"explanation": "通过网络争议场景，观察个体面对批评时的心理承受能力。",
},
"场景4": {
"scenario": """你和恋人约好今天一起看电影，但在约定时间前半小时，对方发来消息：
@@ -78,7 +78,7 @@ PERSONALITY_SCENES = {
二十分钟后，对方又发来消息：「可能要再等等，抱歉！」
电影快要开始了，但对方还是没有出现。""",
"explanation": "通过恋爱情境，观察个体对不确定性的忍耐程度。"
"explanation": "通过恋爱情境，观察个体对不确定性的忍耐程度。",
},
"场景5": {
"scenario": """在一次重要的小组展示中，你的组员在演示途中突然卡壳了：
@@ -86,10 +86,9 @@ PERSONALITY_SCENES = {
组员小声对你说：「我忘词了，接下来的部分是什么来着...」
台下的老师和同学都在等待，气氛有些尴尬。""",
"explanation": "通过公开场合的突发状况，观察个体的应急反应和压力处理能力。"
}
"explanation": "通过公开场合的突发状况，观察个体的应急反应和压力处理能力。",
},
},
"严谨性": {
"场景1": {
"scenario": """你是团队的项目负责人，刚刚接手了一个为期两个月的重要项目。在第一次团队会议上：
@@ -99,7 +98,7 @@ PERSONALITY_SCENES = {
小张：「要不要先列个时间表？不过感觉太详细的计划也没必要，点到为止就行。」
小李：「客户那边说如果能提前完成有奖励，我觉得我们可以先做快一点的部分。」""",
"explanation": "这个场景通过项目管理情境，体现个体在工作方法、计划性和责任心方面的特征。"
"explanation": "这个场景通过项目管理情境，体现个体在工作方法、计划性和责任心方面的特征。",
},
"场景2": {
"scenario": """期末小组作业，组长让大家分工完成一份研究报告。在截止日期前三天：
@@ -109,7 +108,7 @@ PERSONALITY_SCENES = {
组员B：「我这边可能还要一天才能完成，最近太忙了。」
组员C发来一份没有任何引用出处、可能存在抄袭的内容：「我写完了，你们看看怎么样？」""",
"explanation": "通过学习场景，观察个体对学术规范和质量要求的重视程度。"
"explanation": "通过学习场景，观察个体对学术规范和质量要求的重视程度。",
},
"场景3": {
"scenario": """你在一个兴趣小组的群聊中，大家正在讨论举办一次线下活动：
@@ -119,7 +118,7 @@ PERSONALITY_SCENES = {
成员B：「对啊，随意一点挺好的。」
成员C：「人来了自然就热闹了。」""",
"explanation": "通过活动组织场景，观察个体对活动计划的态度。"
"explanation": "通过活动组织场景，观察个体对活动计划的态度。",
},
"场景4": {
"scenario": """你和恋人计划一起去旅游，对方说：
@@ -127,7 +126,7 @@ PERSONALITY_SCENES = {
恋人：「我们就随心而行吧！订个目的地，其他的到了再说，这样更有意思。」
距离出发还有一周时间，但机票、住宿和具体行程都还没有确定。""",
"explanation": "通过旅行规划场景，观察个体的计划性和对不确定性的接受程度。"
"explanation": "通过旅行规划场景，观察个体的计划性和对不确定性的接受程度。",
},
"场景5": {
"scenario": """在一个重要的团队项目中，你发现一个同事的工作存在明显错误：
@@ -135,20 +134,19 @@ PERSONALITY_SCENES = {
同事：「差不多就行了，反正领导也看不出来。」
这个错误可能不会立即造成问题，但长期来看可能会影响项目质量。""",
"explanation": "通过工作质量场景，观察个体对细节和标准的坚持程度。"
}
"explanation": "通过工作质量场景，观察个体对细节和标准的坚持程度。",
},
},
"开放性": {
"场景1": {
"scenario": """周末下午，你的好友小美兴致勃勃地给你打电话：
小美：「我刚发现一个特别有意思的沉浸式艺术展！不是传统那种挂画的展览，而是把整个空间都变成了艺术品。观众要穿特制的服装，
还要带上VR眼镜，好像还有AI实时互动！」
小美：「我刚发现一个特别有意思的沉浸式艺术展！不是传统那种挂画的展览，而是把整个空间都变成了艺术品。"""
"""观众要穿特制的服装，还要带上VR眼镜，好像还有AI实时互动！」
小美继续说：「虽然票价不便宜，但听说体验很独特。网上评价两极分化，有人说是前所未有的艺术革新，
也有人说是哗众取宠。要不要周末一起去体验一下？」""",
"explanation": "这个场景通过新型艺术体验，反映个体对创新事物的接受程度和尝试意愿。"
小美继续说：「虽然票价不便宜，但听说体验很独特。网上评价两极分化，有人说是前所未有的艺术革新，也有人说是哗众取宠。"""
"""要不要周末一起去体验一下？」""",
"explanation": "这个场景通过新型艺术体验，反映个体对创新事物的接受程度和尝试意愿。",
},
"场景2": {
"scenario": """在一节创意写作课上，老师提出了一个特别的作业：
@@ -156,16 +154,16 @@ PERSONALITY_SCENES = {
老师：「下周的作业是用AI写作工具协助创作一篇小说。你们可以自由探索如何与AI合作，打破传统写作方式。」
班上随即展开了激烈讨论，有人认为这是对创作的亵渎，也有人对这种新形式感到兴奋。""",
"explanation": "通过新技术应用场景，观察个体对创新学习方式的态度。"
"explanation": "通过新技术应用场景，观察个体对创新学习方式的态度。",
},
"场景3": {
"scenario": """在社交媒体上，你看到一个朋友分享了一种新的生活方式：
「最近我在尝试'数字游牧'生活，就是一边远程工作一边环游世界。没有固定住所，住青旅或短租，认识来自世界各地的朋友。
虽然有时会很不稳定，但这种自由的生活方式真的很棒！」
「最近我在尝试'数字游牧'生活，就是一边远程工作一边环游世界。"""
"""没有固定住所，住青旅或短租，认识来自世界各地的朋友。虽然有时会很不稳定，但这种自由的生活方式真的很棒！」
评论区里争论不断，有人向往这种生活，也有人觉得太冒险。""",
"explanation": "通过另类生活方式，观察个体对非传统选择的态度。"
"explanation": "通过另类生活方式，观察个体对非传统选择的态度。",
},
"场景4": {
"scenario": """你的恋人突然提出了一个想法：
@@ -173,7 +171,7 @@ PERSONALITY_SCENES = {
恋人：「我们要不要尝试一下开放式关系？就是在保持彼此关系的同时，也允许和其他人发展感情。现在国外很多年轻人都这样。」
这个提议让你感到意外，你之前从未考虑过这种可能性。""",
"explanation": "通过感情观念场景，观察个体对非传统关系模式的接受度。"
"explanation": "通过感情观念场景，观察个体对非传统关系模式的接受度。",
},
"场景5": {
"scenario": """在一次朋友聚会上，大家正在讨论未来职业规划：
@@ -183,10 +181,9 @@ PERSONALITY_SCENES = {
朋友B：「我想去学习生物科技，准备转行做人造肉研发。」
朋友C：「我在考虑加入一个区块链创业项目，虽然风险很大。」""",
"explanation": "通过职业选择场景，观察个体对新兴领域的探索意愿。"
}
"explanation": "通过职业选择场景，观察个体对新兴领域的探索意愿。",
},
},
"宜人性": {
"场景1": {
"scenario": """在回家的公交车上，你遇到这样一幕：
@@ -198,7 +195,7 @@ PERSONALITY_SCENES = {
年轻人B：「现在的老年人真是...我看她包里还有菜，肯定是去菜市场买完菜回来的，这么多人都不知道叫子女开车接送。」
就在这时，老奶奶一个趔趄，差点摔倒。她扶住了扶手，但包里的东西洒了一些出来。""",
"explanation": "这个场景通过公共场合的助人情境，体现个体的同理心和对他人需求的关注程度。"
"explanation": "这个场景通过公共场合的助人情境，体现个体的同理心和对他人需求的关注程度。",
},
"场景2": {
"scenario": """在班级群里，有同学发起为生病住院的同学捐款：
@@ -208,7 +205,7 @@ PERSONALITY_SCENES = {
同学B：「我觉得这是他家里的事，我们不方便参与吧。」
同学C：「但是都是同学一场，帮帮忙也是应该的。」""",
"explanation": "通过同学互助场景，观察个体的助人意愿和同理心。"
"explanation": "通过同学互助场景，观察个体的助人意愿和同理心。",
},
"场景3": {
"scenario": """在一个网络讨论组里，有人发布了求助信息：
@@ -219,7 +216,7 @@ PERSONALITY_SCENES = {
「生活本来就是这样，想开点！」
「你这样子太消极了，要积极面对。」
「谁还没点烦心事啊，过段时间就好了。」""",
"explanation": "通过网络互助场景，观察个体的共情能力和安慰方式。"
"explanation": "通过网络互助场景，观察个体的共情能力和安慰方式。",
},
"场景4": {
"scenario": """你的恋人向你倾诉工作压力：
@@ -227,7 +224,7 @@ PERSONALITY_SCENES = {
恋人：「最近工作真的好累，感觉快坚持不下去了...」
但今天你也遇到了很多烦心事，心情也不太好。""",
"explanation": "通过感情关系场景，观察个体在自身状态不佳时的关怀能力。"
"explanation": "通过感情关系场景，观察个体在自身状态不佳时的关怀能力。",
},
"场景5": {
"scenario": """在一次团队项目中，新来的同事小王因为经验不足，造成了一个严重的错误。在部门会议上：
@@ -235,11 +232,12 @@ PERSONALITY_SCENES = {
主管：「这个错误造成了很大的损失，是谁负责的这部分？」
小王看起来很紧张，欲言又止。你知道是他造成的错误，同时你也是这个项目的共同负责人。""",
"explanation": "通过职场情境，观察个体在面对他人过错时的态度和处理方式。"
}
}
"explanation": "通过职场情境，观察个体在面对他人过错时的态度和处理方式。",
},
},
}
def get_scene_by_factor(factor: str) -> Dict:
"""
根据人格因子获取对应的情景测试
@@ -252,6 +250,7 @@ def get_scene_by_factor(factor: str) -> Dict:
"""
return PERSONALITY_SCENES.get(factor, None)
def get_all_scenes() -> Dict:
"""
获取所有情景测试

123
src/plugins/schedule/offline_llm.py Normal file
View File

@@ -0,0 +1,123 @@
import asyncio
import os
import time
from typing import Tuple, Union
import aiohttp
import requests
from src.common.logger import get_module_logger
logger = get_module_logger("offline_llm")
class LLMModel:
def __init__(self, model_name="deepseek-ai/DeepSeek-V3", **kwargs):
self.model_name = model_name
self.params = kwargs
self.api_key = os.getenv("SILICONFLOW_KEY")
self.base_url = os.getenv("SILICONFLOW_BASE_URL")
if not self.api_key or not self.base_url:
raise ValueError("环境变量未正确加载：SILICONFLOW_KEY 或 SILICONFLOW_BASE_URL 未设置")
logger.info(f"API URL: {self.base_url}") # 使用 logger 记录 base_url
def generate_response(self, prompt: str) -> Union[str, Tuple[str, str]]:
"""根据输入的提示生成模型的响应"""
headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
# 构建请求体
data = {
"model": self.model_name,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.5,
**self.params,
}
# 发送请求到完整的 chat/completions 端点
api_url = f"{self.base_url.rstrip('/')}/chat/completions"
logger.info(f"Request URL: {api_url}") # 记录请求的 URL
max_retries = 3
base_wait_time = 15 # 基础等待时间（秒）
for retry in range(max_retries):
try:
response = requests.post(api_url, headers=headers, json=data)
if response.status_code == 429:
wait_time = base_wait_time * (2**retry) # 指数退避
logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
time.sleep(wait_time)
continue
response.raise_for_status() # 检查其他响应状态
result = response.json()
if "choices" in result and len(result["choices"]) > 0:
content = result["choices"][0]["message"]["content"]
reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
return content, reasoning_content
return "没有返回结果", ""
except Exception as e:
if retry < max_retries - 1: # 如果还有重试机会
wait_time = base_wait_time * (2**retry)
logger.error(f"[回复]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}")
time.sleep(wait_time)
else:
logger.error(f"请求失败: {str(e)}")
return f"请求失败: {str(e)}", ""
logger.error("达到最大重试次数，请求仍然失败")
return "达到最大重试次数，请求仍然失败", ""
async def generate_response_async(self, prompt: str) -> Union[str, Tuple[str, str]]:
"""异步方式根据输入的提示生成模型的响应"""
headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
# 构建请求体
data = {
"model": self.model_name,
"messages": [{"role": "user", "content": prompt}],
"temperature": 0.5,
**self.params,
}
# 发送请求到完整的 chat/completions 端点
api_url = f"{self.base_url.rstrip('/')}/chat/completions"
logger.info(f"Request URL: {api_url}") # 记录请求的 URL
max_retries = 3
base_wait_time = 15
async with aiohttp.ClientSession() as session:
for retry in range(max_retries):
try:
async with session.post(api_url, headers=headers, json=data) as response:
if response.status == 429:
wait_time = base_wait_time * (2**retry) # 指数退避
logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
await asyncio.sleep(wait_time)
continue
response.raise_for_status() # 检查其他响应状态
result = await response.json()
if "choices" in result and len(result["choices"]) > 0:
content = result["choices"][0]["message"]["content"]
reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
return content, reasoning_content
return "没有返回结果", ""
except Exception as e:
if retry < max_retries - 1: # 如果还有重试机会
wait_time = base_wait_time * (2**retry)
logger.error(f"[回复]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}")
await asyncio.sleep(wait_time)
else:
logger.error(f"请求失败: {str(e)}")
return f"请求失败: {str(e)}", ""
logger.error("达到最大重试次数，请求仍然失败")
return "达到最大重试次数，请求仍然失败", ""

191
src/plugins/schedule/schedule_generator copy.py Normal file
View File

@@ -0,0 +1,191 @@
import datetime
import json
import re
import os
import sys
from typing import Dict, Union
# 添加项目根目录到 Python 路径
root_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../../.."))
sys.path.append(root_path)
from src.common.database import db # noqa: E402
from src.common.logger import get_module_logger # noqa: E402
from src.plugins.schedule.offline_llm import LLMModel # noqa: E402
from src.plugins.chat.config import global_config # noqa: E402
logger = get_module_logger("scheduler")
class ScheduleGenerator:
enable_output: bool = True
def __init__(self):
# 使用离线LLM模型
self.llm_scheduler = LLMModel(model_name="Pro/deepseek-ai/DeepSeek-V3", temperature=0.9)
self.today_schedule_text = ""
self.today_schedule = {}
self.tomorrow_schedule_text = ""
self.tomorrow_schedule = {}
self.yesterday_schedule_text = ""
self.yesterday_schedule = {}
async def initialize(self):
today = datetime.datetime.now()
tomorrow = datetime.datetime.now() + datetime.timedelta(days=1)
yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
self.today_schedule_text, self.today_schedule = await self.generate_daily_schedule(target_date=today)
self.tomorrow_schedule_text, self.tomorrow_schedule = await self.generate_daily_schedule(
target_date=tomorrow, read_only=True
)
self.yesterday_schedule_text, self.yesterday_schedule = await self.generate_daily_schedule(
target_date=yesterday, read_only=True
)
async def generate_daily_schedule(
self, target_date: datetime.datetime = None, read_only: bool = False
) -> Dict[str, str]:
date_str = target_date.strftime("%Y-%m-%d")
weekday = target_date.strftime("%A")
schedule_text = str
existing_schedule = db.schedule.find_one({"date": date_str})
if existing_schedule:
if self.enable_output:
logger.debug(f"{date_str}的日程已存在:")
schedule_text = existing_schedule["schedule"]
# print(self.schedule_text)
elif not read_only:
logger.debug(f"{date_str}的日程不存在，准备生成新的日程。")
prompt = (
f"""我是{global_config.BOT_NICKNAME}，{global_config.PROMPT_SCHEDULE_GEN}，请为我生成{date_str}（{weekday}）的日程安排，包括："""
+ """
1. 早上的学习和工作安排
2. 下午的活动和任务
3. 晚上的计划和休息时间
请按照时间顺序列出具体时间点和对应的活动，用一个时间点而不是时间段来表示时间，用JSON格式返回日程表，
仅返回内容，不要返回注释，不要添加任何markdown或代码块样式，时间采用24小时制，
格式为{"时间": "活动","时间": "活动",...}。"""
)
try:
schedule_text, _ = self.llm_scheduler.generate_response(prompt)
db.schedule.insert_one({"date": date_str, "schedule": schedule_text})
self.enable_output = True
except Exception as e:
logger.error(f"生成日程失败: {str(e)}")
schedule_text = "生成日程时出错了"
# print(self.schedule_text)
else:
if self.enable_output:
logger.debug(f"{date_str}的日程不存在。")
schedule_text = "忘了"
return schedule_text, None
schedule_form = self._parse_schedule(schedule_text)
return schedule_text, schedule_form
def _parse_schedule(self, schedule_text: str) -> Union[bool, Dict[str, str]]:
"""解析日程文本，转换为时间和活动的字典"""
try:
reg = r"\{(.|\r|\n)+\}"
matched = re.search(reg, schedule_text)[0]
schedule_dict = json.loads(matched)
return schedule_dict
except json.JSONDecodeError:
logger.exception("解析日程失败: {}".format(schedule_text))
return False
def _parse_time(self, time_str: str) -> str:
"""解析时间字符串，转换为时间"""
return datetime.datetime.strptime(time_str, "%H:%M")
def get_current_task(self) -> str:
"""获取当前时间应该进行的任务"""
current_time = datetime.datetime.now().strftime("%H:%M")
# 找到最接近当前时间的任务
closest_time = None
min_diff = float("inf")
# 检查今天的日程
if not self.today_schedule:
return "摸鱼"
for time_str in self.today_schedule.keys():
diff = abs(self._time_diff(current_time, time_str))
if closest_time is None or diff < min_diff:
closest_time = time_str
min_diff = diff
# 检查昨天的日程中的晚间任务
if self.yesterday_schedule:
for time_str in self.yesterday_schedule.keys():
if time_str >= "20:00": # 只考虑晚上8点之后的任务
# 计算与昨天这个时间点的差异（需要加24小时）
diff = abs(self._time_diff(current_time, time_str))
if diff < min_diff:
closest_time = time_str
min_diff = diff
return closest_time, self.yesterday_schedule[closest_time]
if closest_time:
return closest_time, self.today_schedule[closest_time]
return "摸鱼"
def _time_diff(self, time1: str, time2: str) -> int:
"""计算两个时间字符串之间的分钟差"""
if time1 == "24:00":
time1 = "23:59"
if time2 == "24:00":
time2 = "23:59"
t1 = datetime.datetime.strptime(time1, "%H:%M")
t2 = datetime.datetime.strptime(time2, "%H:%M")
diff = int((t2 - t1).total_seconds() / 60)
# 考虑时间的循环性
if diff < -720:
diff += 1440 # 加一天的分钟
elif diff > 720:
diff -= 1440 # 减一天的分钟
# print(f"时间1[{time1}]: 时间2[{time2}]，差值[{diff}]分钟")
return diff
def print_schedule(self):
"""打印完整的日程安排"""
if not self._parse_schedule(self.today_schedule_text):
logger.warning("今日日程有误，将在下次运行时重新生成")
db.schedule.delete_one({"date": datetime.datetime.now().strftime("%Y-%m-%d")})
else:
logger.info("=== 今日日程安排 ===")
for time_str, activity in self.today_schedule.items():
logger.info(f"时间[{time_str}]: 活动[{activity}]")
logger.info("==================")
self.enable_output = False
async def main():
# 使用示例
scheduler = ScheduleGenerator()
await scheduler.initialize()
scheduler.print_schedule()
print("\n当前任务：")
print(await scheduler.get_current_task())
print("昨天日程：")
print(scheduler.yesterday_schedule)
print("今天日程：")
print(scheduler.today_schedule)
print("明天日程：")
print(scheduler.tomorrow_schedule)
# 当作为组件导入时使用的实例
bot_schedule = ScheduleGenerator()
if __name__ == "__main__":
import asyncio
# 当直接运行此文件时执行
asyncio.run(main())

24
src/plugins/schedule/schedule_generator.py
View File

@@ -5,8 +5,9 @@ from typing import Dict, Union
from nonebot import get_driver
from src.plugins.chat.config import global_config
# 添加项目根目录到 Python 路径
from src.plugins.chat.config import global_config
from ...common.database import db # 使用正确的导入语法
from ..models.utils_model import LLM_request
from src.common.logger import get_module_logger
@@ -165,24 +166,5 @@ class ScheduleGenerator:
logger.info(f"时间[{time_str}]: 活动[{activity}]")
logger.info("==================")
self.enable_output = False
# def main():
# # 使用示例
# scheduler = ScheduleGenerator()
# # new_schedule = scheduler.generate_daily_schedule()
# scheduler.print_schedule()
# print("\n当前任务：")
# print(scheduler.get_current_task())
# print("昨天日程：")
# print(scheduler.yesterday_schedule)
# print("今天日程：")
# print(scheduler.today_schedule)
# print("明天日程：")
# print(scheduler.tomorrow_schedule)
# if __name__ == "__main__":
# main()
# 当作为组件导入时使用的实例
bot_schedule = ScheduleGenerator()

3
template.env
View File

@@ -1,8 +1,6 @@
HOST=127.0.0.1
PORT=8080
ENABLE_ADVANCE_OUTPUT=false
# 插件配置
PLUGINS=["src2.plugins.chat"]
@@ -31,6 +29,7 @@ CHAT_ANY_WHERE_KEY=
SILICONFLOW_KEY=
# 定义日志相关配置
SIMPLE_OUTPUT=true # 精简控制台输出格式
CONSOLE_LOG_LEVEL=INFO # 自定义日志的默认控制台输出日志级别
FILE_LOG_LEVEL=DEBUG # 自定义日志的默认文件输出日志级别
DEFAULT_CONSOLE_LOG_LEVEL=SUCCESS # 原生日志的控制台输出日志级别（nonebot就是这一类）

17
template/bot_config_template.toml
View File

@@ -1,5 +1,5 @@
[inner]
version = "0.0.10"
version = "0.0.11"
#以下是给开发人员阅读的，一般用户不需要阅读
#如果你想要修改配置文件，请在修改后将version的值进行变更
@@ -66,12 +66,15 @@ model_r1_distill_probability = 0.1 # 麦麦回答时选择次要回复模型3
max_response_length = 1024 # 麦麦回答的最大token数
[willing]
willing_mode = "classical"
# willing_mode = "dynamic"
# willing_mode = "custom"
willing_mode = "classical" # 回复意愿模式 经典模式
# willing_mode = "dynamic" # 动态模式(可能不兼容)
# willing_mode = "custom" # 自定义模式（可自行调整
[memory]
build_memory_interval = 2000 # 记忆构建间隔 单位秒 间隔越低，麦麦学习越多，但是冗余信息也会增多
build_memory_distribution = [4,2,0.6,24,8,0.4] # 记忆构建分布，参数：分布1均值，标准差，权重，分布2均值，标准差，权重
build_memory_sample_num = 10 # 采样数量，数值越高记忆采样次数越多
build_memory_sample_length = 20 # 采样长度，数值越高一段记忆内容越丰富
memory_compress_rate = 0.1 # 记忆压缩率 控制记忆精简程度 建议保持默认,调高可以获得更多信息，但是冗余信息也会增多
forget_memory_interval = 1000 # 记忆遗忘间隔 单位秒 间隔越低，麦麦遗忘越频繁，记忆更精简，但更难学习
@@ -109,9 +112,7 @@ tone_error_rate=0.2 # 声调错误概率
word_replace_rate=0.006 # 整词替换概率
[others]
enable_advance_output = false # 是否启用高级输出
enable_kuuki_read = true # 是否启用读空气功能
enable_debug_output = false # 是否启用调试输出
enable_friend_chat = false # 是否启用好友聊天
[groups]
@@ -120,9 +121,9 @@ talk_allowed = [
123,
] #可以回复消息的群
talk_frequency_down = [] #降低回复频率的群
ban_user_id = [] #禁止回复消息的QQ号
ban_user_id = [] #禁止回复和读取消息的QQ号
[remote] #测试功能，发送统计信息，主要是看全球有多少只麦麦
[remote] #发送统计信息，主要是看全球有多少只麦麦
enable = true

18
webui.py
View File

@@ -4,11 +4,14 @@ import toml
import signal
import sys
import requests
try:
from src.common.logger import get_module_logger
logger = get_module_logger("webui")
except ImportError:
from loguru import logger
# 检查并创建日志目录
log_dir = "logs/webui"
if not os.path.exists(log_dir):
@@ -24,11 +27,13 @@ import ast
from packaging import version
from decimal import Decimal
def signal_handler(signum, frame):
"""处理 Ctrl+C 信号"""
logger.info("收到终止信号，正在关闭 Gradio 服务器...")
sys.exit(0)
# 注册信号处理器
signal.signal(signal.SIGINT, signal_handler)
@@ -74,11 +79,10 @@ WILLING_MODE_CHOICES = [
]
# 添加WebUI配置文件版本
WEBUI_VERSION = version.parse("0.0.9")
# ==============================================
# env环境配置文件读取部分
def parse_env_config(config_file):
@@ -445,9 +449,7 @@ def adjust_personality_less_probabilities(
def adjust_model_greater_probabilities(t_model_1_probability, t_model_2_probability, t_model_3_probability):
total = (
Decimal(str(t_model_1_probability)) +
Decimal(str(t_model_2_probability)) +
Decimal(str(t_model_3_probability))
Decimal(str(t_model_1_probability)) + Decimal(str(t_model_2_probability)) + Decimal(str(t_model_3_probability))
)
if total > Decimal("1.0"):
warning_message = (
@@ -459,9 +461,7 @@ def adjust_model_greater_probabilities(t_model_1_probability, t_model_2_probabil
def adjust_model_less_probabilities(t_model_1_probability, t_model_2_probability, t_model_3_probability):
total = (
Decimal(str(t_model_1_probability))
+ Decimal(str(t_model_2_probability))
+ Decimal(str(t_model_3_probability))
Decimal(str(t_model_1_probability)) + Decimal(str(t_model_2_probability)) + Decimal(str(t_model_3_probability))
)
if total < Decimal("1.0"):
warning_message = (
@@ -1212,7 +1212,7 @@ with gr.Blocks(title="MaimBot配置文件编辑") as app:
willing_mode = gr.Dropdown(
choices=WILLING_MODE_CHOICES,
value=config_data["willing"]["willing_mode"],
label="回复意愿模式"
label="回复意愿模式",
)
else:
willing_mode = gr.Textbox(visible=False, value="disabled")