def save_config(self): # configs.process = int(self.process_edit.text()) configs.path = self.path_edit.text() configs.Scalerfile_path = self.scaler_path_edit.text() configs.TDDIfile_path = self.tddi_path_edit.text() configs.UserDatafile_path = self.userdata_path_edit.text() with open("Config/configs.py", "w", encoding="utf-8") as f: f.write(f"# -*- coding: utf-8 -*-\n") # f.write(f"process = {configs.process}\n") f.write(f"path = \"{configs.path}\"\n") f.write(f"Scalerfile_path = \"{configs.Scalerfile_path}\"\n") f.write(f"TDDIfile_path = \"{configs.TDDIfile_path}\"\n") f.write(f"UserDatafile_path = \"{configs.UserDatafile_path}\"\n") time.sleep(0.5)这个怎么改为写入硬盘中

<think> 我们正在处理一个关于Python中`__init__`方法的问题。用户希望理解包含`__init__`方法的Python代码的功能和逻辑。 根据提供的引用，特别是引用[5]，我们可以了解到`__init__`方法与`__new__`方法的区别： - `__new__`方法负责创建对象（实例）。 - `__init__`方法负责对创建的对象进行初始化（设置实例属性）。 另外，引用[3]也提到：`__init__`方法在类的一个对象被建立时会被自动马上运行，用于初始化对象。 因此，我们可以这样解释： - 在Python中，当我们创建一个类的新实例时，会先调用`__new__`方法来创建实例，然后调用`__init__`方法来初始化这个实例的属性。 - `__init__`方法并不是构造函数（创建对象），而是初始化方法。它会在对象创建后立即被调用，用于设置对象的初始状态。 现在，我们来看引用[5]中的示例代码： ```python class Person(object): def __new__(cls, *args, **kwargs): print("__new__()方法被调用，函数中cls的id为：{0}".format(id(cls))) obj = super().__new__(cls) print("创建的obj对象的id为：{0}".format(id(obj))) return obj def __init__(self, name, age): print("__init__()被调用，函数中self的id为：{0}".format(id(self))) self.name = name self.age = age print("object类对象的id为：{0}".format(id(object))) print("Person类对象的id为：{0}".format(id(Person))) p1 = Person("张三", 20) print("p1这个Person类对象的id为：{0}".format(id(p1))) ``` 这段代码的功能和逻辑如下： 1. 定义了一个`Person`类，继承自`object`（在Python3中这是默认的，可以省略，但这里显式写出）。 2. 重写了`__new__`方法：这个方法在创建实例时被调用。它接收的第一个参数是类本身（`cls`），然后使用`super().__new__(cls)`创建该类的一个实例（`obj`），并返回这个实例。 3. 重写了`__init__`方法：这个方法在实例创建后（由`__new__`返回的实例）被调用，用于初始化实例属性。它接收实例（通常命名为`self`）以及其他参数（这里为`name`和`age`），然后将这些参数赋值给实例的属性。 执行过程： - 首先打印`object`类和`Person`类的id。 - 然后创建`Person`类的实例`p1`，传递参数`"张三"`和`20`。 - 在创建`p1`时： a. 调用`__new__`方法：打印传入的`cls`（即`Person`类）的id，然后创建实例`obj`，打印`obj`的id（这个id应该和后面`__init__`中的`self`以及`p1`的id相同，因为它们是同一个对象），并返回`obj`。 b. 然后调用`__init__`方法：将`__new__`返回的实例作为`self`传入，并传入`"张三"`和`20`，打印`self`的id（应该和`__new__`中创建的`obj`的id相同），然后给`self.name`和`self.age`赋值。 - 最后打印`p1`的id。 因此，输出结果将展示： - `object`类的id（一个固定的内存地址）。 - `Person`类的id（另一个内存地址）。 - 在`__new__`方法中，`cls`的id等于`Person`类的id。 - 创建的`obj`的id（也就是实例的内存地址）。 - 在`__init__`方法中，`self`的id等于`__new__`中创建的`obj`的id。 - 最后打印的`p1`的id也等于同一个地址。 所以，`__init__`方法的作用是：在实例创建后，对实例进行初始化，设置实例的属性（如`name`和`age`）。 注意：通常情况下，我们不需要重写`__new__`方法，除非需要控制对象的创建（比如实现单例、继承不可变类型等）。我们通常只重写`__init__`方法。 总结回答： 包含`__init__`方法的类在实例化时，会调用`__init__`方法进行初始化操作，设置实例的初始属性值。`__init__`方法不是创建实例的方法，而是初始化实例的方法。 根据用户要求，我们需要生成相关问题。 </think> ### Python `__init__`方法的功能和逻辑解释 在Python中，`__init__`方法是一个**特殊初始化方法**，当类的实例被创建时自动调用。它负责设置对象的初始状态，主要功能是为新创建的对象定义实例属性并赋初值[^3][^5]。 #### 核心逻辑和工作流程 1. **对象创建顺序**： - 创建对象时先调用`__new__`方法（负责内存分配和对象创建）； - 随后自动调用`__init__`方法（负责属性初始化）[^5]； - 数学表达：对象创建过程可表示为 $$ \text{对象} = \text{__new__()} \rightarrow \text{__init__()} $$ 2. **方法签名**： ```python def __init__(self, [参数1, 参数2...]): # 初始化代码 ``` - `self` 参数：指向新创建的实例对象（必需）； - 其他参数：创建实例时传递的初始化参数。 3. **典型功能**： - 定义实例属性（如 `self.name = name`） - 执行初始配置或验证 - 建立对象间的关联关系 - 加载初始数据 #### 示例代码解析 ```python class Person: def __init__(self, name, age): # 初始化方法 print("__init__()被调用") self.name = name # 设置实例属性 self.age = age # 设置实例属性 # 创建实例时自动触发__init__ p = Person("张三", 20) ``` - **执行过程**： 1. `Person("张三", 20)` 触发实例创建 2. 隐式调用`__new__`分配内存生成对象 3. 自动调用`__init__(self, "张三", 20)` 4. 设置 `self.name = "张三"`, `self.age = 20` #### 与相关概念的区别 | 特性 | `__init__` | `__init__.py`文件 | |---------------|--------------------------------|--------------------------------| | **类型** | 类方法 | 包标识文件 | | **作用域** | 单个类内部 | Python包目录 | | **主要功能** | 初始化对象实例 | 标识包/导出模块接口[^1][^2] | | **调用时机** | 实例创建时 | 包被导入时[^2][^4] | #### 关键注意事项 1. 不是构造函数（实际对象创建由`__new__`完成） 2. 必须包含`self`参数指向当前实例 3. 不需要返回值（隐式返回初始化后的实例） 4. 父类的`__init__`需显式调用（使用`super().__init__()`）

<think> 我们注意到用户已经有一个现成的config_loader.py文件，并且内容非常完整。用户的主要需求似乎是确保其中包含了特定的配置项（model_manager和cognitive_config）。因此，我们的任务是在不破坏原有结构的前提下，将所需的配置项整合进去。 分析： 1. 用户原有的ConfigLoader类已经通过环境变量和配置文件加载配置。 2. 用户要求确保config.json包含特定的配置项，但原有的ConfigLoader并没有加载config.json（它主要从环境变量和hardware_config.json加载）。 3. 我们需要修改ConfigLoader，使其能够加载并合并config.json中的配置。 修改计划： 步骤1：在ConfigLoader类中增加一个方法`_load_main_config`，用于加载config.json。 步骤2：在`_load_config`方法中合适的位置调用这个方法（建议在环境变量加载之后，其他配置加载之前）。 步骤3：将加载的配置合并到当前实例的属性中。 但是注意：原有的配置是通过环境变量设置的，而config.json是静态配置。我们需要考虑优先级（环境变量应覆盖json配置？还是反之？）。根据常规，环境变量优先级最高，所以应该先加载json，然后用环境变量覆盖。 然而，观察原有代码： - 先加载环境变量（`_load_environment_vars`） - 然后加载其他配置（路径、服务器、模型等） 我们计划： - 在`_load_environment_vars`之后立即加载config.json（这样环境变量可以覆盖json中的配置，但注意原有代码中其他配置（如服务器配置）是从环境变量获取的，所以如果我们要让config.json也能设置这些，就需要改变加载方式） 另一种思路：我们不在原有属性上设置，而是单独保存一个字典存放从config.json读取的配置，然后允许通过这个字典来获取配置。但这样会改变原有使用配置的方式（原来直接通过实例属性访问）。 权衡后，我们决定： - 在`_load_config`中，在加载环境变量后，加载config.json，并将其内容解析为一个字典。 - 然后，我们从这个字典中提取出我们关心的配置项（model_manager, cognitive_config）并赋值给实例属性。 - 同时，为了保持扩展性，我们将整个config.json的内容保存为一个属性（如self.main_config），这样其他地方也可以使用。 但是，原有代码已经将很多配置通过环境变量设置成了实例属性（如self.USE_GPU）。如果我们希望config.json中的配置能够覆盖环境变量，那么我们需要在环境变量设置之后，再用json中的配置覆盖。 然而，用户提供的config.json中有一个配置项"use_gpu"在model_manager下，而原有代码中self.USE_GPU是从环境变量来的。这就会造成不一致。 因此，我们需要统一配置的优先级顺序： 1. 环境变量（最高优先级） 2. config.json（次优先级） 3. 代码中的默认值（最低优先级） 但是，原有代码中，在加载环境变量后，其他配置方法（如`_load_model_config`）会使用环境变量设置实例属性。如果我们想用config.json覆盖，就需要在设置实例属性之前先加载config.json？但这样环境变量又会覆盖config.json。 所以调整顺序： 1. 先加载config.json（得到一个字典） 2. 然后加载环境变量（环境变量可以覆盖config.json中的配置） 3. 然后其他配置方法（如`_load_model_config`）使用环境变量和已经设置的实例属性（注意：这里可能会有冲突，因为原本这些方法是从环境变量读取，但现在我们可能希望它们也可以从config.json读取？） 这可能会引起较大改动。因此，我们采取另一种方案： 不改动原有加载顺序，而是在所有配置加载完成后，再加载config.json，并将其中的特定配置项合并到实例属性。但是注意，原有的一些配置项（如USE_GPU）已经根据环境变量设置好了，如果config.json中也有，我们要不要覆盖？ 根据用户需求，他们希望config.json中的配置被使用，所以我们应该让config.json的优先级高于环境变量？这需要明确。 考虑到用户之前特别强调config.json的内容，我们假设用户希望config.json的配置项具有较高优先级（即覆盖环境变量）。那么我们需要： 1. 在`_load_config`的最后，加载config.json。 2. 然后，用config.json中的配置去覆盖当前实例属性。 但是要注意，原有配置项是分散的（如USE_GPU是顶级属性，而config.json中是在model_manager下）。所以我们需要设计一个映射关系。 但是，为了减少复杂度和保持原有代码结构，我们决定： 1. 在`_load_config`的最后，添加一个步骤：加载并合并config.json。 2. 我们将config.json中的顶级键作为配置类别，然后对于每一个类别，我们将其作为实例的一个属性（字典形式），如果已经存在同名属性，则用字典合并（深合并）的方式更新。 具体步骤： 在ConfigLoader类中添加方法： def _load_main_config(self): """加载config.json配置文件""" config_file = self.CONFIG_DIR / 'config.json' if config_file.exists(): try: with open(config_file, 'r') as f: self.main_config = json.load(f) self.logger.info(f"✅ 已加载主配置文件: {config_file}") except Exception as e: self.logger.error(f"❌ 加载主配置文件失败: {str(e)}") self.main_config = {} else: self.logger.warning(f"⚠️ 未找到主配置文件: {config_file}") self.main_config = {} def _merge_main_config(self): """将主配置合并到当前配置""" if not hasattr(self, 'main_config') or not self.main_config: return # 遍历主配置的每个顶级键 for category, config_dict in self.main_config.items(): # 如果当前实例已有这个属性（且是字典），则合并 if hasattr(self, category) and isinstance(getattr(self, category), dict): existing_dict = getattr(self, category) # 深合并：用主配置的字典更新已有的字典 self._deep_merge(existing_dict, config_dict) else: # 否则直接设置属性 setattr(self, category, config_dict) # 特殊处理：如果config.json中有model_manager.use_gpu，我们希望它覆盖self.USE_GPU if 'model_manager' in self.main_config: model_mgr_config = self.main_config['model_manager'] if 'use_gpu' in model_mgr_config: self.USE_GPU = model_mgr_config['use_gpu'] @staticmethod def _deep_merge(base_dict, update_dict): """递归合并两个字典""" for key, value in update_dict.items(): if key in base_dict and isinstance(base_dict[key], dict) and isinstance(value, dict): ConfigLoader._deep_merge(base_dict[key], value) else: base_dict[key] = value 然后，在`_load_config`方法中： 在最后（即`_load_hardware_config`之后）添加： self._load_main_config() self._merge_main_config() 但是注意：用户原有的`_load_hardware_config`方法会加载硬件配置并设置self.HARDWARE_CONFIG，而我们的合并操作可能会覆盖它？因为我们也会处理config.json中的`hardware_config`键（如果有的话）。所以我们需要确保硬件配置的加载顺序和合并顺序。 另外，用户要求确保config.json中包含特定的配置项（model_manager和cognitive_config）。通过上述合并，这些配置项将作为实例属性存在（即self.model_manager和self.cognitive_config）。 但是注意：原有代码中没有这些属性，所以我们直接设置即可。 修改后的`_load_config`方法： def _load_config(self): ... # 原有的前9步 # 10. 加载硬件配置 self._load_hardware_config() # 11. 加载主配置文件config.json并合并 self._load_main_config() self._merge_main_config() # 12. 记录最终配置 self.log_config() 同时，我们需要在log_config方法中记录这些新配置： def log_config(self): ... # 原有的日志 # 如果存在model_manager配置，打印部分内容 if hasattr(self, 'model_manager'): self.logger.info(f"🧠 模型管理器配置: GPU={self.USE_GPU}, 最大内存模型数={getattr(self.model_manager, 'max_models_in_memory', 'N/A')}") if hasattr(self, 'cognitive_config'): self.logger.info(f"🤔 认知配置: 状态目录={getattr(self.cognitive_config, 'state_dir', 'N/A')}") 注意：我们之前已经将config.json中的model_manager.use_gpu同步到了self.USE_GPU，所以这里直接使用self.USE_GPU。 但是，我们也要考虑到，可能其他配置项也需要同步到原有属性？比如cognitive_config中的state_dir，原有代码中可能没有对应的属性。我们不需要强制同步，因为用户原有的代码可能没有使用cognitive_config，所以我们可以让用户通过config.cognitive_config['state_dir']来访问。 因此，我们只需要确保这两个配置字典（model_manager和cognitive_config）作为实例属性存在即可。 最后，由于原有代码中有一个全局实例config，所以任何地方都可以通过`from config.config_loader import config`来访问。 修改后的代码将保证： - config.json被加载并解析为字典，其顶级键成为config实例的属性（字典值）。 - 对于已经存在的属性（字典类型），执行深合并。 - 特殊处理model_manager中的use_gpu，将其同步到顶级属性USE_GPU（因为原有代码中模型配置使用USE_GPU）。 但是注意：原有代码中USE_GPU已经是顶级属性，而且是从环境变量加载的。我们在合并主配置时，如果config.json中的model_manager.use_gpu为false，那么我们会覆盖环境变量的值（因为我们的合并是在环境变量加载之后，且在设置USE_GPU之后）。这符合用户要求（config.json优先级高）。 修改代码： 由于用户已经提供了完整的config_loader.py，我们只给出需要修改的部分（避免重复整个文件）。 修改点1：在ConfigLoader类的`_load_config`方法末尾添加两步（加载主配置和合并） 修改点2：添加两个新方法`_load_main_config`和`_merge_main_config`，以及辅助方法`_deep_merge` 修改点3：在log_config方法中添加日志输出，显示新增的配置信息 考虑到用户可能已经修改了文件，我们提供差异化的修改方案（使用代码块展示需要添加的代码部分）。 注意：由于代码较长，我们只展示需要修改和添加的部分。 具体修改如下： 1. 在`_load_config`方法的最后（在`_load_hardware_config`之后，`log_config`之前）添加： # 加载主配置文件config.json self._load_main_config() self._merge_main_config() 2. 在类中添加新方法： def _load_main_config(self): """加载config.json配置文件""" config_file = self.CONFIG_DIR / 'config.json' if config_file.exists(): try: with open(config_file, 'r') as f: self.main_config = json.load(f) self.logger.info(f"✅ 已加载主配置文件: {config_file}") except Exception as e: self.logger.error(f"❌ 加载主配置文件失败: {str(e)}") self.main_config = {} else: self.logger.warning(f"⚠️ 未找到主配置文件: {config_file}") self.main_config = {} def _merge_main_config(self): """将主配置合并到当前配置""" if not hasattr(self, 'main_config') or not self.main_config: return # 遍历主配置的每个顶级键 for category, config_dict in self.main_config.items(): # 如果当前实例已有这个属性（且是字典），则合并 if hasattr(self, category) and isinstance(getattr(self, category), dict): existing_dict = getattr(self, category) # 深合并：用主配置的字典更新已有的字典 self._deep_merge(existing_dict, config_dict) else: # 否则直接设置属性 setattr(self, category, config_dict) # 特殊处理：如果config.json中有model_manager.use_gpu，我们希望它覆盖self.USE_GPU if 'model_manager' in self.main_config: model_mgr_config = self.main_config['model_manager'] if 'use_gpu' in model_mgr_config: # 注意：这里覆盖原有的USE_GPU属性 self.USE_GPU = model_mgr_config['use_gpu'] @staticmethod def _deep_merge(base_dict, update_dict): """递归合并两个字典""" for key, value in update_dict.items(): if key in base_dict and isinstance(base_dict[key], dict) and isinstance(value, dict): ConfigLoader._deep_merge(base_dict[key], value) else: base_dict[key] = value 3. 修改`log_config`方法，在最后添加： # 记录主配置中的关键信息 if hasattr(self, 'model_manager'): self.logger.info(f"🧠 模型管理器配置: 使用GPU={self.USE_GPU}, 内存中最大模型数={self.model_manager.get('max_models_in_memory', 'N/A')}") if hasattr(self, 'cognitive_config'): self.logger.info(f"🤔 认知配置: 状态目录={self.cognitive_config.get('state_dir', 'N/A')}, 回退阈值={self.cognitive_config.get('fallback_threshold', 'N/A')}") 注意：这里我们使用字典的get方法，以防配置项不存在。 由于用户已经有一个config_loader.py，我们只需要将上述代码添加到相应的位置即可。 完整代码修改后的文件过长，因此我们只给出修改部分。用户可以直接编辑现有的config_loader.py文件。 如果用户需要完整的文件，我们可以提供，但这里为了避免混淆，我们只提供修改指导。 考虑到用户可能不熟悉代码，我们也可以提供整个文件，但用户已经存在这个文件，所以我们选择提供修改指导。 最后，为了确保正确性，我们在修改后的代码中增加了一些日志，这样在运行时会看到加载和合并的信息。 注意：如果用户没有config.json文件，则不会影响原有逻辑（只会有警告日志）。 相关问题的回答： 用户提问：如何确保config.json被正确加载？ 回答：按照上述修改后，程序启动时会尝试加载config.json并合并配置，同时会打印日志。 修改后的代码将满足用户的需求：config.json中的配置（特别是model_manager和cognitive_config）会被加载并成为配置实例的属性。 现在，我们按照要求，在最后提出相关问题。 §§相关问题§§: 1. 如果config.json中的配置项与硬件配置文件冲突，会如何处理？ 2. 如何确保配置合并时的优先级顺序符合预期？ 3. 除了json格式，是否支持其他格式的配置文件（如yaml）？ 4. 如果配置文件过大，如何优化配置加载的性能？ </think> 我理解您的需求了。您已经有一个完整的 `config_loader.py` 文件，不需要创建新文件，只需要确保它能正确加载您指定的 `config.json` 配置。下面是针对您现有文件的修改方案： ```python # E:\AI_System\config/config_loader.py import os import sys import logging import json from pathlib import Path from dotenv import load_dotenv class ConfigLoader: _instance = None _initialized = False def __new__(cls): if cls._instance is None: cls._instance = super(ConfigLoader, cls).__new__(cls) return cls._instance def __init__(self): if not self._initialized: self._initialized = True self._setup_logger() self._load_config() self._ensure_dirs() def _setup_logger(self): self.logger = logging.getLogger('ConfigLoader') self.logger.setLevel(logging.INFO) ch = logging.StreamHandler() ch.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') ch.setFormatter(formatter) self.logger.addHandler(ch) def _load_config(self): """加载并解析所有配置""" self._determine_workspace_root() self._load_environment_vars() self._load_path_configs() self._load_server_config() # +++ 添加模型管理器配置加载 +++ self._load_model_manager_config() # +++ 添加认知系统配置加载 +++ self._load_cognitive_config() self._load_security_config() self._load_database_config() self._load_life_system_config() self._load_hardware_config() self.log_config() # +++ 新增模型管理器配置加载方法 +++ def _load_model_manager_config(self): """加载模型管理器配置""" config_file = self.CONFIG_DIR / 'config.json' if config_file.exists(): try: with open(config_file, 'r') as f: config_data = json.load(f) # 提取模型管理器配置 model_mgr = config_data.get('model_manager', {}) self.USE_GPU = model_mgr.get('use_gpu', False) self.MAX_MODEL_INSTANCES = model_mgr.get('max_models_in_memory', 3) # 特殊模型配置 self.SPECIAL_MODELS = model_mgr.get('special_models', {}) self.logger.info(f"✅ 已加载模型管理器配置: GPU={self.USE_GPU}, 最大模型数={self.MAX_MODEL_INSTANCES}") self.logger.debug(f"特殊模型: {list(self.SPECIAL_MODELS.keys())}") except Exception as e: self.logger.error(f"❌ 加载模型管理器配置失败: {str(e)}") self.USE_GPU = False self.MAX_MODEL_INSTANCES = 3 self.SPECIAL_MODELS = {} else: self.logger.warning(f"⚠️ 未找到配置文件: {config_file}") self.USE_GPU = False self.MAX_MODEL_INSTANCES = 3 self.SPECIAL_MODELS = {} # +++ 新增认知系统配置加载方法 +++ def _load_cognitive_config(self): """加载认知系统配置""" config_file = self.CONFIG_DIR / 'config.json' if config_file.exists(): try: with open(config_file, 'r') as f: config_data = json.load(f) # 提取认知系统配置 cognitive_cfg = config_data.get('cognitive_config', {}) self.COGNITIVE_STATE_DIR = Path(cognitive_cfg.get('state_dir', 'E:/AI_Workspace/system_state')) self.FALLBACK_THRESHOLD = cognitive_cfg.get('fallback_threshold', 0.8) # 确保目录存在 self.COGNITIVE_STATE_DIR.mkdir(parents=True, exist_ok=True) self.logger.info(f"✅ 已加载认知系统配置: 状态目录={self.COGNITIVE_STATE_DIR}, 回退阈值={self.FALLBACK_THRESHOLD}") except Exception as e: self.logger.error(f"❌ 加载认知系统配置失败: {str(e)}") self.COGNITIVE_STATE_DIR = Path('E:/AI_Workspace/system_state') self.FALLBACK_THRESHOLD = 0.8 else: self.logger.warning(f"⚠️ 未找到配置文件: {config_file}") self.COGNITIVE_STATE_DIR = Path('E:/AI_Workspace/system_state') self.FALLBACK_THRESHOLD = 0.8 # 以下保持原有方法不变（只需添加上述两个新方法） def _determine_workspace_root(self): """确定工作区根目录""" env_root = os.getenv('WORKSPACE_ROOT') if env_root: self.WORKSPACE_ROOT = Path(env_root) self.logger.info(f"✅ 使用环境变量指定工作区: {self.WORKSPACE_ROOT}") return possible_paths = [ Path("E:/AI_System"), Path(__file__).resolve().parent.parent, Path.cwd(), Path.home() / "AI_System" ] for path in possible_paths: if path.exists() and "AI_System" in str(path): self.WORKSPACE_ROOT = path self.logger.info(f"✅ 检测到有效工作区: {self.WORKSPACE_ROOT}") return self.WORKSPACE_ROOT = Path.cwd() self.logger.warning(f"⚠️ 未找到AI_System工作区，使用当前目录: {self.WORKSPACE_ROOT}") def _load_environment_vars(self): """加载.env文件中的环境变量""" env_path = self.WORKSPACE_ROOT / '.env' if env_path.exists(): load_dotenv(env_path) self.logger.info(f"✅ 已加载环境文件: {env_path}") else: self.logger.warning(f"⚠️ 未找到环境文件: {env_path} - 使用默认配置") self.ENV = os.getenv('FLASK_ENV', 'development') self.DEBUG_MODE = os.getenv('DEBUG_MODE', 'true').lower() == 'true' def _load_path_configs(self): """加载所有路径配置""" self.PROJECT_ROOT = self.WORKSPACE_ROOT self.AGENT_PATH = self._get_path('AGENT_PATH', 'agent') self.WEB_UI_PATH = self._get_path('WEB_UI_PATH', 'web_ui') self.MODEL_CACHE_DIR = self._get_path('MODEL_CACHE_DIR', 'model_cache') self.LOG_DIR = self._get_path('LOG_DIR', 'logs') self.CONFIG_DIR = self._get_path('CONFIG_DIR', 'config') self.CORE_DIR = self._get_path('CORE_DIR', 'core') self.COGNITIVE_ARCH_DIR = self._get_path('COGNITIVE_ARCH_DIR', 'cognitive_arch') self.ENVIRONMENT_DIR = self._get_path('ENVIRONMENT_DIR', 'environment') self.UTILS_DIR = self._get_path('UTILS_DIR', 'utils') self.RESOURCES_DIR = self._get_path('RESOURCES_DIR', 'resources') def _load_server_config(self): """加载服务器相关配置""" self.HOST = os.getenv('HOST', '0.0.0.0') self.PORT = int(os.getenv('FLASK_PORT', 8000)) self.GRADIO_PORT = int(os.getenv('GRADIO_PORT', 7860)) self.LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO').upper() self.logger.setLevel(getattr(logging, self.LOG_LEVEL, logging.INFO)) # 移除原有的_load_model_config方法，因为已经被新的_load_model_manager_config替代 def _load_security_config(self): """加载安全相关配置""" self.SECRET_KEY = os.getenv('SECRET_KEY', 'dev-secret-key') self.API_KEY = os.getenv('API_KEY', '') self.ENABLE_AUTH = os.getenv('ENABLE_AUTH', 'false').lower() == 'true' def _load_database_config(self): """加载数据库配置""" self.DB_TYPE = os.getenv('DB_TYPE', 'sqlite') self.DB_PATH = self._get_path('DB_PATH', 'environment/environment.db') self.DB_HOST = os.getenv('DB_HOST', 'localhost') self.DB_PORT = int(os.getenv('DB_PORT', 3306)) self.DB_NAME = os.getenv('DB_NAME', 'ai_system') self.DB_USER = os.getenv('DB_USER', 'ai_user') self.DB_PASSWORD = os.getenv('DB_PASSWORD', 'secure_password') def _load_life_system_config(self): """加载生活系统配置""" self.LIFE_SYSTEM_ENABLED = os.getenv('LIFE_SYSTEM_ENABLED', 'true').lower() == 'true' self.LIFE_SCHEDULE = { "wake_up": os.getenv('WAKE_UP', '08:00'), "breakfast": os.getenv('BREAKFAST', '08:30'), "lunch": os.getenv('LUNCH', '12:30'), "dinner": os.getenv('DINNER', '19:00'), "sleep": os.getenv('SLEEP', '23:00') } self.ENERGY_THRESHOLD = float(os.getenv('ENERGY_THRESHOLD', 0.3)) def _load_hardware_config(self): """加载硬件配置文件""" hardware_config_path = self.CONFIG_DIR / 'hardware_config.json' self.HARDWARE_CONFIG = {} if hardware_config_path.exists(): try: with open(hardware_config_path, 'r') as f: self.HARDWARE_CONFIG = json.load(f) self.logger.info(f"✅ 已加载硬件配置文件: {hardware_config_path}") except Exception as e: self.logger.error(f"❌ 解析硬件配置文件失败: {str(e)}") else: self.logger.warning(f"⚠️ 未找到硬件配置文件: {hardware_config_path}") def _get_path(self, env_var, default_dir): """获取路径配置，优先使用环境变量""" env_path = os.getenv(env_var) if env_path: path = Path(env_path) if not path.is_absolute(): path = self.WORKSPACE_ROOT / path return path return self.WORKSPACE_ROOT / default_dir def _ensure_dirs(self): """确保所有必要目录存在""" required_dirs = [ self.LOG_DIR, self.MODEL_CACHE_DIR, self.AGENT_PATH, self.WEB_UI_PATH, self.CONFIG_DIR, self.CORE_DIR, self.COGNITIVE_ARCH_DIR, self.ENVIRONMENT_DIR, self.UTILS_DIR, self.RESOURCES_DIR, self.COGNITIVE_STATE_DIR # +++ 确保认知状态目录存在 +++ ] for path in required_dirs: try: path.mkdir(parents=True, exist_ok=True) except Exception as e: self.logger.error(f"❌ 创建目录失败 {path}: {str(e)}") def log_config(self): """记录关键配置信息""" self.logger.info("=" * 60) self.logger.info(f"🏠 工作区根目录: {self.WORKSPACE_ROOT}") self.logger.info(f"🌿 环境: {self.ENV} (DEBUG: {self.DEBUG_MODE})") self.logger.info(f"🌐 主机: {self.HOST}:{self.PORT} (Gradio: {self.GRADIO_PORT})") self.logger.info(f"📝 日志级别: {self.LOG_LEVEL}") # +++ 添加模型配置信息 +++ self.logger.info(f"🧠 模型管理器: GPU={self.USE_GPU}, 最大模型数={self.MAX_MODEL_INSTANCES}") self.logger.info(f" 特殊模型: {list(self.SPECIAL_MODELS.keys())}") # +++ 添加认知配置信息 +++ self.logger.info(f"🤔 认知系统: 状态目录={self.COGNITIVE_STATE_DIR}, 回退阈值={self.FALLBACK_THRESHOLD}") self.logger.info(f"💾 模型缓存: {self.MODEL_CACHE_DIR}") self.logger.info(f"🔑 安全密钥: {'*****' if self.SECRET_KEY != 'dev-secret-key' else self.SECRET_KEY}") self.logger.info(f"⏰ 生活系统: {'启用' if self.LIFE_SYSTEM_ENABLED else '禁用'}") self.logger.info(f"🗄️ 数据库: {self.DB_TYPE}://{self.DB_USER}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}") self.logger.info("=" * 60) # 其他保持不变的辅助方法... # get_paths(), get_db_config(), get_life_schedule(), get_hardware_config() 等保持原样 # 全局配置实例 config = ConfigLoader() # 测试配置（可选） if __name__ == '__main__': print("=" * 60) print("测试配置加载器") print("=" * 60) print(f"工作区根目录: {config.WORKSPACE_ROOT}") print(f"模型管理器配置: GPU={config.USE_GPU}, 最大实例={config.MAX_MODEL_INSTANCES}") print(f"认知系统配置: 状态目录={config.COGNITIVE_STATE_DIR}, 阈值={config.FALLBACK_THRESHOLD}") print("=" * 60) ``` ### 修改说明： 1. **添加了两个核心方法**： - `_load_model_manager_config()`：专门加载模型管理器配置 - `_load_cognitive_config()`：专门加载认知系统配置 2. **移除了原有方法**： - 删除了原来的 `_load_model_config()`，因为新方法完全替代了它的功能 3. **配置目录自动创建**： - 在 `_ensure_dirs()` 中添加了对 `COGNITIVE_STATE_DIR` 的创建 - 确保 `E:/AI_Workspace/system_state` 目录会自动创建 4. **日志增强**： - 在 `log_config()` 中添加了模型管理和认知系统的配置日志 - 启动时会清晰显示所有关键配置项 ### 使用说明： 1. **保留现有文件结构**： - 确保 `config.json` 在 `E:\AI_System\config\` 目录中 - 保持所有其他文件位置不变 2. **配置文件内容**： - 确保 `config.json` 包含您指定的结构： ```json { "model_manager": { "use_gpu": true, "max_models_in_memory": 3, "special_models": { "deepseek-vl2": {"architecture": "DeepSeekVLVisionModel"}, "sdxl": {"pipeline": "DiffusionPipeline"} } }, "cognitive_config": { "state_dir": "E:/AI_Workspace/system_state", "fallback_threshold": 0.8 } } ``` 3. **系统启动**： - 无需额外操作，配置加载器会在系统启动时自动加载所有配置 - 在日志中会看到加载成功的确认信息