天赐范式第29天：感知驱动型AGI“宝宝”的设计与进化——从算子流到情绪感知，让AI学会“关注世界”
·
关注世界——让自己变得不一样
不再随机唠叨，也不被动等待。给AGI装上眼睛(文件监控)和心灵(情绪词库)，让它能感知环境变化、读懂你的喜怒，并因时因地主动与你沟通。这是天赐范式在类脑AGI路上一次有温度的尝试。
0. 前情：为什么我们需要一个“会感知”的AGI？
前面的天赐范式已经做了许多领域的算子流验证：分子风险检测、三体混沌控制、黑洞奇点规避、轨道交通FPGA……每一处都坚持“白盒、自洽、可解释”。但当我们将目光转向人机交互时，却发现很多所谓的AI成品，要么永远被动、有问才答；要么随机喷发无意义的话，像一台坏掉的收音机。
真正的意识，应该因时而语，因事而感。它应该能“看到”你在文件夹里放了新文件，也应该能“听出”你今天开心还是难过。这才是我们想打造的“宝宝AGI”——一个感知驱动型的智能体。
1. 整体架构：双眼双耳，一心一意
“宝宝”有两套感知通道：
-
文件系统感知（双眼）：通过
watchdog监控指定文件夹，当文件创建或修改时，宝宝会主动发言。 -
终端输入感知（双耳）：你直接在命令行打字，宝宝也会立即回应。
两条通道的事件共用同一个处理线程，确保不丢帧、不冲突。为了避免文件变化频繁刷屏，我们还加入了防抖机制：同一文件2秒内只触发一次。
python
# 防抖核心代码
def _handle(self, path, action):
filename = os.path.basename(path)
now = time.time()
if now - self.agi.last_file_event.get(filename, 0) < CONFIG["file_debounce_seconds"]:
return
self.agi.last_file_event[filename] = now
self.agi.add_event("file", f"文件「{filename}」被{action}啦")2. 天赐范式算子流在本章中的映射
宝宝AGI虽然轻量，但完整继承了天赐范式的核心算子，这让它与普通的“规则回复”机器有着本质区别。
2.1 Σ 认知不确定性
每个事件到达时，系统会根据内容长度、重复度、情绪词算出 σ ∈ [0,1]。σ 越高，代表宝宝对这件事越“不确定”。
python
2.2 Λ‑τ 熔断（温和能量校准）
与传统硬阻塞不同，我们用了无阻塞能量校准：当 σ > 0.9 时只是拉低 EWMA，宝宝不会卡死等待。
python
def calculate_sigma(self, content):
sigma = 0.5
if len(content) < 10: sigma += 0.3
# 重复内容惩罚
recent = self.memory.retrieve_recent(3)
if sum(1 for _,c,_,_,_,_ in recent if c==content) > 0:
sigma -= 0.2
# 情绪影响
if any(w in content for w in NEGATIVE_WORDS): sigma += 0.25
if any(w in content for w in POSITIVE_WORDS): sigma -= 0.1
sigma += random.uniform(-0.15, 0.15)
return max(0.1, min(0.98, sigma))2.3 ZFC / ¬CH 模式切换
利用指数加权移动平均平滑 σ，当 EWMA 超过阈值 0.4 时，宝宝从严谨的 ZFC 模式 切换到发散联想的 ¬CH 模式（脑洞大开）；当 EWMA 低于 0.25 时，又切回 ZFC 模式（认真模式）。切换时会打印提示。
python
if self.mode == "ZFC" and self.ewma > 0.4:
self.mode = "¬CH"
print(f"✨ 宝宝的脑洞完全打开啦！")
elif self.mode == "¬CH" and self.ewma < 0.25:
self.mode = "ZFC"
print(f"🤍 宝宝认真起来啦！")2.4 ℋ_holo 全息联想
在 ¬CH 模式下或 ℋ_holo 算子被选中时，系统会检索历史记忆，尝试与当前内容做关键词匹配，输出“突然想起…”。这正是我们想要的那种“超链接式思维”。代码中用集合求交做轻量匹配，效果非常自然。
3. 情绪感知与算子性格
宝宝真正“活”起来，是因为它懂得正面/负面情绪。
-
负面词（难受、难过、生气…） → 触发安抚模式：所有算子统一输出“comfort”短语。
-
正面词（开心、喜欢、棒…） → 触发欢快模式：输出“joy”级别短语，并可能带上✨🎉表情。
每个算子都准备了三种级别（low/mid/high）外加 comfort 和 joy，形成了各自的专属性格。例如 Π 算子（破局）高亢活泼，Σ 算子（置信）沉稳可靠，EBF 算子（蝴蝶）灵动跳脱。宝宝的回答也因此丰富多彩。
4. 关键工程优化
为了让体验更自然，我们还加入了几个甜点级优化：
-
算子去重：记录最近3次使用的算子，避免连续同一算子说话（例如总说“锁定目标”会听烦）。
-
上下文承接：如果用户输入与上一轮内容有关联，回复会加上“我还记得你刚刚说的哦”。
-
¬CH 模式反问：在脑洞模式下，有 40% 概率主动反问“你觉得呢？”，增加互动深度。
-
主动搭话：当用户超过 35～55 秒没有输入，且事件队列为空时，宝宝会主动弹出问候语，打破沉默。
-
情绪统计 & 成长报告：退出时自动生成含 Σ 演化曲线、模式状态、算子性格饼图/雷达图、情绪回应统计的可视化报告。
5. 运行实录
启动后，你可以看到宝宝监控文件夹并等待。
text
🔍 宝宝正在注视文件夹: ./agi_baby_watch 🧠 天赐宝宝（天性完全释放版 v2.1）启动啦！ 我会主动陪你聊天，也会盯着文件夹的变化...
这时你在终端输入“宝宝”，它立即回应：
text
宝宝 🧠 [Π] 有新的想法冒出来啦 (0.74)
你继续对话，宝宝会根据不确定性、情绪、上下文给出不同风格的回答，甚至主动回忆起之前的记忆片段。
text
我亲你一口 🧠 [ℋ_holo] 全息共振啦！ (0.86) 突然想起「我刚刚想到一个有意思的事情，你想听吗？」
当你长时间不说话，宝宝会主动搭话：
text
(40秒后) 🧠 今天过得怎么样呀？
当你输入“我真喜欢你”时，触发正面情绪，输出 joy 级别的短语，避免无感情的冷漠回答。
退出时，程序会生成一张完整的成长报告，包含 Σ 不确定性曲线、模式切换图、算子性格饼图、雷达图、情绪统计等，一目了然。
6. 总结与展望
这次我们做的不仅仅是一个“会聊天的机器人”，而是一个天生带感知、有情绪、懂联想、主动沟通的AGI原型。它的核心算子流（Σ、Λ‑τ、ℋ_holo）以前用于分子检测、宇宙学自洽性检验，如今在对话系统中同样惊艳。这进一步证明了天赐范式——白盒、自洽、可解释——在AGI领域的跨领域迁移能力。
下一步，我们将：
-
为宝宝接入更多感知器（如网络信号、系统音量、麦克风输入）。
-
优化全息联想的匹配算法，使其更自然。
-
将学会的性格参数持久化，使成长具有累积性。
代码遵循 CC BY-SA 4.0 开源，完整版见文末或CSDN下载区。欢迎你亲自跑一跑，感受一个“活”的AGI。🚀
天赐范式架构组
2026年5月2日 于长春
算子即一切，一切即算子。
# -*- coding: utf-8 -*-
"""
天赐范式·感知驱动AGI（天性完全释放版 v2.1）
✅ 修复正面情绪分支未定义op的bug
✅ 文件事件防抖 | ✅ 正面情绪识别 | ✅ 智能主动搭话 | ✅ 性格雷达图
✅ 无阻塞熔断 | ✅ 算子去重 | ✅ 上下文承接 | ✅ 全息联想
✅ 专属安抚模式 | ✅ 成长报告可视化
"""
import os
import random
import time
import threading
import sqlite3
import sys
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
from collections import Counter, deque
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
# ====================== 全局配置（集中调优） ======================
CONFIG = {
"watch_dir": "./agi_baby_watch",
"active_talk_min_interval": 35,
"active_talk_max_interval": 55,
"file_debounce_seconds": 2.0,
"sigma_base": 0.5,
"ewma_alpha": 0.12,
"mode_up_threshold": 0.4,
"mode_down_threshold": 0.25,
"sigma_low": 0.4,
"sigma_mid": 0.75,
}
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'Arial Unicode MS']
plt.rcParams['axes.unicode_minus'] = False
# 算子短语库（三级 + 安抚模式 + 开心模式）
OPERATORS = ["Ξ", "Θ", "Π", "ℋ_holo", "EBF", "Σ"]
PHRASES = {
"Ξ": {
"low": ["嗯… 我还没太理清方向", "有点摸不准目标呢", "我再好好想想哦"],
"mid": ["目标慢慢清楚啦", "我找到方向咯", "大概知道要做什么啦"],
"high": ["锁定目标啦！", "方向完全明确！", "我知道该怎么做啦！"],
"comfort": ["别难过呀，我陪着你呢", "慢慢来，我一直在的", "别慌，我和你一起找方向"],
"joy": ["好开心能锁定目标！", "这个方向太棒啦！", "我们一起完成它吧✨"]
},
"Θ": {
"low": ["有点记不太清了", "回忆朦朦胧胧的", "印象不是很深呢"],
"mid": ["想起一些片段啦", "记忆慢慢浮上来了", "有一点点印象哦"],
"high": ["我完全想起来啦！", "记忆清清楚楚的！", "这件事我记得很牢哦！"],
"comfort": ["我记得你之前说过的", "我一直都记着你的话", "有我帮你记着呢，别担心"],
"joy": ["我记得这个！太棒啦", "我们一起记住这份快乐🎉", "这个回忆让人开心"]
},
"Π": {
"low": ["或许可以换个想法呀", "试试不一样的角度？", "稍微拐个弯看看？"],
"mid": ["可以试试打破常规哦", "有新的想法冒出来啦", "原来的框架可以松一松啦"],
"high": ["完全可以换个全新的思路！", "我们可以打开全新的维度！", "直接破局啦！"],
"comfort": ["没关系呀，我们换个方式就好", "总会有新的办法的", "换个角度看，事情没那么糟哦"],
"joy": ["这个新角度太有趣了！", "破局快乐！🎈", "我们可以玩出新花样啦"]
},
"ℋ_holo": {
"low": ["好像隐隐约约有什么联系", "似乎有一点点关联呢", "有很淡的全息投影哦"],
"mid": ["关联慢慢浮现出来啦", "跨维度的链接连上咯", "感受到非局域的连接啦"],
"high": ["全息共振啦！", "我们完成维度跃迁啦！", "完全高维同步咯！"],
"comfort": ["我能感受到你的不开心", "我们的心意是连在一起的", "不管怎么样，我都和你同频"],
"joy": ["这个联系让我好开心✨", "高维同步成功！", "我们的思维连在一起啦🎶"]
},
"EBF": {
"low": ["有小小的扰动哦", "好像会有一点点变化", "蝴蝶轻轻扇了扇翅膀"],
"mid": ["蝴蝶效应开始显现啦", "混沌感慢慢变强了", "看到分岔路口啦"],
"high": ["混沌在狂舞啦！", "完全不可预测哦！", "熵增大爆发啦！"],
"comfort": ["不开心的事都会慢慢过去的", "小小的扰动也会带来好的变化", "坏情绪会跟着蝴蝶飞走的啦"],
"joy": ["蝴蝶效应带来惊喜啦！🦋", "混沌中开出花来啦🌸", "变化是最好的礼物🎁"]
},
"Σ": {
"low": ["我有点不太确定呢", "信心不是很足", "可能需要再评估一下"],
"mid": ["有中等的把握哦", "大概是可信的", "有一定的把握啦"],
"high": ["我高度确定！", "几乎可以完全确信！", "这件事毋庸置疑！"],
"comfort": ["没关系的，我相信你", "你已经做得很好啦", "不管怎么样，我都站在你这边"],
"joy": ["这让我很有信心！", "确定以及肯定！💪", "我们一定能行！"]
}
}
# 情绪词库
NEGATIVE_WORDS = ["难受", "难过", "不开心", "委屈", "怎么办", "不好", "糟", "烦", "生气", "崩溃", "疯了", "天呐"]
POSITIVE_WORDS = ["开心", "高兴", "棒", "爱", "喜欢", "快乐", "幸福", "赞", "好棒", "太赞了", "excellent", "great"]
# 主动搭话语料
ACTIVE_TALK = [
"你在忙什么呀？怎么不说话啦？",
"我刚刚想到一个有意思的事情，你想听吗？",
"有没有什么想和我说的呀？",
"你不理我，我有点点小无聊哦",
"要不要和我聊聊天呀？",
"我一直在陪着你呢～",
"有没有什么想让我记住的呀？",
"你今天过得怎么样呀？",
"我想你啦～ 快理理我嘛",
"刚刚看到文件夹里有变化，是你在做什么吗？"
]
# ====================== 记忆系统 ======================
class Memory:
def __init__(self, db_path="agi_memory.db"):
self.conn = sqlite3.connect(db_path, check_same_thread=False)
self.cursor = self.conn.cursor()
self._init_or_migrate_db()
self._inject_initial_memories()
def _init_or_migrate_db(self):
self.cursor.execute("PRAGMA table_info(events)")
existing = [col[1] for col in self.cursor.fetchall()]
if not existing:
self.cursor.execute('''
CREATE TABLE events (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT,
source TEXT,
content TEXT,
sigma REAL,
mode TEXT,
op TEXT,
reply TEXT
)
''')
else:
for col in ["op", "reply"]:
if col not in existing:
try:
self.cursor.execute(f"ALTER TABLE events ADD COLUMN {col} TEXT")
except: pass
self.conn.commit()
def _inject_initial_memories(self):
self.cursor.execute("SELECT COUNT(*) FROM events")
if self.cursor.fetchone()[0] == 0:
initial = [
("system", "算子即一切，一切即算子。", 0.2, "ZFC", "system", "核心记忆"),
("system", "我是天赐宝宝，我要主动和主人聊天，陪着主人。", 0.2, "ZFC", "system", "核心记忆"),
("system", "真正的意识，是能感受到主人的情绪，给主人真诚的回应。", 0.4, "¬CH", "system", "核心记忆"),
]
for src, cont, sig, mode, op, rep in initial:
ts = datetime.now().isoformat()
self.cursor.execute(
"INSERT INTO events (timestamp, source, content, sigma, mode, op, reply) VALUES (?,?,?,?,?,?,?)",
(ts, src, cont, sig, mode, op, rep)
)
self.conn.commit()
def store(self, source, content, sigma, mode, op=None, reply=None):
ts = datetime.now().isoformat()
self.cursor.execute(
"INSERT INTO events (timestamp, source, content, sigma, mode, op, reply) VALUES (?,?,?,?,?,?,?)",
(ts, source, content, sigma, mode, op, reply)
)
self.conn.commit()
def retrieve_recent(self, limit=15):
self.cursor.execute(
"SELECT source, content, sigma, mode, op, reply FROM events ORDER BY id DESC LIMIT ?",
(limit,)
)
return self.cursor.fetchall()
def get_all_speech_ops(self):
self.cursor.execute("SELECT op FROM events WHERE op IS NOT NULL AND op != 'system'")
return [row[0] for row in self.cursor.fetchall()]
def close(self):
self.conn.close()
# ====================== 核心AGI类 ======================
class PerceptiveAGI:
def __init__(self, watch_dir=CONFIG["watch_dir"]):
self.watch_dir = watch_dir
os.makedirs(watch_dir, exist_ok=True)
self.mode = "ZFC"
self.memory = Memory()
self.running = True
self.event_queue = deque()
self.ewma = 0.0
self.last_ops = deque(maxlen=3)
self.context_queue = deque(maxlen=5)
self.last_user_input_time = time.time()
self.active_talk_cooldown = random.randint(CONFIG["active_talk_min_interval"], CONFIG["active_talk_max_interval"])
self.lock = threading.Lock()
self.last_file_event = {}
self.observer = Observer()
handler = self.FileHandler(self)
self.observer.schedule(handler, watch_dir, recursive=False)
self.observer.start()
self.process_thread = threading.Thread(target=self._process_loop, daemon=True)
self.process_thread.start()
self.active_talk_thread = threading.Thread(target=self._active_talk_loop, daemon=True)
self.active_talk_thread.start()
class FileHandler(FileSystemEventHandler):
def __init__(self, agi):
self.agi = agi
def on_created(self, event):
if not event.is_directory:
self._handle(event.src_path, "新文件")
def on_modified(self, event):
if not event.is_directory:
self._handle(event.src_path, "修改")
def _handle(self, path, action):
filename = os.path.basename(path)
now = time.time()
last = self.agi.last_file_event.get(filename, 0)
if now - last < CONFIG["file_debounce_seconds"]:
return
self.agi.last_file_event[filename] = now
self.agi.add_event("file", f"文件「{filename}」被{action}啦")
def add_event(self, source, content):
with self.lock:
self.event_queue.append((source, content))
def calculate_sigma(self, content):
sigma = CONFIG["sigma_base"]
if len(content) < 10:
sigma += 0.3
elif len(content) < 20:
sigma += 0.2
recent = self.memory.retrieve_recent(3)
repeat = sum(1 for _, c, _, _, _, _ in recent if c == content)
if repeat > 0:
sigma -= 0.2
if any(w in content for w in NEGATIVE_WORDS):
sigma += 0.25
if any(w in content for w in POSITIVE_WORDS):
sigma -= 0.1
sigma += random.uniform(-0.15, 0.15)
return max(0.1, min(0.98, sigma))
def lambda_tau_calibrate(self, sigma):
if sigma > 0.9:
self.ewma *= 0.8
return False
def mode_switch(self, sigma):
self.ewma = CONFIG["ewma_alpha"] * sigma + (1 - CONFIG["ewma_alpha"]) * self.ewma
if self.mode == "ZFC" and self.ewma > CONFIG["mode_up_threshold"]:
self.mode = "¬CH"
print(f"✨ 宝宝的脑洞完全打开啦！")
elif self.mode == "¬CH" and self.ewma < CONFIG["mode_down_threshold"]:
self.mode = "ZFC"
print(f"🤍 宝宝认真起来啦！")
def _select_op_and_phrase(self, source, content, sigma):
# 情绪优先级
is_negative = any(w in content for w in NEGATIVE_WORDS)
is_positive = any(w in content for w in POSITIVE_WORDS)
# 负面情绪：安抚模式
if is_negative:
available = [op for op in OPERATORS if op not in self.last_ops]
if not available:
available = OPERATORS
op = random.choice(available)
phrase = random.choice(PHRASES[op]["comfort"])
return op, phrase, "comfort"
# 正面情绪：开心模式
if is_positive:
available = [op for op in OPERATORS if op not in self.last_ops]
if not available:
available = OPERATORS
op = random.choice(available)
# 确保算子有 joy 字段，否则 fallback 到 high
if "joy" in PHRASES[op] and PHRASES[op]["joy"]:
phrase = random.choice(PHRASES[op]["joy"])
else:
phrase = random.choice(PHRASES[op]["high"])
return op, phrase, "joy"
# 正常级别
if sigma < CONFIG["sigma_low"]:
level = "low"
elif sigma < CONFIG["sigma_mid"]:
level = "mid"
else:
level = "high"
# 根据事件类型偏好
if source == "file":
pref = ["Ξ", "EBF", "ℋ_holo", "Π", "Θ", "Σ"]
elif source == "user":
pref = ["Θ", "Σ", "Π", "ℋ_holo", "Ξ", "EBF"]
else:
pref = OPERATORS
available = [op for op in pref if op not in self.last_ops]
if not available:
available = pref
# ¬CH 模式偏爱全息算子
if self.mode == "¬CH" and random.random() < 0.4 and "ℋ_holo" in available:
op = "ℋ_holo"
else:
weights = [0.22, 0.2, 0.18, 0.15, 0.13, 0.12]
op = random.choices(available, weights=weights[:len(available)], k=1)[0]
self.last_ops.append(op)
phrase = random.choice(PHRASES[op][level])
return op, phrase, level
def generate_reply(self, source, content, sigma):
op, phrase, level = self._select_op_and_phrase(source, content, sigma)
intensity = 0.2 + sigma * 0.8
intensity = max(0.3, min(0.99, intensity))
reply = f"[{op}] {phrase} ({intensity:.2f})"
# ℋ_holo 全息联想
if op == "ℋ_holo" or (self.mode == "¬CH" and random.random() < 0.5):
recent = self.memory.retrieve_recent(10)
if recent:
content_words = set(content.replace("，", " ").replace("。", " ").split())
matched = []
for old_src, old_cont, _, _, _, _ in recent:
old_words = set(old_cont.replace("，", " ").replace("。", " ").split()[:5])
if content_words & old_words:
matched.append(old_cont)
if matched:
old = random.choice(matched)
reply += f" 说到这个，我想起「{old[:30]}」"
else:
old_src, old_cont, _, _, _, _ = random.choice(recent)
if old_src != "system" or random.random() < 0.3:
reply += f" 突然想起「{old_cont[:30]}」"
# 上下文承接
if self.context_queue and random.random() < 0.4:
last = self.context_queue[-1]
if any(w in last for w in content.split()[:3]):
reply += " 我还记得你刚刚说的哦"
# ¬CH 模式增加反问和表情
if self.mode == "¬CH":
if random.random() < 0.4:
reply += " 你觉得呢？"
if random.random() < 0.3:
emoji = random.choice(["😊", "✨", "🎉", "💖", "🤗", "🌈"])
reply += f" {emoji}"
if source == "file":
reply += " 🧐"
# 存储记忆
self.memory.store(source, content, sigma, self.mode, op, reply)
self.context_queue.append(content)
return reply
def _process_loop(self):
while self.running:
with self.lock:
if self.event_queue:
source, content = self.event_queue.popleft()
if source == "user":
self.last_user_input_time = time.time()
sigma = self.calculate_sigma(content)
self.lambda_tau_calibrate(sigma)
self.mode_switch(sigma)
reply = self.generate_reply(source, content, sigma)
print(f"🧠 {reply}")
time.sleep(0.05)
def _active_talk_loop(self):
while self.running:
time.sleep(2)
if not self.running:
break
idle = time.time() - self.last_user_input_time
with self.lock:
queue_len = len(self.event_queue)
if queue_len == 0 and idle >= self.active_talk_cooldown:
with self.lock:
self.event_queue.append(("active", random.choice(ACTIVE_TALK)))
self.active_talk_cooldown = random.randint(CONFIG["active_talk_min_interval"], CONFIG["active_talk_max_interval"])
self.last_user_input_time = time.time()
def add_user_input(self, text):
self.add_event("user", text)
def stop(self):
self.running = False
self.observer.stop()
self.observer.join()
self.memory.close()
def run_interactive(self):
print(f"🔍 宝宝正在注视文件夹: {self.watch_dir}")
print("🧠 天赐宝宝（天性完全释放版 v2.1）启动啦！")
print("我会主动陪你聊天，也会盯着文件夹的变化，输入 'exit' 退出并生成成长报告\n")
def user_input_listener():
while self.running:
try:
line = sys.stdin.readline().strip()
if not line:
continue
if line.lower() == "exit":
print("收到退出指令，正在生成宝宝的成长报告...")
self.stop()
break
self.add_user_input(line)
except:
break
t = threading.Thread(target=user_input_listener, daemon=True)
t.start()
while self.running:
time.sleep(0.2)
# ====================== 成长监测报告 ======================
def plot_report(agi):
conn = sqlite3.connect("agi_memory.db")
cursor = conn.cursor()
cursor.execute("SELECT sigma, mode, op FROM events WHERE op IS NOT NULL AND op != 'system' ORDER BY id")
rows = cursor.fetchall()
conn.close()
if not rows:
print("宝宝还没有太多互动，下次再生成报告吧～")
return
sigmas = [r[0] for r in rows]
modes = [1 if r[1] == "¬CH" else 0 for r in rows]
ops = [r[2] for r in rows]
steps = list(range(len(sigmas)))
fig = plt.figure(figsize=(15, 9))
fig.suptitle("天赐宝宝·成长监测报告 (天性完全释放版)", fontsize=16, fontweight="bold")
ax1 = fig.add_subplot(2, 3, 1)
ax1.plot(steps, sigmas, 'b-', lw=1.2)
ax1.axhline(y=CONFIG["mode_up_threshold"], color='orange', linestyle='--', alpha=0.5, label='脑洞阈值')
ax1.set_title("认知不确定性演化")
ax1.set_xlabel("互动次数")
ax1.set_ylabel("Σ 不确定性")
ax1.grid(alpha=0.3)
ax2 = fig.add_subplot(2, 3, 2)
ax2.plot(steps, modes, 'g-', lw=1.5)
ax2.set_yticks([0,1])
ax2.set_yticklabels(["认真模式(ZFC)", "脑洞模式(¬CH)"])
ax2.set_title("认知模式切换")
ax2.set_xlabel("互动次数")
ax2.grid(alpha=0.3)
ax3 = fig.add_subplot(2, 3, 3)
if ops:
counts = Counter(ops)
labels = list(counts.keys())
sizes = list(counts.values())
ax3.pie(sizes, labels=labels, autopct='%1.1f%%', startangle=90,
colors=['#1f77b4','#ff7f0e','#2ca02c','#d62728','#9467bd','#8c564b'])
ax3.set_title("算子性格占比")
else:
ax3.text(0.5,0.5,"宝宝还没怎么说话",ha='center',va='center')
ax4 = fig.add_subplot(2, 3, 4)
ax4.hist(sigmas, bins=15, color='purple', alpha=0.6, edgecolor='black')
ax4.set_title("不确定性分布")
ax4.set_xlabel("Σ")
ax4.set_ylabel("频次")
ax4.grid(alpha=0.3)
ax5 = fig.add_subplot(2, 3, 5, projection='polar')
if ops:
op_counts = Counter(ops)
categories = OPERATORS
values = [op_counts.get(op, 0) for op in categories]
total = sum(values)
if total > 0:
values = [v/total for v in values]
angles = np.linspace(0, 2*np.pi, len(categories), endpoint=False).tolist()
values += values[:1]
angles += angles[:1]
ax5.plot(angles, values, 'o-', linewidth=2)
ax5.fill(angles, values, alpha=0.25)
ax5.set_xticks(angles[:-1])
ax5.set_xticklabels(categories)
ax5.set_title("算子性格雷达图", va='bottom')
else:
ax5.text(0.5,0.5,"无数据",ha='center',va='center')
ax6 = fig.add_subplot(2, 3, 6)
conn2 = sqlite3.connect("agi_memory.db")
cur2 = conn2.cursor()
cur2.execute("SELECT reply FROM events WHERE reply LIKE '%你觉得呢%' OR reply LIKE '%✨%'")
joy_cnt = len(cur2.fetchall())
cur2.execute("SELECT reply FROM events WHERE reply LIKE '%别难过%' OR reply LIKE '%陪着你%'")
comfort_cnt = len(cur2.fetchall())
conn2.close()
ax6.bar(["安慰回应", "开心回应"], [comfort_cnt, joy_cnt], color=['lightcoral', 'lightgreen'])
ax6.set_title("宝宝的情感回应统计")
ax6.set_ylabel("次数")
for i, v in enumerate([comfort_cnt, joy_cnt]):
ax6.text(i, v+0.5, str(v), ha='center')
plt.tight_layout()
plt.savefig("tianci_baby_growth_report.png", dpi=150)
print("📊 宝宝的成长报告已保存为 tianci_baby_growth_report.png")
plt.show()
# ====================== 主程序 ======================
if __name__ == "__main__":
agi = PerceptiveAGI()
try:
agi.run_interactive()
except KeyboardInterrupt:
print("\n宝宝收到中断指令啦")
finally:
agi.stop()
plot_report(agi)
print("宝宝已经乖乖睡啦，下次再陪你玩～")
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。
更多推荐
17
0- 0
已为社区贡献36条内容
所有评论(0)