Update app.py

app.py

@@ -5,10 +5,14 @@ import cv2
 from PIL import Image
 import time
 import os
+import json
+from datetime import datetime
 from scipy import stats
 from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
 from transformers import AutoImageProcessor, AutoModelForImageClassification
 from functools import lru_cache
+import pywt  # 用于小波变换
+import uuid  # 用于生成唯一ID
 
 # 设置缓存目录
 os.environ["TRANSFORMERS_CACHE"] = "/tmp/transformers_cache"
@@ -16,32 +20,36 @@ os.environ["HF_HOME"] = "/tmp/hf_home"
 os.makedirs("/tmp/transformers_cache", exist_ok=True)
 os.makedirs("/tmp/hf_home", exist_ok=True)
 
+# 创建反馈存储目录
+FEEDBACK_DIR = "/tmp/feedback"
+os.makedirs(FEEDBACK_DIR, exist_ok=True)
+
 #############################################
-# 模型管理部分
+# 模型管理部分 - 增强版
 #############################################
 
-class ModelManager:
-    """Manages model loading, caching and inference"""
+class EnhancedModelManager:
+    """Enhanced model manager with support for specialized AI detection models"""
     
     def __init__(self):
         self.models = {
-            "model1": {
-                "name": "umm-maybe/AI-image-detector",
+            "ai_detector": {
+                "name": "umm-maybe/AI-image-detector",  # 将来替换为CNNDetection
                 "processor": None,
                 "model": None,
-                "weight": 0.5
+                "weight": 0.6  # 增加专业AI检测模型权重
             },
-            "model2": {
-                "name": "microsoft/resnet-50",
+            "general_classifier1": {
+                "name": "microsoft/resnet-50",  # 将来替换为DFDC模型
                 "processor": None,
                 "model": None,
-                "weight": 0.25
+                "weight": 0.2  # 降低通用模型权重
             },
-            "model3": {
-                "name": "google/vit-base-patch16-224",
+            "general_classifier2": {
+                "name": "google/vit-base-patch16-224",  # 保留作为辅助模型
                 "processor": None,
                 "model": None,
-                "weight": 0.25
+                "weight": 0.2  # 降低通用模型权重
             }
         }
         self.loaded_models = set()
@@ -116,7 +124,8 @@ class ModelManager:
             return {
                 "model_name": model_info["name"],
                 "ai_probability": ai_probability,
-                "predicted_class": model_info["model"].config.id2label[predicted_class_idx]
+                "predicted_class": model_info["model"].config.id2label[predicted_class_idx],
+                "confidence": float(probabilities[0][predicted_class_idx].item())
             }
         
         except Exception as e:
@@ -155,7 +164,7 @@ class ModelManager:
         predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower()
         
         # 检查AI相关关键词
-        ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer"]
+        ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer", "digital", "cgi", "rendered"]
         for keyword in ai_keywords:
             if keyword in predicted_class:
                 return float(probabilities[0][predicted_class_idx].item())
@@ -164,14 +173,13 @@ class ModelManager:
         if "ai" in predicted_class or "generated" in predicted_class or "fake" in predicted_class:
             return float(probabilities[0][predicted_class_idx].item())
         else:
-            return 1 - float(probabilities[0][predicted_class_idx].item())
-
+            return 0.3  # 降低默认AI概率，更保守的判断
 #############################################
-# 特征提取部分
+# 特征提取部分 - 增强版
 #############################################
 
-class FeatureExtractor:
-    """Optimized image feature extraction"""
+class EnhancedFeatureExtractor:
+    """Enhanced image feature extraction with advanced features"""
     
     def __init__(self):
         # 中间结果缓存
@@ -181,6 +189,31 @@ class FeatureExtractor:
         """Clear the cache between images"""
         self.cache = {}
     
+    def detect_image_type(self, image):
+        """Detect the type of image (portrait, landscape, etc.)"""
+        img_array = np.array(image)
+        
+        # 检测人脸
+        try:
+            face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+            if len(img_array.shape) == 3:
+                gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+            else:
+                gray = img_array
+            faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+            
+            if len(faces) > 0:
+                return "portrait"
+        except:
+            pass
+        
+        # 检查是否为风景图 (简单启发式方法)
+        if image.width > image.height * 1.5:
+            return "landscape"
+        
+        # 默认类型
+        return "general"
+    
     @lru_cache(maxsize=8)
     def get_grayscale(self, image_id):
         """Get grayscale version of image with caching"""
@@ -217,7 +250,12 @@ class FeatureExtractor:
         image_id = id(image)
         self.cache['image_id'] = image_id
         
+        # 检测图像类型
+        image_type = self.detect_image_type(image)
+        self.cache['image_type'] = image_type
+        
         features = {}
+        features["image_type"] = image_type
         
         # 基本特征
         features["width"] = image.width
@@ -231,6 +269,7 @@ class FeatureExtractor:
         self._extract_noise_features(img_cv, features)
         self._extract_symmetry_features(img_cv, features)
         self._extract_frequency_features(img_cv, features, image_id)
+        self._extract_advanced_features(img_cv, features, image_id)
         
         return features
     
@@ -276,6 +315,18 @@ class FeatureExtractor:
             g_entropy = stats.entropy(g_hist + 1e-10)
             b_entropy = stats.entropy(b_hist + 1e-10)
             features["color_entropy"] = float((r_entropy + g_entropy + b_entropy) / 3)
+            
+            # 颜色一致性 - AI生成图像通常颜色过于一致
+            color_blocks = []
+            for i in range(0, h-block_size, stride):
+                for j in range(0, w-block_size, stride):
+                    block = img_array[i:i+block_size, j:j+block_size]
+                    avg_color = np.mean(block, axis=(0,1))
+                    color_blocks.append(avg_color)
+            
+            if color_blocks:
+                color_blocks = np.array(color_blocks)
+                features["color_consistency"] = float(1.0 - np.std(color_blocks) / 128.0)
     
     def _extract_edge_features(self, img_cv, features, image_id):
         """Extract edge-related features"""
@@ -312,6 +363,10 @@ class FeatureExtractor:
         if np.sum(mask) > 0:
             edge_dir_hist, _ = np.histogram(edge_direction[mask], bins=18, range=(-180, 180))
             features["edge_direction_entropy"] = float(stats.entropy(edge_dir_hist + 1e-10))
+            
+            # 边缘方向一致性 - 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"""
@@ -375,6 +430,9 @@ class FeatureExtractor:
             lbp_hist, _ = np.histogram(lbp, bins=n_points + 2, range=(0, n_points + 2))
             lbp_hist = lbp_hist.astype(float) / (sum(lbp_hist) + 1e-10)
             features["lbp_entropy"] = float(stats.entropy(lbp_hist + 1e-10))
+            
+            # LBP一致性 - AI生成图像通常LBP模式过于一致
+            features["lbp_uniformity"] = float(np.sum(lbp_hist**2))
         except Exception as e:
             print(f"LBP计算错误: {e}")
     
@@ -406,6 +464,18 @@ class FeatureExtractor:
                     
             if noise_blocks:
                 features["noise_spatial_std"] = float(np.std(noise_blocks))
+                
+            # 噪声颜色通道相关性 - 真实照片的噪声在通道间相关性较低
+            if len(img_cv.shape) == 3:
+                noise_r = noise[:,:,0].flatten()
+                noise_g = noise[:,:,1].flatten()
+                noise_b = noise[:,:,2].flatten()
+                
+                corr_rg = np.corrcoef(noise_r, noise_g)[0,1]
+                corr_rb = np.corrcoef(noise_r, noise_b)[0,1]
+                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"""
@@ -438,6 +508,33 @@ class FeatureExtractor:
                     diff = cv2.absdiff(top_half, bottom_half)
                 v_symmetry = 1 - float(np.mean(diff) / 255)
                 features["vertical_symmetry"] = v_symmetry
+                
+        # 径向对称性 - 对于人脸等中心对象很有用
+        if min(h, w) > 100:  # 只对足够大的图像计算
+            try:
+                center_y, center_x = h // 2, w // 2
+                max_radius = min(center_x, center_y) - 10
+                
+                if max_radius > 20:  # 确保有足够的半径
+                    # 创建径向对称性掩码
+                    y, x = np.ogrid[-center_y:h-center_y, -center_x:w-center_x]
+                    mask = x*x + y*y <= max_radius*max_radius
+                    
+                    # 计算对称性
+                    masked_img = img_cv.copy()
+                    if len(masked_img.shape) == 3:
+                        for c in range(masked_img.shape[2]):
+                            masked_img[:,:,c][~mask] = 0
+                    else:
+                        masked_img[~mask] = 0
+                    
+                    # 旋转180度比较
+                    rotated = cv2.rotate(masked_img, cv2.ROTATE_180)
+                    diff = cv2.absdiff(masked_img, rotated)
+                    
+                    features["radial_symmetry"] = 1 - float(np.mean(diff) / 255)
+            except:
+                pass
     
     def _extract_frequency_features(self, img_cv, features, image_id):
         """Extract frequency domain features"""
@@ -485,60 +582,249 @@ class FeatureExtractor:
             cv2.ellipse(mask, (center_w, center_h), (w//2, h//2), angle, -10, 10, 1, -1)
             freq_blocks.append(np.mean(magnitude * mask))
         features["freq_anisotropy"] = float(np.std(freq_blocks))
+        
+        # 频率峰值分析 - AI生成图像通常有特定的频率峰值模式
+        try:
+            # 计算径向平均功率谱
+            y, x = np.ogrid[-center_h:h-center_h, -center_w:w-center_w]
+            r = np.sqrt(x*x + y*y)
+            r = r.astype(np.int32)
+            
+            # 创建径向平均
+            radial_mean = np.zeros(min(center_h, center_w))
+            for i in range(1, len(radial_mean)):
+                mask = (r == i)
+                if np.sum(mask) > 0:
+                    radial_mean[i] = np.mean(magnitude[mask])
+            
+            # 计算峰值特征
+            peaks, _ = stats.find_peaks(radial_mean)
+            if len(peaks) > 0:
+                features["freq_peak_count"] = len(peaks)
+                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"""
+        # 获取灰度图
+        gray = self.cache.get('gray')
+        if gray is None:
+            gray = self.get_grayscale(image_id)
+            if gray is None:
+                if len(img_cv.shape) == 3:
+                    gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
+                else:
+                    gray = img_cv
+                self.cache['gray'] = gray
+        
+        # 小波变换特征
+        try:
+            # 如果图像太大，先降采样
+            if gray.shape[0] > 512 or gray.shape[1] > 512:
+                gray_small = cv2.resize(gray, (512, 512))
+            else:
+                gray_small = gray
+                
+            # 执行小波变换
+            coeffs = pywt.dwt2(gray_small, 'haar')
+            cA, (cH, cV, cD) = coeffs
+            
+            # 计算各子带的统计特征
+            features["wavelet_h_std"] = float(np.std(cH))
+            features["wavelet_v_std"] = float(np.std(cV))
+            features["wavelet_d_std"] = float(np.std(cD))
+            
+            # 计算小波系数的熵
+            cH_hist, _ = np.histogram(cH.flatten(), bins=50)
+            cV_hist, _ = np.histogram(cV.flatten(), bins=50)
+            cD_hist, _ = np.histogram(cD.flatten(), bins=50)
+            
+            features["wavelet_h_entropy"] = float(stats.entropy(cH_hist + 1e-10))
+            features["wavelet_v_entropy"] = float(stats.entropy(cV_hist + 1e-10))
+            features["wavelet_d_entropy"] = float(stats.entropy(cD_hist + 1e-10))
+        except:
+            pass
+        
+        # DCT变换特征
+        try:
+            # 执行DCT变换
+            dct = cv2.dct(np.float32(gray_small))
+            
+            # 计算DCT系数的统计特征
+            dct_std = np.std(dct)
+            features["dct_std"] = float(dct_std)
+            
+            # 计算DCT系数的熵
+            dct_hist, _ = np.histogram(dct.flatten(), bins=50)
+            features["dct_entropy"] = float(stats.entropy(dct_hist + 1e-10))
+        except:
+            pass
+        
+        # 图像质量评估
+        try:
+            # 计算梯度幅度图像
+            sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+            sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+            gradient_magnitude = np.sqrt(sobelx**2 + sobely**2)
+            
+            # 计算自然度指标
+            naturalness = np.mean(gradient_magnitude) / np.std(gradient_magnitude)
+            features["naturalness_index"] = float(naturalness)
+        except:
+            pass
 #############################################
-# 分析逻辑部分
+# 特征分析与决策逻辑部分
 #############################################
 
-# 初始化管理器
-model_manager = ModelManager()
-feature_extractor = FeatureExtractor()
+# 基于图像类型的特征阈值
+OPTIMIZED_THRESHOLDS = {
+    "lbp_entropy": {
+        "default": 2.0,
+        "portrait": 1.9,
+        "landscape": 2.2,
+    },
+    "freq_anisotropy": {
+        "default": 0.008,
+        "portrait": 0.007,
+        "landscape": 0.01,
+    },
+    "texture_correlation": {
+        "default": 0.95,
+        "portrait": 0.92,
+        "landscape": 0.95,
+    },
+    "horizontal_symmetry": {
+        "default": 0.85,
+        "portrait": 0.80,
+        "landscape": 0.85,
+    },
+    "vertical_symmetry": {
+        "default": 0.85,
+        "portrait": 0.80,
+        "landscape": 0.85,
+    },
+    "noise_spatial_std": {
+        "default": 0.3,
+        "portrait": 0.3,
+        "landscape": 0.4,
+    },
+    "freq_ratio": {
+        "default": 0.05,
+        "portrait": 0.05,
+        "landscape": 0.1,
+    },
+    "noise_spectrum_std": {
+        "default": 800,
+        "portrait": 800,
+        "landscape": 1000,
+    },
+    "color_entropy": {
+        "default": 3.5,
+        "portrait": 3.5,
+        "landscape": 4.0,
+    },
+    "lbp_uniformity": {
+        "default": 0.2,
+        "portrait": 0.2,
+        "landscape": 0.15,
+    },
+    "noise_channel_correlation": {
+        "default": 0.5,
+        "portrait": 0.5,
+        "landscape": 0.4,
+    },
+    "wavelet_h_entropy": {
+        "default": 3.0,
+        "portrait": 2.8,
+        "landscape": 3.2,
+    },
+    "dct_entropy": {
+        "default": 4.0,
+        "portrait": 3.8,
+        "landscape": 4.2,
+    },
+    "naturalness_index": {
+        "default": 1.5,
+        "portrait": 1.3,
+        "landscape": 1.7,
+    }
+}
 
-# 跟踪对AI检测最重要的特征
-CRITICAL_FEATURES = {
-    "lbp_entropy": {"threshold": 2.5, "weight": 0.4},
-    "freq_anisotropy": {"threshold": 0.1, "weight": 0.4},
-    "detail_spatial_std": {"threshold": 5, "weight": 0.3},
-    "texture_correlation": {"threshold": 0.9, "weight": 0.15},
-    "horizontal_symmetry": {"threshold": 0.7, "weight": 0.1},
-    "vertical_symmetry": {"threshold": 0.7, "weight": 0.1},
-    "noise_spatial_std": {"threshold": 0.5, "weight": 0.15},
-    "freq_ratio": {"threshold": 0.1, "weight": 0.1},
-    "noise_spectrum_std": {"threshold": 1000, "weight": 0.15},
-    "color_entropy": {"threshold": 5, "weight": 0.15}
+# 特征重要性权重
+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
 }
 
+def get_threshold(feature_name, image_type="default"):
+    """Get the appropriate threshold for a feature based on image type"""
+    if feature_name not in OPTIMIZED_THRESHOLDS:
+        return None
+        
+    return OPTIMIZED_THRESHOLDS[feature_name].get(image_type, 
+                                               OPTIMIZED_THRESHOLDS[feature_name]["default"])
+
 def check_ai_specific_features(image_features):
-    """Optimized check for AI-generated image features"""
+    """Enhanced check for AI-generated image features"""
     ai_score = 0
     ai_signs = []
     
-    # 只处理最关键的特征
-    for feature_name, config in CRITICAL_FEATURES.items():
+    # 获取图像类型
+    image_type = image_features.get("image_type", "default")
+    
+    # 处理每个特征
+    for feature_name, importance in FEATURE_IMPORTANCE.items():
         if feature_name not in image_features:
             continue
             
         value = image_features[feature_name]
-        threshold = config["threshold"]
-        weight = config["weight"]
+        threshold = get_threshold(feature_name, image_type)
+        
+        if threshold is None:
+            continue
         
         # 不同特征有不同的比较逻辑
-        if feature_name in ["lbp_entropy", "freq_anisotropy", "detail_spatial_std", 
-                           "noise_spatial_std", "freq_ratio", "noise_spectrum_std", 
-                           "color_entropy"]:
+        feature_score = 0
+        
+        # 低值表示AI生成的特征
+        if feature_name in ["lbp_entropy", "freq_anisotropy", "noise_spatial_std", 
+                           "freq_ratio", "noise_spectrum_std", "color_entropy",
+                           "wavelet_h_entropy", "dct_entropy", "naturalness_index"]:
             if value < threshold:
-                ai_score += weight
-                ai_signs.append(f"{feature_name} 异常低 ({value:.2f})")
-        elif feature_name in ["texture_correlation", "horizontal_symmetry", "vertical_symmetry"]:
+                feature_score = min(1.0, (threshold - value) / threshold * 2)
+                if feature_score > 0.5:
+                    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:
-                ai_score += weight
-                ai_signs.append(f"{feature_name} 异常高 ({value:.2f})")
+                feature_score = min(1.0, (value - threshold) / (1 - threshold) * 2)
+                if feature_score > 0.5:
+                    ai_signs.append(f"{feature_name} 异常高 ({value:.2f})")
+        
+        # 累加加权分数
+        ai_score += feature_score * importance
     
     # 计算检测到多少关键特征
     critical_count = len(ai_signs)
     if critical_count >= 5:
-        ai_score = max(ai_score, 0.9)
+        ai_score = max(ai_score, 0.8)  # 更保守，从0.9改为0.8
     elif critical_count >= 3:
-        ai_score = max(ai_score, 0.7)
+        ai_score = max(ai_score, 0.6)  # 更保守，从0.7改为0.6
     
     return min(ai_score, 1.0), ai_signs
 
@@ -547,22 +833,34 @@ def detect_beauty_filter_signs(image_features):
     beauty_score = 0
     beauty_signs = []
     
+    # 获取图像类型
+    image_type = image_features.get("image_type", "default")
+    
     # 只检查最重要的美颜滤镜指标
     if "face_skin_std" in image_features:
-        if image_features["face_skin_std"] < 15:
+        threshold = 15 if image_type == "portrait" else 20
+        if image_features["face_skin_std"] < threshold:
             beauty_score += 0.3
             beauty_signs.append("皮肤质感过于均匀")
     
     if "edge_density" in image_features:
-        if image_features["edge_density"] < 0.03:
+        threshold = 0.03 if image_type == "portrait" else 0.04
+        if image_features["edge_density"] < threshold:
             beauty_score += 0.2
             beauty_signs.append("边缘过于平滑")
     
     if "noise_level" in image_features:
-        if image_features["noise_level"] < 1.0:
+        threshold = 1.0 if image_type == "portrait" else 1.5
+        if image_features["noise_level"] < threshold:
             beauty_score += 0.2
             beauty_signs.append("噪点异常少")
     
+    if "texture_homogeneity" in image_features:
+        threshold = 0.5 if image_type == "portrait" else 0.4
+        if image_features["texture_homogeneity"] > threshold:
+            beauty_score += 0.2
+            beauty_signs.append("纹理过于均匀")
+    
     return min(beauty_score, 1.0), beauty_signs
 
 def detect_photoshop_signs(image_features):
@@ -570,67 +868,114 @@ def detect_photoshop_signs(image_features):
     ps_score = 0
     ps_signs = []
     
+    # 获取图像类型
+    image_type = image_features.get("image_type", "default")
+    
     # 只检查最重要的PS指标
     if "texture_homogeneity" in image_features:
-        if image_features["texture_homogeneity"] > 0.4:
+        threshold = 0.4 if image_type == "portrait" else 0.35
+        if image_features["texture_homogeneity"] > threshold:
             ps_score += 0.2
             ps_signs.append("皮肤质感过于均匀")
     
     if "edge_density" in image_features:
-        if image_features["edge_density"] < 0.01:
+        threshold = 0.01 if image_type == "portrait" else 0.015
+        if image_features["edge_density"] < threshold:
             ps_score += 0.2
             ps_signs.append("边缘过于平滑")
     
     if "color_std" in image_features:
-        if image_features["color_std"] > 50:
+        threshold = 50 if image_type == "portrait" else 40
+        if image_features["color_std"] > threshold:
             ps_score += 0.2
             ps_signs.append("颜色分布极不自然")
     
+    if "noise_spatial_std" in image_features:
+        threshold = 1.0 if image_type == "portrait" else 1.2
+        if image_features["noise_spatial_std"] > threshold:
+            ps_score += 0.2
+            ps_signs.append("噪点分布不均匀")
+    
     return min(ps_score, 1.0), ps_signs
 
-def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, valid_models_count, ai_feature_score):
-    """Provide detailed analysis with two-level classification"""
+def calculate_model_consistency(model_results):
+    """Calculate the consistency between model predictions"""
+    if not model_results:
+        return 0.0
+        
+    # 提取AI概率
+    probabilities = [result.get("ai_probability", 0.5) for result in model_results.values() 
+                    if "error" not in result]
+    
+    if not probabilities:
+        return 0.0
+        
+    # 计算方差作为一致性度量
+    variance = np.var(probabilities)
+    
+    # 方差越小，一致性越高
+    consistency = max(0.0, 1.0 - variance * 5)  # 缩放以获得合理的一致性分数
     
-    # 根据模型数量调整置信度
-    confidence_prefix = ""
-    if valid_models_count >= 3:
+    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"""
+    
+    # 根据模型数量和一致性调整置信度
+    if model_consistency > 0.8 and valid_models_count >= 2:
         confidence_prefix = "极高置信度："
-    elif valid_models_count == 2:
+    elif model_consistency > 0.6 and valid_models_count >= 2:
         confidence_prefix = "高置信度："
-    elif valid_models_count == 1:
+    elif valid_models_count >= 1:
         confidence_prefix = "中等置信度："
+    else:
+        confidence_prefix = "低置信度："
     
     # 计算编辑分数（在所有路径中都需要）
     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.6:
-        ai_probability = max(0.8, ai_probability)
-        category = confidence_prefix + "AI生成图像（基于特征分析）"
-        description = "基于多种典型AI特征分析，该图像很可能是AI生成的，尽管模型判断结果不确定。"
+    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.5:
-        ai_probability = max(0.7, ai_probability)
+    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生成图像"
+        category = confidence_prefix + "AI生成图像" + explanation
         description = "图像很可能是由AI完全生成，几乎没有真人照片的特征。"
         main_category = "AI生成"
     else:
         # 第二级分类：素人 vs 修图
         if combined_edit_score > 0.5:
-            category = confidence_prefix + "真人照片，修图痕迹明显"
+            category = confidence_prefix + "真人照片，修图痕迹明显" + explanation
             description = "图像基本是真人照片，但经过了明显的后期处理或美颜，修饰痕迹明显。"
             main_category = "真人照片-修图明显"
         else:
-            category = confidence_prefix + "真实素人照片"
+            category = confidence_prefix + "真实素人照片" + explanation
             description = "图像很可能是未经大量处理的真人照片，保留了自然的细节和特征。"
             main_category = "真人照片-素人"
     
-    # 处理边界情况
-    if ai_probability > 0.45 and combined_edit_score > 0.7:
-        category = confidence_prefix + "真人照片，修图痕迹明显（也可能是AI生成）"
+    # 处理边界情况 - 添加"不确定"类别
+    if 0.4 < ai_probability < 0.6 and abs(ai_probability - ai_feature_score) > 0.3:
+        category = "无法确定" + explanation
+        description = "系统无法确定该图像是AI生成还是真实照片。模型预测和特征分析结果不一致，需要人工判断。"
+        main_category = "无法确定"
+    
+    # 处理边界情况 - AI生成与高度修图
+    elif ai_probability > 0.45 and combined_edit_score > 0.7:
+        category = confidence_prefix + "真人照片，修图痕迹明显（也可能是AI生成）" + explanation
         description = "图像可能是真人照片经过大量后期处理，也可能是AI生成图像。由于现代AI技术与高度修图效果相似，难以完全区分。"
         main_category = "真人照片-修图明显"
     
@@ -641,13 +986,31 @@ def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_s
     
     return category, description, ps_details, ai_details, beauty_details, main_category
 def detect_ai_image(image):
-    """Main detection function with optimizations"""
+    """Enhanced main detection function with two-stage detection and improved decision logic"""
     if image is None:
         return {"error": "未提供图像"}
     
     start_time = time.time()
+    image_id = str(uuid.uuid4())  # 为图像生成唯一ID，用于反馈收集
+    
+    # 初始化管理器
+    model_manager = EnhancedModelManager()
+    feature_extractor = EnhancedFeatureExtractor()
     
-    # 步骤1：获取模型预测（仅在需要时加载模型）
+    # 第一阶段：快速特征分析
+    # 确定是否需要降采样
+    downscale_factor = 1.0
+    if image.width * image.height > 1024 * 1024:  # 对于大于1MP的图像
+        downscale_factor = min(1.0, 1024 * 1024 / (image.width * image.height))
+    
+    # 提取特征
+    feature_extractor.clear_cache()  # 清除之前运行的缓存
+    image_features = feature_extractor.analyze_image_features(image, downscale_factor)
+    
+    # 快速特征分析
+    ai_feature_score, ai_signs = check_ai_specific_features(image_features)
+    
+    # 第二阶段：模型分析
     results = {}
     valid_models = 0
     weighted_ai_probability = 0
@@ -672,72 +1035,79 @@ def detect_ai_image(image):
     else:
         return {"error": "所有模型加载失败"}
     
-    # 步骤2：提取图像特征（对大图像进行降采样）
-    # 确定是否需要降采样
-    downscale_factor = 1.0
-    if image.width * image.height > 1024 * 1024:  # 对于大于1MP的图像
-        downscale_factor = min(1.0, 1024 * 1024 / (image.width * image.height))
-    
-    # 提取特征
-    feature_extractor.clear_cache()  # 清除之前运行的缓存
-    image_features = feature_extractor.analyze_image_features(image, downscale_factor)
+    # 计算模型一致性
+    model_consistency = calculate_model_consistency(results)
     
-    # 步骤3：分析特征
-    ai_feature_score, ai_signs = check_ai_specific_features(image_features)
+    # 分析PS和美颜痕迹
     ps_score, ps_signs = detect_photoshop_signs(image_features)
     beauty_score, beauty_signs = detect_beauty_filter_signs(image_features)
     
-    # 步骤4：根据特征调整概率
+    # 协同决策：结合模型预测和特征分析
     adjusted_probability = final_ai_probability
     
-    # 增加特征分析的权重
-    if ai_feature_score > 0.8:
-        adjusted_probability = max(adjusted_probability, 0.8)
-    elif ai_feature_score > 0.6:
-        adjusted_probability = max(adjusted_probability, 0.7)
-    elif ai_feature_score > 0.4:
-        adjusted_probability = max(adjusted_probability, 0.6)
+    # 根据模型一致性调整特征分析的影响
+    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
     
     # 检查关键特征
     key_ai_features_count = 0
     
     # LBP熵（微观纹理分析）
-    if "lbp_entropy" in image_features and image_features["lbp_entropy"] < 2.5:
-        key_ai_features_count += 1
-        adjusted_probability += 0.1
+    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 and image_features["freq_anisotropy"] < 0.1:
-        key_ai_features_count += 1
-        adjusted_probability += 0.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 "detail_spatial_std" in image_features and image_features["detail_spatial_std"] < 5:
-        key_ai_features_count += 1
-        adjusted_probability += 0.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
     
-    # 多个关键特征强烈表明AI生成
-    if key_ai_features_count >= 2:
-        adjusted_probability = max(adjusted_probability, 0.7)
+    # 多个关键特征强烈表明AI生成，但需要模型支持
+    if key_ai_features_count >= 2 and final_ai_probability > 0.3:
+        adjusted_probability = max(adjusted_probability, 0.6)  # 更保守，从0.7改为0.6
     
     # 确保概率在有效范围内
     adjusted_probability = min(1.0, max(0.0, adjusted_probability))
     
-    # 步骤5：获取详细分析
+    # 获取详细分析
     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
+        valid_models, ai_feature_score, model_consistency
     )
     
     # 构建最终结果
     processing_time = time.time() - start_time
     
     final_result = {
+        "image_id": image_id,
         "ai_probability": adjusted_probability,
         "original_ai_probability": final_ai_probability,
         "ps_score": ps_score,
         "beauty_score": beauty_score,
         "ai_feature_score": ai_feature_score,
+        "model_consistency": model_consistency,
         "category": category,
         "main_category": main_category,
         "description": description,
@@ -747,26 +1117,120 @@ def detect_ai_image(image):
         "processing_time": f"{processing_time:.2f} seconds",
         "individual_model_results": results,
         # 只包含最重要的特征以减少响应大小
-        "key_features": {k: image_features[k] for k in CRITICAL_FEATURES if k in image_features}
+        "key_features": {k: image_features[k] for k in FEATURE_IMPORTANCE if k in image_features}
     }
     
+    # 保存结果用于后续分析
+    try:
+        with open(f"{FEEDBACK_DIR}/{image_id}.json", "w") as f:
+            json.dump(final_result, f)
+    except:
+        pass
+    
     # 返回两个值：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:
+        return {"status": "error", "message": "未提供图像ID"}
+    
+    try:
+        # 读取原始结果
+        result_path = f"{FEEDBACK_DIR}/{image_id}.json"
+        if not os.path.exists(result_path):
+            return {"status": "error", "message": "找不到对应的图像分析结果"}
+            
+        with open(result_path, "r") as f:
+            original_result = json.load(f)
+            
+        # 添加用户反馈
+        feedback_data = {
+            "image_id": image_id,
+            "original_result": original_result,
+            "user_feedback": user_feedback,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        # 保存反馈
+        feedback_path = f"{FEEDBACK_DIR}/{image_id}_feedback.json"
+        with open(feedback_path, "w") as f:
+            json.dump(feedback_data, f)
+            
+        return {"status": "success", "message": "反馈已保存，感谢您的贡献！"}
+    except Exception as e:
+        return {"status": "error", "message": f"保存反馈时出错: {str(e)}"}
+
+#############################################
+# Gradio界面部分
+#############################################
+
+def process_image_and_show_results(image):
+    """Process image and format results for Gradio interface"""
+    if image is None:
+        return {"error": "请上传图像"}, None, "未检测"
+    
+    try:
+        result, label = detect_ai_image(image)
+        return result, result["image_id"], result["main_category"]
+    except Exception as e:
+        return {"error": f"处理图像时出错: {str(e)}"}, None, "错误"
+
+def submit_feedback(image_id, correct_classification, comments):
+    """Submit user feedback"""
+    if not image_id:
+        return "请先上传图像进行分析"
+    
+    feedback = {
+        "correct_classification": correct_classification,
+        "comments": comments
+    }
+    
+    result = save_user_feedback(image_id, feedback)
+    return result["message"]
+
 # 创建Gradio界面
-iface = gr.Interface(
-    fn=detect_ai_image,
-    inputs=gr.Image(type="pil"),
-    outputs=[
-        gr.JSON(label="详细分析结果"),
-        gr.Label(label="主要分类", num_top_classes=1)
-    ],
-    title="优化版AI图像检测API",
-    description="多模型集成检测图像是否由AI生成或真人照片（素人/修图）",
-    examples=None,
-    allow_flagging="never"
-)
+with gr.Blocks(title="增强型AI图像检测系统") as iface:
+    gr.Markdown("# 增强型AI图像检测系统")
+    gr.Markdown("上传图像，系统将分析该图像是AI生成还是真实照片")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(type="pil", label="上传图像")
+            analyze_btn = gr.Button("分析图像", variant="primary")
+        
+        with gr.Column(scale=2):
+            result_json = gr.JSON(label="详细分析结果")
+            image_id_output = gr.Textbox(label="图像ID", visible=False)
+            result_label = gr.Label(label="主要分类")
+    
+    gr.Markdown("## 用户反馈")
+    gr.Markdown("您认为上述分类结果是否正确？您的反馈将帮助我们改进系统。")
+    
+    with gr.Row():
+        correct_classification = gr.Radio(
+            ["正确", "错误 - 这是AI生成图像", "错误 - 这是真实照片", "不确定"], 
+            label="分类结果是否正确"
+        )
+        comments = gr.Textbox(label="其他评论（可选）")
+    
+    feedback_btn = gr.Button("提交反馈")
+    feedback_result = gr.Textbox(label="反馈结果")
+    
+    # 设置事件
+    analyze_btn.click(
+        process_image_and_show_results, 
+        inputs=[input_image], 
+        outputs=[result_json, image_id_output, result_label]
+    )
+    
+    feedback_btn.click(
+        submit_feedback,
+        inputs=[image_id_output, correct_classification, comments],
+        outputs=[feedback_result]
+    )
 
 # 启动应用
-iface.launch(share=True)
+if __name__ == "__main__":
+    iface.launch(share=True)