E:\AI_System\agent\model_manager.py
import os
import logging
from typing import Dict, Any
class ModelManager:
“”“模型管理器 - 修复初始化参数问题”“”
def __init__(self, model_registry: Dict[str, str] = None, cache_dir: str = "model_cache", use_gpu: bool = True): """ 初始化模型管理器 :param model_registry: 模型路径注册表 :param cache_dir: 缓存目录 :param use_gpu: 是否使用GPU """ self.logger = logging.getLogger("ModelManager") self.model_registry = model_registry or {} self.cache_dir = cache_dir self.use_gpu = use_gpu self.loaded_models = {} # 确保缓存目录存在 os.makedirs(cache_dir, exist_ok=True) self.logger.info(f"✅ 模型管理器初始化完成 (GPU: {'启用' if use_gpu else '禁用'})") self.logger.info(f"模型注册表: {list(model_registry.keys())}") def load_model(self, model_name: str): """加载指定模型""" if model_name not in self.model_registry: self.logger.error(f"未知模型: {model_name}") return False model_path = self.model_registry[model_name] if not os.path.exists(model_path): self.logger.error(f"模型路径不存在: {model_path}") return False # 实际加载逻辑 self.logger.info(f"加载模型: {model_name} ({model_path})") self.loaded_models[model_name] = { "path": model_path, "status": "loaded" } return True def unload_model(self, model_name: str = None): """卸载模型""" if model_name: if model_name in self.loaded_models: self.logger.info(f"卸载模型: {model_name}") del self.loaded_models[model_name] return True return False else: self.logger.info("卸载所有模型") self.loaded_models.clear() return True def get_model_info(self, model_name: str) -> Dict[str, Any]: """获取模型信息""" if model_name in self.loaded_models: return self.loaded_models[model_name] elif model_name in self.model_registry: return {"status": "registered", "path": self.model_registry[model_name]} return {"status": "unknown"} def list_models(self): """列出所有注册模型""" return list(self.model_registry.keys())
E:\AI_System\agent\cognitive_architecture.py
import os
import sys
import logging
import json
import time
import abc
from pathlib import Path
from agent.base_module import CognitiveModule
class CognitiveSystem(CognitiveModule):
“”“核心认知系统实现”“”
VERSION = "1.2.0" # 默认配置参数 DEFAULT_CONFIG = { "reasoning_depth": 3, # 推理深度级别（1-5） "memory_limit": 1000, # 短期记忆容量 "auto_reflection": True, # 是否启用自动反思 "learning_threshold": 0.8, # 学习触发阈值 "error_recovery": True, # 是否启用错误恢复机制 "max_concurrent_tasks": 5 # 最大并发任务数 } def __init__(self, name: str, model_manager, config: dict = None): """ 初始化认知系统 :param name: 认知系统名称 :param model_manager: 模型管理器实例 :param config: 可选配置字典，覆盖默认配置 """ super().__init__(name) self.model_manager = model_manager # 合并默认配置和用户配置 self.config = self.DEFAULT_CONFIG.copy() if config is not None: self.config.update(config) # 验证配置有效性 self._validate_config() # 初始化系统组件 self._initialize_components() self.mode = "TASK_EXECUTION" # 默认任务执行模式 self.command_handlers = { "help": self.handle_help, "hi": self.handle_greeting, "hello": self.handle_greeting, "你好": self.handle_greeting, "在吗": self.handle_greeting, "status": self.handle_status, "mode": self.handle_mode, "models": self.handle_models, } # 初始化记忆系统 self.memory = { "short_term": [], "long_term": {}, "last_accessed": time.time() } # 初始化日志 self.logger = logging.getLogger(f"CognitiveSystem.{name}") self.logger.info(f"✅ 认知系统初始化完成 (版本 {self.VERSION})") self.logger.info(f"当前模式: {self.mode}") self.logger.debug(f"系统配置: {self.config}") # 新增方法：处理用户命令 def process_command(self, command: str) -> str: """处理用户命令的核心方法""" try: self.logger.info(f"🧠 处理命令: {command}") # 分割命令和参数 parts = command.split(maxsplit=1) cmd = parts[0].lower() arg = parts[1] if len(parts) > 1 else "" # 查找命令处理器 handler = self.command_handlers.get(cmd, self.handle_default) return handler(arg) except Exception as e: self.logger.error(f"命令处理失败: {str(e)}", exc_info=True) return f"❌ 处理命令时出错: {str(e)}" # 命令处理函数 def handle_greeting(self, arg: str) -> str: """处理问候命令""" return f"你好，我是{self.name}！有什么可以帮您？" def handle_help(self, arg: str) -> str: """处理帮助命令""" return """ === 高级命令系统 === 基础命令: help - 显示此帮助信息 exit/quit - 退出系统 status - 查看系统状态 mode [mode]- 切换工作模式 (reflect, task, learn) 系统控制: models - 显示已加载模型 config [key] [value] - 修改配置 多行输入: 输入多行命令时，在最后一行以 ;; 结束 """ def handle_status(self, arg: str) -> str: """处理状态查询命令""" return ( f"系统状态:\n" f"- 认知系统: {self.name} v{self.VERSION}\n" f"- 当前模式: {self.mode}\n" f"- 最后访问: {self.memory['last_accessed']}\n" f"- 短期记忆: {len(self.memory['short_term'])}/{self.config['memory_limit']} 条" ) def handle_mode(self, arg: str) -> str: """处理模式切换命令""" if not arg: return "请指定模式: reflect, task, learn" mode_map = { "reflect": "SELF_REFLECTION", "task": "TASK_EXECUTION", "learn": "LEARNING" } new_mode = mode_map.get(arg.lower(), "") if new_mode: self.set_mode(new_mode) return f"已切换到 {new_mode} 模式" return f"❌ 无效模式: {arg} (可用选项: reflect, task, learn)" def handle_models(self, arg: str) -> str: """处理模型查询命令""" try: models = "\n".join([ f"- {name}: {path}" for name, path in self.model_manager.config.items() ]) return f"已配置模型:\n{models}" except Exception as e: return f"❌ 获取模型信息失败: {str(e)}" def handle_default(self, command: str) -> str: """默认命令处理器""" return f"正在处理您的请求: {command}..." # 以下为原有方法... def _validate_config(self): """验证配置参数有效性""" if not 1 <= self.config.get("reasoning_depth", 3) <= 5: raise ValueError("推理深度必须在1-5范围内") if self.config.get("memory_limit", 1000) < 100: raise ValueError("内存限制不能小于100") def _initialize_components(self): """初始化认知系统的各个子组件""" self.logger.debug("初始化推理引擎...") self.logger.debug("初始化记忆系统...") self.logger.debug("初始化学习系统...") self.logger.debug("初始化任务调度器...") def process_stimulus(self, stimulus: dict): """处理输入刺激""" try: self.logger.debug(f"处理刺激: {stimulus}") self.memory["last_accessed"] = time.time() if self.mode == "SELF_REFLECTION": return self._process_self_reflection(stimulus) elif self.mode == "LEARNING": return self._process_learning(stimulus) else: # TASK_EXECUTION return self._process_task(stimulus) except Exception as e: self.logger.error(f"处理刺激失败: {str(e)}", exc_info=True) return {"error": f"处理失败: {str(e)}"} def generate_response(self): """生成响应（保留方法）""" return {"status": "ready", "mode": self.mode} def get_current_mode(self): """获取当前模式""" return self.mode def set_mode(self, new_mode: str): """切换模式""" valid_modes = ["SELF_REFLECTION", "TASK_EXECUTION", "LEARNING"] if new_mode in valid_modes: self.mode = new_mode self.logger.info(f"切换到 {new_mode} 模式") return {"status": "success", "new_mode": new_mode} else: self.logger.warning(f"无效模式: {new_mode}") return {"status": "error", "message": f"无效模式: {new_mode}"} def _process_task(self, stimulus: dict): """处理任务执行""" task_type = stimulus.get("type", "general") content = stimulus.get("content", {}) self.logger.info(f"处理任务: {task_type}") if task_type == "question": return {"response": f"收到问题: {content.get('text', '')}"} elif task_type == "command": return {"response": f"执行命令: {content.get('text', '')}"} else: return {"response": f"处理通用任务: {json.dumps(content)}"} def _process_self_reflection(self, stimulus: dict): """处理自我反思""" self.logger.info("执行深度反思...") return {"reflection": "反思完成", "insights": []} def _process_learning(self, stimulus: dict): """处理学习任务""" self.logger.info("执行学习任务...") return {"learning": "学习完成", "knowledge": "新知识"} def save_state(self, path: str): """保存系统状态""" state = { "version": self.VERSION, "mode": self.mode, "last_accessed": self.memory["last_accessed"] } try: with open(path, 'w') as f: json.dump(state, f) self.logger.info(f"✅ 状态已保存到 {path}") return True except Exception as e: self.logger.error(f"保存状态失败: {str(e)}", exc_info=True) return False def load_state(self, path: str): """加载系统状态""" try: with open(path, 'r') as f: state = json.load(f) self.mode = state.get("mode", "TASK_EXECUTION") self.logger.info(f"✅ 状态已从 {path} 加载") return True except Exception as e: self.logger.error(f"加载状态失败: {str(e)}", exc_info=True) return False
#E:\AI_System\main.py
import os
import sys
import traceback
import threading
import time
import logging
from pathlib import Path
from core.config import config
from core.command_listener import start_command_listener
from agent.model_manager import ModelManager
from agent.cognitive_architecture import CognitiveSystem
from agent.environment_interface import EnvironmentInterface
def setup_logging():
“”“配置系统日志记录”“”
log_dir = Path(config.get(“LOG_DIR”, “logs”))
log_dir.mkdir(parents=True, exist_ok=True)
log_format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s" log_level = config.get("ENVIRONMENT.LOG_LEVEL", "INFO").upper() logging.basicConfig( level=getattr(logging, log_level), format=log_format, handlers=[ logging.FileHandler(log_dir / "ai_system.log", encoding='utf-8'), logging.StreamHandler() ] ) logger = logging.getLogger("Main") logger.info("日志系统初始化完成 (级别: %s)", log_level) return logger
def main():
“”“主函数”“”
logger = setup_logging()
logger.info("=" * 50) logger.info("🚀 启动AI系统 - 核心认知模式") logger.info("=" * 50) logger.info("系统配置摘要:") logger.info(f"项目根目录: {config.get('DIRECTORIES.PROJECT_ROOT', '未设置')}") logger.info(f"默认模型路径: {config.get('MODEL_PATHS.TEXT_BASE', '未设置')}") logger.info(f"日志级别: {config.get('ENVIRONMENT.LOG_LEVEL', 'INFO')}") # 初始化模型管理器 try: model_manager = ModelManager( model_registry=config.get("MODEL_PATHS", {}), cache_dir=config.get("MODEL_CACHE_DIR", "model_cache"), use_gpu=config.get("ENVIRONMENT.USE_GPU", True) ) logger.info("✅ 模型管理器初始化完成") base_model = config.get("MODEL_PATHS.TEXT_BASE") if base_model and model_manager.load_model("TEXT_BASE"): logger.info(f"✅ 基础模型已加载: {base_model}") except Exception as e: logger.error("❌ 模型管理器初始化失败: %s", str(e)) logger.error(traceback.format_exc()) return # 初始化认知系统接口 try: cognitive_system = CognitiveSystem( name=config.get("AGENT_NAME", "小蓝"), model_manager=model_manager, config=config.get("COGNITIVE_CONFIG", {}) ) logger.info("✅ 认知系统初始化完成 - 名称: %s", cognitive_system.name) except Exception as e: logger.error("❌ 认知系统初始化失败: %s", str(e)) logger.error(traceback.format_exc()) return # 初始化环境接口 try: environment_interface = EnvironmentInterface( name="环境接口", cognitive_system=cognitive_system, config={ "max_workers": config.get("MAX_WORKERS", 4), "response_timeout": config.get("AGENT_RESPONSE_TIMEOUT", 30.0), "log_level": config.get("ENVIRONMENT.LOG_LEVEL", "INFO") } ) logger.info("✅ 环境接口初始化完成") except Exception as e: logger.error("❌ 环境接口初始化失败: %s", str(e)) logger.error(traceback.format_exc()) return # 创建关闭处理函数 def shutdown_handler(): """系统关闭处理函数""" logger.info("🛑 收到关闭命令，开始关闭系统...") # 先停止命令监听器 if 'command_listener' in locals() and command_listener.running: command_listener.stop() # 然后停止环境接口 environment_interface.stop() logger.info("✅ 系统已完全关闭") sys.exit(0) # 自定义命令处理器 - 统一处理所有命令 def command_handler(command: str) -> dict: """处理用户命令 - 返回字典格式响应""" try: logger.info(f"🔄 处理命令: {command}") # 命令路由 cmd_lower = command.lower().strip() # 1. 系统命令处理 if cmd_lower in ["exit", "quit"]: return { "status": "success", "message": "接收到退出命令，正在关闭系统...", "action": "shutdown" } # 2. 其他命令转发给认知系统 logger.info("转发命令给认知系统: %s", command) response = cognitive_system.process_command(command) # 格式化输出响应 return { "status": "success", "content": response } except Exception as e: logger.error(f"❌ 命令处理错误: {str(e)}", exc_info=True) return { "status": "error", "error": f"处理命令时出错: {str(e)}", "command": command } # 启动命令监听器 - 作为唯一的输入来源 try: command_listener = start_command_listener( command_handler=command_handler, shutdown_handler=shutdown_handler ) logger.info("✅ 命令监听器已启动") except Exception as e: logger.error("❌ 命令监听器启动失败: %s", str(e)) logger.error(traceback.format_exc()) return logger.info("🌟 系统准备就绪! 输入命令控制模式 (输入 'help' 查看可用命令)") # 主循环：处理命令监听器的输出 try: while True: # 短暂休眠以避免CPU占用过高 time.sleep(0.1) # 检查是否收到退出信号 if not command_listener.running: break except KeyboardInterrupt: logger.info("🛑 收到中断信号，关闭系统...") shutdown_handler() except Exception as e: logger.error("❌ 主循环发生未预期错误: %s", str(e)) logger.error(traceback.format_exc()) shutdown_handler()
if name == “main”:
main()
{
“LOG_DIR”: “E:/AI_System/logs”,
“CONFIG_DIR”: “E:/AI_System/config”,
“MODEL_CACHE_DIR”: “E:/AI_System/model_cache”,
“AGENT_NAME”: “小蓝”,
“DEFAULT_USER”: “管理员”,
“MAX_WORKERS”: 4,
“AGENT_RESPONSE_TIMEOUT”: 30.0,
“MODEL_BASE_PATH”: “E:/AI_Models”,
// 模型路径 - 使用相对路径引用
“MODEL_PATHS”: {
“TEXT_BASE”: “
M
O
D
E
L
B
A
S
E
P
A
T
H
/
Q
w
e
n
2
−
7
B
"
,
"
T
E
X
T
C
H
A
T
"
:
"
MODEL
B
ASE
P
ATH/Qwen2−7B","TEXT
C
HAT":"{MODEL_BASE_PATH}/deepseek-7b-chat”,
“MULTIMODAL”: “
M
O
D
E
L
B
A
S
E
P
A
T
H
/
d
e
e
p
s
e
e
k
−
v
l
2
"
,
"
I
M
A
G
E
G
E
N
"
:
"
MODEL
B
ASE
P
ATH/deepseek−vl2","IMAGE
G
EN":"{MODEL_BASE_PATH}/sdxl”,
“YI_VL”: “
M
O
D
E
L
B
A
S
E
P
A
T
H
/
y
i
−
v
l
"
,
"
S
T
A
B
L
E
D
I
F
F
U
S
I
O
N
"
:
"
MODEL
B
ASE
P
ATH/yi−vl","STABLE
D
IFFUSION":"{MODEL_BASE_PATH}/stable-diffusion-xl-base-1.0”
},
// 网络配置 - 扁平化处理
“NETWORK_HOST”: “0.0.0.0”,
“FLASK_PORT”: 8000,
“GRADIO_PORT”: 7860,
// 数据库配置 - 敏感信息使用环境变量引用
“DB_HOST”: “localhost”,
“DB_PORT”: 5432,
“DB_NAME”: “ai_system”,
“DB_USER”: “ai_user”,
“DB_PASSWORD”: “${ENV:DB_PASSWORD}”, // 从环境变量获取
// 安全配置 - 密钥使用环境变量
“SECRET_KEY”: “${ENV:SECRET_KEY}”, // 从环境变量获取
// 环境配置 - 扁平化处理
“ENV_MODE”: “dev”,
“LOG_LEVEL”: “DEBUG”,
“USE_GPU”: true,
// 目录配置 - 使用基础路径引用
“PROJECT_ROOT”: “E:/AI_System”,
“DEFAULT_MODEL”: “
M
O
D
E
L
B
A
S
E
P
A
T
H
/
Q
w
e
n
2
−
7
B
"
,
"
W
E
B
U
I
D
I
R
"
:
"
MODEL
B
ASE
P
ATH/Qwen2−7B","WEB
U
I
D
IR":"{PROJECT_ROOT}/web_ui”,
“AGENT_DIR”: “${PROJECT_ROOT}/agent”
}
四个原文都发你了 改好后发我完整版！一定要完整 我直接复制 不想再思考了 懂？
最新发布
本文介绍了一种通过重写Python类的__new__方法来确保日志实例唯一性的技术。这种方法利用字典缓存已创建的日志实例，避免了多次实例化相同名称的日志对象，从而提高了效率。
扫一扫
3341
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
