<think>根据错误信息，系统在导入`agent.base_module`时失败。这是因为在`agent`目录下缺少`base_module.py`文件，或者该文件中的类定义不正确。
解决方案：
1. 创建`base_module.py`文件，并定义`CognitiveModule`基类。
2. 确保`agent`目录中存在`base_module.py`文件。
以下是`base_module.py`的代码：
```python:agent/base_module.py
# E:\AI_System\agent\base_module.py
import logging
class CognitiveModule:
"""认知模块基类"""
def __init__(self, name):
self.name = name
self.logger = logging.getLogger(self.name)
self._init_logger()
def _init_logger(self):
"""初始化日志记录器"""
if not self.logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
def process_stimulus(self, stimulus):
"""处理刺激（子类必须实现）"""
raise NotImplementedError("子类必须实现process_stimulus方法")
def generate_response(self):
"""生成响应（子类必须实现）"""
raise NotImplementedError("子类必须实现generate_response方法")
```
然后，在`agent/cognitive_architecture.py`中，我们使用相对导入`from .base_module import CognitiveModule`，这样应该可以正确导入。
另外，在`main.py`中，我们还需要导入`EnvironmentInterface`，但根据错误堆栈，当前错误是缺少`base_module`，所以先解决这个。
如果问题仍然存在，请检查：
1. 文件路径：确保`base_module.py`位于`agent`目录下。
2. 导入语句：在`cognitive_architecture.py`中，使用`from .base_module import CognitiveModule`。
修改后，重新运行`main.py`。
如果还遇到其他模块缺失，请按照相同方式创建。
注意：在`agent`目录下，确保有`__init__.py`文件（可以是空文件），以表示这是一个包。
现在，我们创建`agent/__init__.py`（如果不存在的话）：
在`E:\AI_System\agent`目录下创建一个名为`__init__.py`的空文件。
总结步骤：
1. 创建`agent/base_module.py`，内容如上。
2. 确保`agent`目录下有`__init__.py`文件（可以是空文件）。
3. 重新运行`main.py`。
如果问题仍然存在，请提供最新的错误信息。
由于您要求直接给出文件，以下是修复所需的完整文件：
### 文件1: agent/base_module.py
```python
# agent/base_module.py
import logging
class CognitiveModule:
"""认知模块基类"""
def __init__(self, name):
self.name = name
self.logger = logging.getLogger(self.name)
self._init_logger()
self.logger.info(f"初始化认知模块: {self.name}")
def _init_logger(self):
"""初始化日志记录器"""
if not self.logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
def process_stimulus(self, stimulus):
"""处理刺激（子类必须实现）"""
raise NotImplementedError("子类必须实现process_stimulus方法")
def generate_response(self):
"""生成响应（子类必须实现）"""
raise NotImplementedError("子类必须实现generate_response方法")
```
### 文件2: agent/__init__.py
在`agent`目录下创建一个空文件`__init__.py`即可。
### 文件3: 更新后的agent/cognitive_architecture.py
确保在`cognitive_architecture.py`中导入基类的方式是相对导入：
```python
from .base_module import CognitiveModule
```
如果之前是绝对导入，请改为相对导入。
由于我们已经在`agent`目录下创建了`__init__.py`，并且有`base_module.py`，这样相对导入应该可以工作。
另外，在`main.py`中，我们还需要`EnvironmentInterface`，如果这个类在`agent/environment_interface.py`中，那么确保该文件存在并且包含这个类。
如果`environment_interface.py`不存在，请创建它，并定义`EnvironmentInterface`类：
### 文件4: agent/environment_interface.py
```python
# agent/environment_interface.py
import logging
from .base_module import CognitiveModule
class EnvironmentInterface(CognitiveModule):
"""环境接口"""
def __init__(self, coordinator=None, config=None):
super().__init__("EnvironmentInterface")
self.logger.info("初始化环境接口")
def get_input(self):
"""获取输入（简化实现）"""
# 实际项目中，这里应该从传感器、网络或用户输入获取数据
return {"content": {"text": "Hello, world!"}, "source": "user"}
def output(self, response):
"""输出响应（简化实现）"""
self.logger.info(f"系统输出: {response}")
```
这样，当`main.py`导入`EnvironmentInterface`时就不会出错。
请将上述文件放入对应位置，然后重新运行。
如果问题仍然存在，请检查整个项目的目录结构，确保所有文件都在正确的位置。
目录结构应该类似于：
```
E:\AI_System\
├── core\
├── agent\
│ ├── base_module.py
│ ├── cognitive_architecture.py
│ ├── environment_interface.py
│ ├── model_manager.py
│ └── __init__.py
├── config\
├── logs\
├── venv\
├── main.py
└── .env
```
最后，运行`main.py`。
如果还有错误，请提供最新的错误日志。</think>根据错误日志，系统在导入`agent.base_module`模块时失败。这通常是因为缺少`base_module.py`文件或文件内容不正确。我将为您提供完整的解决方案和所需文件：
### 1. 创建基础模块文件 (`agent/base_module.py`)
```python:agent/base_module.py
# E:\AI_System\agent\base_module.py
import logging
import abc
class CognitiveModule(abc.ABC):
"""认知模块基类 - 所有认知模块的抽象基类"""
def __init__(self, name: str):
self.name = name
self.logger = logging.getLogger(self.name)
self._init_logger()
self.logger.info(f"✅ 初始化认知模块: {self.name}")
def _init_logger(self):
"""初始化日志记录器"""
if not self.logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
@abc.abstractmethod
def process_stimulus(self, stimulus: dict):
"""处理刺激 - 抽象方法"""
pass
@abc.abstractmethod
def generate_response(self):
"""生成响应 - 抽象方法"""
pass
class EnvironmentModule:
"""环境模块基类 - 所有环境接口的抽象基类"""
def __init__(self, name: str):
self.name = name
self.logger = logging.getLogger(self.name)
self._init_logger()
self.logger.info(f"✅ 初始化环境模块: {self.name}")
def _init_logger(self):
"""初始化日志记录器"""
if not self.logger.handlers:
handler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
self.logger.setLevel(logging.INFO)
@abc.abstractmethod
def get_input(self):
"""获取输入 - 抽象方法"""
pass
@abc.abstractmethod
def output(self, response: dict):
"""输出响应 - 抽象方法"""
pass
```
### 2. 更新认知架构文件 (`agent/cognitive_architecture.py`)
```python:agent/cognitive_architecture.py
# E:\AI_System\agent\cognitive_architecture.py
import logging
from .base_module import CognitiveModule
# 内联实现自我认知模块 - 避免导入失败
class DigitalBodySchema:
def __init__(self):
self.self_map = {"boundary_strength": 0.5, "self_awareness": 0.3}
def is_part_of_self(self, stimulus):
"""判断刺激是否属于自我部分"""
text = stimulus.get("content", {}).get("text", "").lower()
self_keywords = ["i ", "me ", "my ", "self", "自己", "我"]
return any(keyword in text for keyword in self_keywords)
def strengthen_boundary(self, source):
"""加强自我边界"""
self.self_map["boundary_strength"] = min(1.0, self.self_map["boundary_strength"] + 0.1)
def get_self_map(self):
"""获取自我地图"""
return self.self_map.copy()
class SelfReferentialFramework:
def __init__(self):
self.self_model = {
"traits": {},
"beliefs": [],
"self_reflection_count": 0
}
def update_self_model(self, stimulus):
"""更新自我模型"""
text = stimulus.get("content", {}).get("text", "")
if "i am" in text.lower() or "my" in text.lower():
self.self_model["self_reflection_count"] += 1
def get_self_model(self):
"""获取自我模型"""
return self.self_model.copy()
class SelfNarrativeGenerator:
def __init__(self):
self.recent_stories = []
def generate_self_story(self, self_model):
"""生成自我叙事"""
count = self_model.get("self_reflection_count", 0)
story = f"这是一个关于自我的故事。自我反思次数: {count}"
self.recent_stories.append(story)
if len(self.recent_stories) > 5:
self.recent_stories.pop(0)
return story
def get_recent_stories(self):
"""获取最近的自我叙事"""
return self.recent_stories.copy()
# 认知系统类
class CognitiveSystem(CognitiveModule):
def __init__(self, name: str):
super().__init__(name)
# 初始化自我认知模块
self.digital_body = DigitalBodySchema()
self.self_framework = SelfReferentialFramework()
self.narrative_generator = SelfNarrativeGenerator()
self.logger.info("✅ 认知系统初始化完成")
def process_stimulus(self, stimulus: dict):
"""处理刺激"""
# 处理刺激并更新自我认知
if self.digital_body.is_part_of_self(stimulus):
self.digital_body.strengthen_boundary(stimulus.get("source"))
self.self_framework.update_self_model(stimulus)
def generate_response(self):
"""生成响应"""
self_model = self.self_framework.get_self_model()
return self.narrative_generator.generate_self_story(self_model)
def get_recent_stories(self):
"""获取最近的自我叙事"""
return self.narrative_generator.get_recent_stories()
def get_self_status(self):
"""获取自我状态"""
return {
"self_map": self.digital_body.get_self_map(),
"self_model": self.self_framework.get_self_model(),
"recent_stories": self.get_recent_stories()
}
```
### 3. 更新环境接口文件 (`agent/environment_interface.py`)
```python:agent/environment_interface.py
# E:\AI_System\agent\environment_interface.py
import logging
import time
import random
from .base_module import EnvironmentModule
class EnvironmentInterface(EnvironmentModule):
"""环境接口类 - 处理系统输入和输出"""
def __init__(self, coordinator=None, config=None):
super().__init__("EnvironmentInterface")
self.input_queue = []
self.last_interaction = time.time()
self.logger.info("✅ 环境接口初始化完成")
def get_input(self):
"""获取输入"""
# 模拟输入 - 实际系统中应替换为真实输入源
if not self.input_queue:
self._generate_sample_inputs()
if self.input_queue:
return self.input_queue.pop(0)
# 默认返回空输入
return {"content": {"text": ""}, "source": "system"}
def _generate_sample_inputs(self):
"""生成示例输入 - 用于测试"""
sample_inputs = [
{"content": {"text": "Hello, how are you?"}, "source": "user"},
{"content": {"text": "What is your name?"}, "source": "user"},
{"content": {"text": "Tell me about yourself."}, "source": "user"},
{"content": {"text": "I am feeling great today."}, "source": "user"},
{"content": {"text": "My name is Alex."}, "source": "user"},
]
self.input_queue.extend(sample_inputs)
def output(self, response: dict):
"""输出响应"""
self.logger.info(f"💬 系统响应: {response}")
# 实际系统中应添加发送到前端或存储的逻辑
print(f">> {response}")
def add_input(self, input_data: dict):
"""添加新输入到队列"""
self.input_queue.append(input_data)
self.last_interaction = time.time()
self.logger.info(f"📥 收到新输入: {input_data}")
```
### 4. 更新主启动文件 (`main.py`)
```python:main.py
# E:\AI_System\main.py
import os
import sys
import logging
import time
from pathlib import Path
from core.config import config
from agent.model_manager import ModelManager
from agent.cognitive_architecture import CognitiveSystem
from agent.environment_interface import EnvironmentInterface
def setup_logging():
"""配置日志系统"""
log_dir = config.get("LOG_DIR", "logs")
os.makedirs(log_dir, exist_ok=True)
log_file = Path(log_dir) / f"system_{time.strftime('%Y%m%d_%H%M%S')}.log"
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler(log_file),
logging.StreamHandler()
]
)
return logging.getLogger('Main')
def main():
"""主函数"""
logger = setup_logging()
logger.info("=" * 50)
logger.info("🚀 启动AI系统")
logger.info("=" * 50)
# 打印系统配置摘要
logger.info("系统配置摘要:")
logger.info(f"AGENT_NAME: {config.get('AGENT_NAME', '未设置')}")
logger.info(f"PROJECT_ROOT: {config.get('DIRECTORIES', {}).get('PROJECT_ROOT', '未设置')}")
logger.info(f"LOG_DIR: {config.get('LOG_DIR', '未设置')}")
logger.info(f"AGENT_DIR: {config.get('DIRECTORIES', {}).get('AGENT_DIR', '未设置')}")
logger.info(f"WEB_UI_DIR: {config.get('DIRECTORIES', {}).get('WEB_UI_DIR', '未设置')}")
logger.info(f"HOST: {config.get('NETWORK', {}).get('HOST', '未设置')}")
logger.info(f"FLASK_PORT: {config.get('NETWORK', {}).get('FLASK_PORT', '未设置')}")
logger.info(f"TEXT_BASE_MODEL: {config.get('MODEL_PATHS', {}).get('TEXT_BASE', '未设置')}")
logger.info(f"USE_GPU: {config.get('ENVIRONMENT', {}).get('USE_GPU', False)}")
logger.info(f"LOG_LEVEL: {config.get('ENVIRONMENT', {}).get('LOG_LEVEL', '未设置')}")
# 初始化模型管理器
try:
model_dir = config.get("MODEL_BASE_PATH", "models")
cache_dir = config.get("MODEL_CACHE_DIR", "model_cache")
device = "cuda" if config.get("ENVIRONMENT", {}).get("USE_GPU", False) else "cpu"
model_manager = ModelManager(
device=device,
model_dir=model_dir,
cache_dir=cache_dir
)
# 加载核心模型
default_model = config.get("DIRECTORIES", {}).get("DEFAULT_MODEL", "Qwen2-7B")
if model_manager.load_core_language_model(default_model):
logger.info(f"✅ 模型管理器初始化完成 | 设备: {device} | 默认模型: {default_model}")
else:
logger.error("❌ 模型加载失败，使用最小模型")
model_manager.load_core_language_model("minimal-model")
except Exception as e:
logger.error(f"❌ 模型管理器初始化失败: {str(e)}")
return
# 初始化认知系统
try:
cognitive_system = CognitiveSystem("核心认知系统")
logger.info("✅ 认知系统初始化完成")
except Exception as e:
logger.error(f"❌ 认知系统初始化失败: {str(e)}")
return
# 初始化环境接口
try:
environment = EnvironmentInterface()
logger.info("✅ 环境接口初始化完成")
except Exception as e:
logger.error(f"❌ 环境接口初始化失败: {str(e)}")
return
# 主循环
try:
logger.info("🏁 进入主运行循环")
while True:
# 获取环境输入
stimulus = environment.get_input()
# 处理刺激
cognitive_system.process_stimulus(stimulus)
# 生成响应
response = cognitive_system.generate_response()
# 输出响应
environment.output(response)
time.sleep(1.0) # 降低CPU使用率
except KeyboardInterrupt:
logger.info("🛑 用户中断，关闭系统")
except Exception as e:
logger.error(f"❌ 系统运行时错误: {str(e)}")
finally:
# 清理资源
model_manager.unload_model()
logger.info("🛑 系统已关闭")
if __name__ == "__main__":
main()
```
### 文件结构说明
请确保您的项目目录结构如下：
```
E:\AI_System\
├── core\
│ ├── config.py
│ └── model_loader.py
├── agent\
│ ├── base_module.py # 新增文件
│ ├── cognitive_architecture.py # 更新文件
│ ├── environment_interface.py # 更新文件
│ └── model_manager.py # 更新文件
├── config\
│ ├── default.json
│ └── local.json
├── logs\
├── venv\
├── main.py # 更新文件
└── .env
```
### 安装所需依赖
在运行前，请确保安装所有必要依赖：
```powershell
venv\Scripts\activate
pip install transformers diskcache python-dotenv prettytable huggingface_hub
```
### 运行系统
```powershell
python main.py
```
### 预期输出
系统启动后，您应该看到类似以下输出：
```
2025-08-28 10:00:00,000 - Main - INFO - 🚀 启动AI系统
2025-08-28 10:00:00,001 - Main - INFO - 系统配置摘要:
...
2025-08-28 10:00:00,100 - ModelManager - INFO - ✅ 使用ModelLoader加载认知模型成功: E:\AI_Models\Qwen2-7B
2025-08-28 10:00:00,101 - CognitiveSystem - INFO - ✅ 认知系统初始化完成
2025-08-28 10:00:00,102 - EnvironmentInterface - INFO - ✅ 环境接口初始化完成
2025-08-28 10:00:00,103 - Main - INFO - 🏁 进入主运行循环
2025-08-28 10:00:00,104 - EnvironmentInterface - INFO - 💬 系统响应: 这是一个关于自我的故事。自我反思次数: 1
>> 这是一个关于自我的故事。自我反思次数: 1
...
```
这些修改解决了以下问题：
1. 添加了缺失的`base_module.py`文件
2. 实现了认知模块和环境模块的基类
3. 完善了环境接口的输入输出逻辑
4. 添加了详细的日志记录
5. 确保所有模块正确继承基类
扫一扫
1637
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
