Update app.py

app.py

@@ -125,7 +125,8 @@ class EnhancedModelManager:
                 "model_name": model_info["name"],
                 "ai_probability": ai_probability,
                 "predicted_class": model_info["model"].config.id2label[predicted_class_idx],
-                "confidence": float(probabilities[0][predicted_class_idx].item())
+                "confidence": float(probabilities[0][predicted_class_idx].item()),
+                "raw_probability": ai_probability  # 保存原始概率用于校准
             }
         
         except Exception as e:
@@ -272,7 +273,6 @@ class EnhancedFeatureExtractor:
         self._extract_advanced_features(img_cv, features, image_id)
         
         return features
-    
     def _extract_color_features(self, img_array, features):
         """Extract color-related features"""
         if len(img_array.shape) == 3:
@@ -367,7 +367,6 @@ class EnhancedFeatureExtractor:
             # 边缘方向一致性 - AI生成图像通常边缘方向过于一致
             edge_dir_normalized = edge_dir_hist / np.sum(edge_dir_hist)
             features["edge_direction_consistency"] = float(np.max(edge_dir_normalized))
-    
     def _extract_texture_features(self, img_cv, features, image_id):
         """Extract texture-related features"""
         # 获取灰度图
@@ -476,7 +475,6 @@ class EnhancedFeatureExtractor:
                 corr_gb = np.corrcoef(noise_g, noise_b)[0,1]
                 
                 features["noise_channel_correlation"] = float((abs(corr_rg) + abs(corr_rb) + abs(corr_gb)) / 3)
-    
     def _extract_symmetry_features(self, img_cv, features):
         """Extract symmetry-related features"""
         h, w = img_cv.shape[:2]
@@ -604,7 +602,6 @@ class EnhancedFeatureExtractor:
                 features["freq_peak_prominence"] = float(np.mean(radial_mean[peaks]))
         except:
             pass
-    
     def _extract_advanced_features(self, img_cv, features, image_id):
         """Extract advanced features for AI detection"""
         # 获取灰度图
@@ -674,99 +671,99 @@ class EnhancedFeatureExtractor:
         except:
             pass
 #############################################
-# 特征分析与决策逻辑部分
+# 特征分析与决策逻辑部分 - 重新调整
 #############################################
 
-# 基于图像类型的特征阈值
+# 基于图像类型的特征阈值 - 更严格的阈值
 OPTIMIZED_THRESHOLDS = {
     "lbp_entropy": {
-        "default": 2.0,
-        "portrait": 1.9,
-        "landscape": 2.2,
+        "default": 1.8,  # 更严格的阈值
+        "portrait": 1.7,
+        "landscape": 1.9,
     },
     "freq_anisotropy": {
-        "default": 0.008,
-        "portrait": 0.007,
-        "landscape": 0.01,
+        "default": 0.005,  # 更严格的阈值
+        "portrait": 0.004,
+        "landscape": 0.006,
     },
     "texture_correlation": {
-        "default": 0.95,
-        "portrait": 0.92,
-        "landscape": 0.95,
+        "default": 0.97,  # 更严格的阈值
+        "portrait": 0.96,
+        "landscape": 0.97,
     },
     "horizontal_symmetry": {
-        "default": 0.85,
-        "portrait": 0.80,
-        "landscape": 0.85,
+        "default": 0.9,  # 更严格的阈值
+        "portrait": 0.88,
+        "landscape": 0.9,
     },
     "vertical_symmetry": {
-        "default": 0.85,
-        "portrait": 0.80,
-        "landscape": 0.85,
+        "default": 0.9,  # 更严格的阈值
+        "portrait": 0.88,
+        "landscape": 0.9,
     },
     "noise_spatial_std": {
-        "default": 0.3,
-        "portrait": 0.3,
-        "landscape": 0.4,
+        "default": 0.2,  # 更严格的阈值
+        "portrait": 0.2,
+        "landscape": 0.25,
     },
     "freq_ratio": {
-        "default": 0.05,
-        "portrait": 0.05,
-        "landscape": 0.1,
+        "default": 0.0,  # 更严格的阈值
+        "portrait": -0.05,
+        "landscape": 0.0,
     },
     "noise_spectrum_std": {
-        "default": 800,
-        "portrait": 800,
-        "landscape": 1000,
+        "default": 600,  # 更严格的阈值
+        "portrait": 600,
+        "landscape": 700,
     },
     "color_entropy": {
-        "default": 3.5,
-        "portrait": 3.5,
-        "landscape": 4.0,
+        "default": 3.0,  # 更严格的阈值
+        "portrait": 3.0,
+        "landscape": 3.2,
     },
     "lbp_uniformity": {
-        "default": 0.2,
-        "portrait": 0.2,
-        "landscape": 0.15,
+        "default": 0.25,  # 更严格的阈值
+        "portrait": 0.25,
+        "landscape": 0.2,
     },
     "noise_channel_correlation": {
-        "default": 0.5,
-        "portrait": 0.5,
-        "landscape": 0.4,
+        "default": 0.97,  # 更严格的阈值
+        "portrait": 0.97,
+        "landscape": 0.95,
     },
     "wavelet_h_entropy": {
-        "default": 3.0,
-        "portrait": 2.8,
-        "landscape": 3.2,
+        "default": 1.5,  # 更严格的阈值
+        "portrait": 1.4,
+        "landscape": 1.6,
     },
     "dct_entropy": {
-        "default": 4.0,
-        "portrait": 3.8,
-        "landscape": 4.2,
+        "default": 0.005,  # 更严格的阈值
+        "portrait": 0.004,
+        "landscape": 0.006,
     },
     "naturalness_index": {
-        "default": 1.5,
-        "portrait": 1.3,
-        "landscape": 1.7,
+        "default": 0.6,  # 更严格的阈值
+        "portrait": 0.55,
+        "landscape": 0.65,
     }
 }
 
-# 特征重要性权重
+# 特征重要性权重 - 调整权重
 FEATURE_IMPORTANCE = {
-    "lbp_entropy": 0.15,
-    "freq_anisotropy": 0.15,
-    "texture_correlation": 0.08,
-    "horizontal_symmetry": 0.03,
-    "vertical_symmetry": 0.03,
-    "noise_spatial_std": 0.08,
-    "freq_ratio": 0.05,
-    "noise_spectrum_std": 0.05,
-    "color_entropy": 0.08,
-    "lbp_uniformity": 0.05,
-    "noise_channel_correlation": 0.05,
-    "wavelet_h_entropy": 0.07,
-    "dct_entropy": 0.08,
-    "naturalness_index": 0.05
+    "lbp_entropy": 0.12,
+    "freq_anisotropy": 0.12,
+    "texture_correlation": 0.06,
+    "horizontal_symmetry": 0.02,
+    "vertical_symmetry": 0.02,
+    "noise_spatial_std": 0.06,
+    "freq_ratio": 0.04,
+    "noise_spectrum_std": 0.04,
+    "color_entropy": 0.06,
+    "lbp_uniformity": 0.04,
+    "noise_channel_correlation": 0.12,  # 增加权重
+    "wavelet_h_entropy": 0.12,  # 增加权重
+    "dct_entropy": 0.12,  # 增加权重
+    "naturalness_index": 0.06
 }
 
 def get_threshold(feature_name, image_type="default"):
@@ -778,7 +775,7 @@ def get_threshold(feature_name, image_type="default"):
                                                OPTIMIZED_THRESHOLDS[feature_name]["default"])
 
 def check_ai_specific_features(image_features):
-    """Enhanced check for AI-generated image features"""
+    """Enhanced check for AI-generated image features with stricter criteria"""
     ai_score = 0
     ai_signs = []
     
@@ -804,21 +801,32 @@ def check_ai_specific_features(image_features):
                            "freq_ratio", "noise_spectrum_std", "color_entropy",
                            "wavelet_h_entropy", "dct_entropy", "naturalness_index"]:
             if value < threshold:
-                feature_score = min(1.0, (threshold - value) / threshold * 2)
-                if feature_score > 0.5:
+                # 更严格的评分，只有显著低于阈值才给高分
+                feature_score = min(1.0, (threshold - value) / threshold * 1.5)
+                if feature_score > 0.7:  # 提高显著性阈值
                     ai_signs.append(f"{feature_name} 异常低 ({value:.2f})")
         
         # 高值表示AI生成的特征
         elif feature_name in ["texture_correlation", "horizontal_symmetry", "vertical_symmetry",
                              "lbp_uniformity", "noise_channel_correlation"]:
             if value > threshold:
-                feature_score = min(1.0, (value - threshold) / (1 - threshold) * 2)
-                if feature_score > 0.5:
+                # 更严格的评分，只有显著高于阈值才给高分
+                feature_score = min(1.0, (value - threshold) / (1 - threshold) * 1.5)
+                if feature_score > 0.7:  # 提高显著性阈值
                     ai_signs.append(f"{feature_name} 异常高 ({value:.2f})")
         
         # 累加加权分数
         ai_score += feature_score * importance
     
+    # 特征组合分析 - 检查特定组合模式
+    if ("dct_entropy" in image_features and image_features["dct_entropy"] < 0.005 and
+        "wavelet_h_entropy" in image_features and image_features["wavelet_h_entropy"] < 1.5 and
+        "noise_channel_correlation" in image_features and image_features["noise_channel_correlation"] > 0.97):
+        # 这种组合强烈表明是AI生成
+        ai_score = max(ai_score, 0.9)
+        if "特征组合模式" not in ai_signs:
+            ai_signs.append("特征组合模式: 多个关键特征同时异常")
+    
     # 计算检测到多少关键特征
     critical_count = len(ai_signs)
     if critical_count >= 5:
@@ -827,7 +835,6 @@ def check_ai_specific_features(image_features):
         ai_score = max(ai_score, 0.6)  # 更保守，从0.7改为0.6
     
     return min(ai_score, 1.0), ai_signs
-
 def detect_beauty_filter_signs(image_features):
     """Detect beauty filter traces"""
     beauty_score = 0
@@ -898,6 +905,27 @@ def detect_photoshop_signs(image_features):
     
     return min(ps_score, 1.0), ps_signs
 
+def calibrate_model_output(probability):
+    """校准模型输出，解决模型偏向真人的问题"""
+    # 如果模型输出总是在0.3-0.4之间，我们可以拉伸这个范围
+    if 0.25 <= probability <= 0.4:
+        # 将0.25-0.4范围拉伸到0.1-0.9
+        return 0.1 + (probability - 0.25) * (0.9 - 0.1) / (0.4 - 0.25)
+    return probability
+
+def calibrate_feature_score(score, signs):
+    """校准特征分析分数，解决特征分析偏向AI的问题"""
+    # 如果特征分数高但检测到的特征少，降低分数
+    if score > 0.7 and len(signs) < 3:
+        return 0.5 + (score - 0.5) * 0.5  # 降低分数
+    # 如果特征分数高且检测到多个特征，保持高分
+    elif score > 0.7 and len(signs) >= 4:
+        return score
+    # 中等分数情况
+    elif 0.4 < score <= 0.7:
+        return 0.4 + (score - 0.4) * 0.7  # 略微降低
+    return score
+
 def calculate_model_consistency(model_results):
     """Calculate the consistency between model predictions"""
     if not model_results:
@@ -917,46 +945,33 @@ def calculate_model_consistency(model_results):
     consistency = max(0.0, 1.0 - variance * 5)  # 缩放以获得合理的一致性分数
     
     return consistency
-
 def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, 
                          valid_models_count, ai_feature_score, model_consistency):
-    """Provide detailed analysis with two-level classification and confidence assessment"""
+    """Provide detailed analysis with improved confidence assessment"""
     
-    # 根据模型数量和一致性调整置信度
-    if model_consistency > 0.8 and valid_models_count >= 2:
-        confidence_prefix = "极高置信度："
-    elif model_consistency > 0.6 and valid_models_count >= 2:
+    # 根据模型和特征分析的一致性调整置信度
+    if abs(ai_probability - ai_feature_score) > 0.2:
+        confidence_prefix = "低置信度："
+        explanation = "（模型预测和特征分析结果存在较大差异）"
+    elif model_consistency > 0.8 and valid_models_count >= 2:
         confidence_prefix = "高置信度："
-    elif valid_models_count >= 1:
+        explanation = ""
+    elif model_consistency > 0.6 and valid_models_count >= 2:
         confidence_prefix = "中等置信度："
+        explanation = ""
     else:
         confidence_prefix = "低置信度："
+        explanation = ""
     
     # 计算编辑分数（在所有路径中都需要）
     combined_edit_score = max(ps_score, beauty_score)
     
-    # 当模型和特征分析严重不一致时降低置信度
-    if abs(ai_probability - ai_feature_score) > 0.4:
-        confidence_prefix = "低置信度："
-        explanation = "（模型预测和特征分析结果存在较大差异）"
-    else:
-        explanation = ""
-    
-    # 处理特征与模型判断不一致的情况
-    if ai_feature_score > 0.8 and ai_probability > 0.4:  # 添加条件
-        ai_probability = max(ai_probability, 0.7)  # 更保守，从0.8改为0.7
-        category = confidence_prefix + "AI生成图像" + explanation
-        description = "图像很可能是由AI完全生成，几乎没有真人照片的特征。"
-        main_category = "AI生成"
-    elif ai_feature_score > 0.6 and ai_probability > 0.3:  # 添加条件
-        ai_probability = max(ai_probability, 0.6)  # 更保守，从0.7改为0.6
-    
-    # 第一级分类：AI vs 真实
+    # 分类逻辑 - 从中立起点开始
     if ai_probability > 0.6:
         category = confidence_prefix + "AI生成图像" + explanation
         description = "图像很可能是由AI完全生成，几乎没有真人照片的特征。"
         main_category = "AI生成"
-    else:
+    elif ai_probability < 0.4:
         # 第二级分类：素人 vs 修图
         if combined_edit_score > 0.5:
             category = confidence_prefix + "真人照片，修图痕迹明显" + explanation
@@ -966,15 +981,14 @@ def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_s
             category = confidence_prefix + "真实素人照片" + explanation
             description = "图像很可能是未经大量处理的真人照片，保留了自然的细节和特征。"
             main_category = "真人照片-素人"
-    
-    # 处理边界情况 - 添加"不确定"类别
-    if 0.4 < ai_probability < 0.6 and abs(ai_probability - ai_feature_score) > 0.3:
-        category = "无法确定" + explanation
+    else:
+        # 处理边界情况 - 添加"无法确定"类别
+        category = confidence_prefix + "无法确定" + explanation
         description = "系统无法确定该图像是AI生成还是真实照片。模型预测和特征分析结果不一致，需要人工判断。"
         main_category = "无法确定"
     
     # 处理边界情况 - AI生成与高度修图
-    elif ai_probability > 0.45 and combined_edit_score > 0.7:
+    if 0.45 < ai_probability < 0.55 and combined_edit_score > 0.7:
         category = confidence_prefix + "真人照片，修图痕迹明显（也可能是AI生成）" + explanation
         description = "图像可能是真人照片经过大量后期处理，也可能是AI生成图像。由于现代AI技术与高度修图效果相似，难以完全区分。"
         main_category = "真人照片-修图明显"
@@ -985,8 +999,9 @@ def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_s
     beauty_details = "检测到的美颜特征：" + "、".join(beauty_signs) if beauty_signs else "未检测到明显的美颜特征。"
     
     return category, description, ps_details, ai_details, beauty_details, main_category
+
 def detect_ai_image(image):
-    """Enhanced main detection function with two-stage detection and improved decision logic"""
+    """Enhanced main detection function with improved decision logic"""
     if image is None:
         return {"error": "未提供图像"}
     
@@ -1020,6 +1035,9 @@ def detect_ai_image(image):
         model_result = model_manager.get_model_prediction(key, image)
         
         if model_result and "error" not in model_result:
+            # 校准模型输出
+            model_result["ai_probability"] = calibrate_model_output(model_result["ai_probability"])
+            
             results[key] = model_result
             weighted_ai_probability += model_result["ai_probability"] * model_info["weight"]
             valid_models += 1
@@ -1042,51 +1060,29 @@ def detect_ai_image(image):
     ps_score, ps_signs = detect_photoshop_signs(image_features)
     beauty_score, beauty_signs = detect_beauty_filter_signs(image_features)
     
-    # 协同决策：结合模型预测和特征分析
-    adjusted_probability = final_ai_probability
+    # 校准特征分析分数
+    calibrated_feature_score = calibrate_feature_score(ai_feature_score, ai_signs)
     
-    # 根据模型一致性调整特征分析的影响
-    if model_consistency > 0.7:
-        # 模型一致性高，增加模型预测的权重
-        if ai_feature_score > 0.8 and final_ai_probability > 0.4:
-            adjusted_probability = 0.7 * final_ai_probability + 0.3 * ai_feature_score
-        elif ai_feature_score > 0.6 and final_ai_probability > 0.3:
-            adjusted_probability = 0.6 * final_ai_probability + 0.4 * ai_feature_score
-        else:
-            adjusted_probability = 0.8 * final_ai_probability + 0.2 * ai_feature_score
-    else:
-        # 模型一致性低，增加特征分析的权重
-        if ai_feature_score > 0.8 and final_ai_probability > 0.4:
-            adjusted_probability = 0.4 * final_ai_probability + 0.6 * ai_feature_score
-        elif ai_feature_score > 0.6 and final_ai_probability > 0.3:
-            adjusted_probability = 0.5 * final_ai_probability + 0.5 * ai_feature_score
-        else:
-            adjusted_probability = 0.6 * final_ai_probability + 0.4 * ai_feature_score
+    # 从中立起点开始决策
+    adjusted_probability = 0.5
     
-    # 检查关键特征
-    key_ai_features_count = 0
-    
-    # LBP熵（微观纹理分析）
-    if "lbp_entropy" in image_features:
-        threshold = get_threshold("lbp_entropy", image_features.get("image_type", "default"))
-        if image_features["lbp_entropy"] < threshold:
-            key_ai_features_count += 1
-    
-    # 频率各向异性
-    if "freq_anisotropy" in image_features:
-        threshold = get_threshold("freq_anisotropy", image_features.get("image_type", "default"))
-        if image_features["freq_anisotropy"] < threshold:
-            key_ai_features_count += 1
-    
-    # 小波熵
-    if "wavelet_h_entropy" in image_features:
-        threshold = get_threshold("wavelet_h_entropy", image_features.get("image_type", "default"))
-        if image_features["wavelet_h_entropy"] < threshold:
-            key_ai_features_count += 1
+    # 根据校准后的模型和特征分析调整概率
+    if final_ai_probability > 0.7 or calibrated_feature_score > 0.8:
+        # 强AI证据
+        adjusted_probability = 0.5 + (final_ai_probability * 0.25 + calibrated_feature_score * 0.25)
+    elif final_ai_probability < 0.3 and calibrated_feature_score < 0.3:
+        # 强真人证据
+        adjusted_probability = 0.5 - ((0.3 - final_ai_probability) * 0.25 + (0.3 - calibrated_feature_score) * 0.25)
+    else:
+        # 证据不足，保持在中间区域
+        adjusted_probability = 0.5 + (final_ai_probability - 0.5) * 0.2 + (calibrated_feature_score - 0.5) * 0.2
     
-    # 多个关键特征强烈表明AI生成，但需要模型支持
-    if key_ai_features_count >= 2 and final_ai_probability > 0.3:
-        adjusted_probability = max(adjusted_probability, 0.6)  # 更保守，从0.7改为0.6
+    # 特征组合分析 - 强有力的组合证据
+    if ("dct_entropy" in image_features and image_features["dct_entropy"] < 0.005 and
+        "wavelet_h_entropy" in image_features and image_features["wavelet_h_entropy"] < 1.5 and
+        "noise_channel_correlation" in image_features and image_features["noise_channel_correlation"] > 0.97):
+        # 这种组合强烈表明是AI生成
+        adjusted_probability = max(adjusted_probability, 0.7)
     
     # 确保概率在有效范围内
     adjusted_probability = min(1.0, max(0.0, adjusted_probability))
@@ -1094,7 +1090,7 @@ def detect_ai_image(image):
     # 获取详细分析
     category, description, ps_details, ai_details, beauty_details, main_category = get_detailed_analysis(
         adjusted_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, 
-        valid_models, ai_feature_score, model_consistency
+        valid_models, calibrated_feature_score, model_consistency
     )
     
     # 构建最终结果
@@ -1106,7 +1102,8 @@ def detect_ai_image(image):
         "original_ai_probability": final_ai_probability,
         "ps_score": ps_score,
         "beauty_score": beauty_score,
-        "ai_feature_score": ai_feature_score,
+        "ai_feature_score": calibrated_feature_score,
+        "raw_feature_score": ai_feature_score,
         "model_consistency": model_consistency,
         "category": category,
         "main_category": main_category,
@@ -1130,7 +1127,6 @@ def detect_ai_image(image):
     # 返回两个值：JSON结果和标签数据
     label_data = {main_category: 1.0}
     return final_result, label_data
-
 def save_user_feedback(image_id, user_feedback):
     """Save user feedback for continuous learning"""
     if not image_id: