Update utils/model_loader.py

utils/model_loader.py

@@ -150,45 +150,61 @@ class ModelManager:
                 sarcoI_cat_path = self.advisory_paths['sarcoI'] / "CatBoost_model.pkl"
                 logger.info(f"使用本地SarcoI建议模型: {sarcoI_cat_path}")
 
-            # SarcoI建议模型实际上是XGBoost模型（重命名为CatBoost_model.pkl）
-            try:
-                import xgboost as xgb
-                # 尝试XGBoost加载方式
-                try:
-                    self.advisory_models['sarcoI'] = xgb.XGBClassifier()
-                    self.advisory_models['sarcoI'].load_model(sarcoI_cat_path)
-                    logger.info("✅ SarcoI建议模型加载成功 (XGBoost格式)")
-                except:
-                    # 如果XGBoost加载失败，尝试pickle加载
-                    with open(sarcoI_cat_path, 'rb') as f:
-                        loaded_model = pickle.load(f)
-                        logger.info(f"🔍 SarcoI建议模型类型: {type(loaded_model)}")
-
-                        # 检查是否是有效的机器学习模型
-                        if hasattr(loaded_model, 'predict_proba'):
-                            self.advisory_models['sarcoI'] = loaded_model
-                            logger.info("✅ SarcoI建议模型加载成功 (pickle格式)")
-                        else:
-                            # 尝试从字典中提取模型
-                            if isinstance(loaded_model, dict):
-                                for key in ['model', 'classifier', 'estimator']:
-                                    if key in loaded_model and hasattr(loaded_model[key], 'predict_proba'):
-                                        self.advisory_models['sarcoI'] = loaded_model[key]
-                                        logger.info(f"✅ 从字典提取SarcoI建议模型成功 (键: {key})")
-                                        break
-                                else:
-                                    raise ValueError(f"无法从加载的对象中找到有效模型: {type(loaded_model)}")
-                            else:
-                                raise ValueError(f"加载的对象不是有效的机器学习模型: {type(loaded_model)}")
-            except ImportError:
-                logger.warning("XGBoost未安装，尝试pickle加载...")
-                with open(sarcoI_cat_path, 'rb') as f:
-                    loaded_model = pickle.load(f)
-                    if hasattr(loaded_model, 'predict_proba'):
-                        self.advisory_models['sarcoI'] = loaded_model
-                        logger.info("✅ SarcoI建议模型加载成功 (pickle格式)")
+            # SarcoI建议模型是CatBoost模型 - 优先使用pickle加载
+            with open(sarcoI_cat_path, 'rb') as f:
+                loaded_model = pickle.load(f)
+                logger.info(f"🔍 SarcoI建议模型类型: {type(loaded_model)}")
+
+                # 检查是否是有效的机器学习模型
+                if hasattr(loaded_model, 'predict_proba'):
+                    self.advisory_models['sarcoI'] = loaded_model
+                    logger.info("✅ SarcoI建议模型加载成功 (pickle格式)")
+                else:
+                    # 尝试从字典中提取模型
+                    if isinstance(loaded_model, dict):
+                        logger.info(f"🔍 字典键: {list(loaded_model.keys())}")
+
+                        # 尝试常见的模型键，特别是CatBoost相关的键
+                        model_keys = ['model', 'classifier', 'estimator', 'catboost_model', 'cb_model', 'best_model', 'trained_model', 'final_model', 'best_estimator']
+                        found_model = False
+
+                        for key in model_keys:
+                            if key in loaded_model:
+                                candidate_model = loaded_model[key]
+                                logger.info(f"🔍 尝试键 '{key}': {type(candidate_model)}")
+
+                                if hasattr(candidate_model, 'predict_proba'):
+                                    self.advisory_models['sarcoI'] = candidate_model
+                                    logger.info(f"✅ 从字典提取SarcoI建议模型成功 (键: {key})")
+                                    found_model = True
+                                    break
+
+                        if not found_model:
+                            # 如果没找到标准键，尝试所有值
+                            for key, value in loaded_model.items():
+                                logger.info(f"🔍 检查键 '{key}': {type(value)}")
+                                if hasattr(value, 'predict_proba'):
+                                    self.advisory_models['sarcoI'] = value
+                                    logger.info(f"✅ 从字典提取SarcoI建议模型成功 (键: {key})")
+                                    found_model = True
+                                    break
+
+                        if not found_model:
+                            # 最后尝试：如果字典只有一个值，直接使���
+                            if len(loaded_model) == 1:
+                                single_key = list(loaded_model.keys())[0]
+                                single_value = loaded_model[single_key]
+                                logger.info(f"🔍 字典只有一个键 '{single_key}': {type(single_value)}")
+                                if hasattr(single_value, 'predict_proba'):
+                                    self.advisory_models['sarcoI'] = single_value
+                                    logger.info(f"✅ 使用字典中唯一值作为SarcoI建议模型 (键: {single_key})")
+                                    found_model = True
+
+                        if not found_model:
+                            logger.error(f"❌ 字典内容详情: {[(k, type(v), hasattr(v, 'predict_proba') if hasattr(v, '__dict__') else 'N/A') for k, v in loaded_model.items()]}")
+                            raise ValueError(f"字典中没有找到有效的机器学习模型")
                     else:
-                        raise ValueError(f"模型加载失败: {type(loaded_model)}")
+                        raise ValueError(f"加载的对象不是有效的机器学习模型: {type(loaded_model)}")
 
             # SarcoII建议模型 (RandomForest)
             if self.use_hf_models and HF_HUB_AVAILABLE:
@@ -312,11 +328,20 @@ class ModelManager:
     def predict_advisory(self, user_data: Dict[str, float], model_type: str) -> Dict[str, Any]:
         """建议预测 - 高精确率"""
         try:
+            # 调试信息
+            logger.info(f"🔍 建议预测调试 - 模型类型: {model_type}")
+            logger.info(f"🔍 可用建议模型: {list(self.advisory_models.keys())}")
+
+            # 检查模型是否存在
+            if model_type not in self.advisory_models:
+                raise KeyError(f"建议模型 '{model_type}' 不存在，可用模型: {list(self.advisory_models.keys())}")
+
             # 准备特征数据
             features_df = self._prepare_features(user_data, model_type, mode='advisory')
-            
+
             # 模型预测
             model = self.advisory_models[model_type]
+            logger.info(f"🔍 使用模型: {type(model)}")
             probability = model.predict_proba(features_df)[0, 1]
             threshold = self.thresholds[model_type]['advisory']