import gradio as gr import torch from PIL import Image import numpy as np import cv2 from transformers import AutoImageProcessor, AutoModelForImageClassification from skimage.feature import graycomatrix, graycoprops, local_binary_pattern from scipy import ndimage, stats # 加载多个检测模型 models = { "model1": { "name": "umm-maybe/AI-image-detector", "processor": None, "model": None, "weight": 0.5 }, "model2": { "name": "microsoft/resnet-50", # 通用图像分类模型 "processor": None, "model": None, "weight": 0.25 }, "model3": { "name": "google/vit-base-patch16-224", # Vision Transformer模型 "processor": None, "model": None, "weight": 0.25 } } # 初始化模型 for key in models: try: models[key]["processor"] = AutoImageProcessor.from_pretrained(models[key]["name"]) models[key]["model"] = AutoModelForImageClassification.from_pretrained(models[key]["name"]) print(f"成功加载模型: {models[key]['name']}") except Exception as e: print(f"加载模型 {models[key]['name']} 失败: {str(e)}") models[key]["processor"] = None models[key]["model"] = None def process_model_output(model_info, outputs, probabilities): """处理不同模型的输出，统一返回AI生成概率""" model_name = model_info["name"].lower() # 针对不同模型的特殊处理 if "ai-image-detector" in model_name: # umm-maybe/AI-image-detector模型特殊处理 # 检查标签 ai_label_idx = None human_label_idx = None for idx, label in model_info["model"].config.id2label.items(): label_lower = label.lower() if "ai" in label_lower or "generated" in label_lower or "fake" in label_lower: ai_label_idx = idx if "human" in label_lower or "real" in label_lower: human_label_idx = idx # 修正后的标签解释逻辑 if human_label_idx is not None: # 如果预测为human，则AI概率应该低 ai_probability = 1 - float(probabilities[0][human_label_idx].item()) elif ai_label_idx is not None: # 如果预测为AI，则AI概率应该高 ai_probability = float(probabilities[0][ai_label_idx].item()) else: # 默认情况 ai_probability = 0.5 elif "resnet" in model_name: # 通用图像分类模型，使用简单启发式方法 predicted_class_idx = outputs.logits.argmax(-1).item() # 检查是否有与AI相关的类别 predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower() # 简单启发式：检查类别名称是否包含与AI生成相关的关键词 ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer"] for keyword in ai_keywords: if keyword in predicted_class: return float(probabilities[0][predicted_class_idx].item()) # 如果没有明确的AI类别，返回中等概率 return 0.5 elif "vit" in model_name: # Vision Transformer模型 predicted_class_idx = outputs.logits.argmax(-1).item() # 同样检查类别名称 predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower() # 简单启发式：检查类别名称是否包含与AI生成相关的关键词 ai_keywords = ["artificial", "generated", "synthetic", "fake", "computer"] for keyword in ai_keywords: if keyword in predicted_class: return float(probabilities[0][predicted_class_idx].item()) # 如果没有明确的AI类别，返回中等概率 return 0.5 # 默认处理 predicted_class_idx = outputs.logits.argmax(-1).item() predicted_class = model_info["model"].config.id2label[predicted_class_idx].lower() 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 ai_probability def analyze_image_features(image): """分析图像特征""" # 转换为OpenCV格式 img_array = np.array(image) if len(img_array.shape) == 3 and img_array.shape[2] == 3: img_cv = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR) else: img_cv = img_array features = {} # 基本特征 features["width"] = image.width features["height"] = image.height features["aspect_ratio"] = image.width / max(1, image.height) # 颜色分析 if len(img_array.shape) == 3: features["avg_red"] = float(np.mean(img_array[:,:,0])) features["avg_green"] = float(np.mean(img_array[:,:,1])) features["avg_blue"] = float(np.mean(img_array[:,:,2])) # 颜色标准差 - 用于检测颜色分布是否自然 features["color_std"] = float(np.std([ features["avg_red"], features["avg_green"], features["avg_blue"] ])) # 颜色局部变化 - 真实照片通常有更多局部颜色变化 local_color_variations = [] for i in range(0, img_array.shape[0]-10, 10): for j in range(0, img_array.shape[1]-10, 10): patch = img_array[i:i+10, j:j+10] local_color_variations.append(np.std(patch)) features["local_color_variation"] = float(np.mean(local_color_variations)) # 颜色分布的自然度 - 真实照片的颜色分布更自然 r_hist, _ = np.histogram(img_array[:,:,0], bins=256, range=(0, 256)) g_hist, _ = np.histogram(img_array[:,:,1], bins=256, range=(0, 256)) b_hist, _ = np.histogram(img_array[:,:,2], bins=256, range=(0, 256)) # 计算颜色直方图的熵 - 真实照片通常熵值更高 r_entropy = stats.entropy(r_hist + 1e-10) # 添加小值避免log(0) 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) # 边缘一致性分析 edges = cv2.Canny(img_cv, 100, 200) features["edge_density"] = float(np.sum(edges > 0) / (image.width * image.height)) # 边缘自然度分析 - 真实照片的边缘通常更自然 if len(img_array.shape) == 3: gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3) sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3) edge_magnitude = np.sqrt(sobelx**2 + sobely**2) features["edge_variance"] = float(np.var(edge_magnitude)) # 边缘方向分布 - 真实照片的边缘方向分布更自然 edge_direction = np.arctan2(sobely, sobelx) * 180 / np.pi edge_dir_hist, _ = np.histogram(edge_direction[edge_magnitude > 30], bins=36, range=(-180, 180)) features["edge_direction_entropy"] = float(stats.entropy(edge_dir_hist + 1e-10)) # 纹理分析 - 使用灰度共生矩阵 if len(img_array.shape) == 3: gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) # 计算GLCM distances = [5] angles = [0, np.pi/4, np.pi/2, 3*np.pi/4] glcm = graycomatrix(gray, distances=distances, angles=angles, symmetric=True, normed=True) # 计算GLCM属性 features["texture_contrast"] = float(np.mean(graycoprops(glcm, 'contrast')[0])) features["texture_homogeneity"] = float(np.mean(graycoprops(glcm, 'homogeneity')[0])) features["texture_correlation"] = float(np.mean(graycoprops(glcm, 'correlation')[0])) features["texture_energy"] = float(np.mean(graycoprops(glcm, 'energy')[0])) features["texture_dissimilarity"] = float(np.mean(graycoprops(glcm, 'dissimilarity')[0])) features["texture_ASM"] = float(np.mean(graycoprops(glcm, 'ASM')[0])) # 局部二值模式 (LBP) - 分析微观纹理 try: radius = 3 n_points = 8 * radius lbp = local_binary_pattern(gray, n_points, radius, method='uniform') lbp_hist, _ = np.histogram(lbp, bins=n_points + 2, range=(0, n_points + 2)) lbp_hist = lbp_hist.astype(float) / sum(lbp_hist) features["lbp_entropy"] = float(stats.entropy(lbp_hist + 1e-10)) except: # 如果LBP分析失败，不添加这个特征 pass # 噪声分析 if len(img_array.shape) == 3: blurred = cv2.GaussianBlur(img_cv, (5, 5), 0) noise = cv2.absdiff(img_cv, blurred) features["noise_level"] = float(np.mean(noise)) # 噪声分布 - 用于检测噪声是否自然 features["noise_std"] = float(np.std(noise)) # 噪声频谱分析 - 真实照片的噪声频谱更自然 noise_fft = np.fft.fft2(noise[:,:,0]) noise_fft_shift = np.fft.fftshift(noise_fft) noise_magnitude = np.abs(noise_fft_shift) features["noise_spectrum_std"] = float(np.std(noise_magnitude)) # 噪声的空间一致性 - AI生成图像的噪声空间分布通常不够自然 noise_blocks = [] block_size = 32 for i in range(0, noise.shape[0]-block_size, block_size): for j in range(0, noise.shape[1]-block_size, block_size): block = noise[i:i+block_size, j:j+block_size] noise_blocks.append(np.mean(block)) features["noise_spatial_std"] = float(np.std(noise_blocks)) # 对称性分析 - AI生成图像通常有更高的对称性 if img_cv.shape[1] % 2 == 0: # 确保宽度是偶数 left_half = img_cv[:, :img_cv.shape[1]//2] right_half = cv2.flip(img_cv[:, img_cv.shape[1]//2:], 1) if left_half.shape == right_half.shape: h_symmetry = 1 - float(np.mean(cv2.absdiff(left_half, right_half)) / 255) features["horizontal_symmetry"] = h_symmetry if img_cv.shape[0] % 2 == 0: # 确保高度是偶数 top_half = img_cv[:img_cv.shape[0]//2, :] bottom_half = cv2.flip(img_cv[img_cv.shape[0]//2:, :], 0) if top_half.shape == bottom_half.shape: v_symmetry = 1 - float(np.mean(cv2.absdiff(top_half, bottom_half)) / 255) features["vertical_symmetry"] = v_symmetry # 频率域分析 - 检测不自然的频率分布 if len(img_array.shape) == 3: gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) f_transform = np.fft.fft2(gray) f_shift = np.fft.fftshift(f_transform) magnitude = np.log(np.abs(f_shift) + 1) # 计算高频和低频成分的比例 h, w = magnitude.shape center_h, center_w = h // 2, w // 2 # 低频区域 (中心区域) low_freq_region = magnitude[center_h-h//8:center_h+h//8, center_w-w//8:center_w+w//8] low_freq_mean = np.mean(low_freq_region) # 高频区域 (边缘区域) high_freq_mean = np.mean(magnitude) - low_freq_mean features["freq_ratio"] = float(high_freq_mean / max(low_freq_mean, 0.001)) # 频率分布的自然度 - 真实照片通常有更自然的频率分布 freq_std = np.std(magnitude) features["freq_std"] = float(freq_std) # 频率分布的各向异性 - 真实照片的频率分布通常更各向异性 freq_blocks = [] for angle in range(0, 180, 20): mask = np.zeros_like(magnitude) 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)) # 尝试检测人脸 try: face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml') gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.1, 4) features["face_count"] = len(faces) if len(faces) > 0: # 分析人脸特征 face_features = [] for (x, y, w, h) in faces: face = img_cv[y:y+h, x:x+w] # 皮肤质感分析 face_hsv = cv2.cvtColor(face, cv2.COLOR_BGR2HSV) skin_mask = cv2.inRange(face_hsv, (0, 20, 70), (20, 150, 255)) skin_pixels = face[skin_mask > 0] if len(skin_pixels) > 0: face_features.append({ "skin_std": float(np.std(skin_pixels)), "skin_local_contrast": float(np.mean(cv2.Laplacian(face, cv2.CV_64F))), "face_symmetry": analyze_face_symmetry(face) }) if face_features: features["face_skin_std"] = np.mean([f["skin_std"] for f in face_features]) features["face_local_contrast"] = np.mean([f["skin_local_contrast"] for f in face_features]) features["face_symmetry"] = np.mean([f["face_symmetry"] for f in face_features]) # 面部微表情分析 for i, (x, y, w, h) in enumerate(faces): face = gray[y:y+h, x:x+w] # 分析面部纹理的局部变化 face_blocks = [] block_size = 8 for bi in range(0, face.shape[0]-block_size, block_size): for bj in range(0, face.shape[1]-block_size, block_size): block = face[bi:bi+block_size, bj:bj+block_size] face_blocks.append(np.std(block)) if face_blocks: features[f"face_{i}_texture_variation"] = float(np.std(face_blocks)) except: # 如果人脸检测失败，不添加人脸特征 pass # 分析物理一致性 physical_features = analyze_physical_consistency(img_cv) features.update(physical_features) # 分析细节连贯性 detail_features = analyze_detail_coherence(img_cv) features.update(detail_features) # 分析衣物细节 clothing_features = analyze_clothing_details(img_cv) features.update(clothing_features) # 分析手部和关节 extremity_features = analyze_extremities(img_cv) features.update(extremity_features) return features def analyze_face_symmetry(face): """分析人脸对称性""" if face.shape[1] % 2 == 0: # 确保宽度是偶数 left_half = face[:, :face.shape[1]//2] right_half = cv2.flip(face[:, face.shape[1]//2:], 1) if left_half.shape == right_half.shape: return 1 - float(np.mean(cv2.absdiff(left_half, right_half)) / 255) return 0.5 # 默认值 def analyze_physical_consistency(image): """分析图像中的物理一致性""" features = {} try: # 转换为灰度图 if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) else: gray = image # 光影一致性分析 # 检测亮度梯度 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) gradient_direction = np.arctan2(sobely, sobelx) # 分析梯度方向的一致性 - 真实照片的光影梯度方向更一致 # 将图像分成块，分析每个块的主要梯度方向 block_size = 32 gradient_dirs = [] for i in range(0, gray.shape[0]-block_size, block_size): for j in range(0, gray.shape[1]-block_size, block_size): block_gradient = gradient_direction[i:i+block_size, j:j+block_size] block_magnitude = gradient_magnitude[i:i+block_size, j:j+block_size] # 只考虑梯度幅值较大的像素 significant_gradients = block_gradient[block_magnitude > np.mean(block_magnitude)] if len(significant_gradients) > 0: # 计算主要方向 hist, _ = np.histogram(significant_gradients, bins=8, range=(-np.pi, np.pi)) main_dir = np.argmax(hist) gradient_dirs.append(main_dir) if gradient_dirs: # 计算主要方向的一致性 hist, _ = np.histogram(gradient_dirs, bins=8, range=(0, 8)) features["light_direction_consistency"] = float(np.max(hist) / max(sum(hist), 1)) # 透视一致性分析 # 使用霍夫变换检测直线 edges = cv2.Canny(gray, 50, 150) lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, minLineLength=50, maxLineGap=10) if lines is not None and len(lines) > 1: # 分析消失点 vanishing_points = [] for i in range(len(lines)): for j in range(i+1, len(lines)): x1, y1, x2, y2 = lines[i][0] x3, y3, x4, y4 = lines[j][0] # 计算两条线的交点（可能的消失点） d = (x1-x2)*(y3-y4) - (y1-y2)*(x3-x4) if abs(d) > 0.001: # 避免平行线 px = ((x1*y2 - y1*x2)*(x3-x4) - (x1-x2)*(x3*y4 - y3*x4)) / d py = ((x1*y2 - y1*x2)*(y3-y4) - (y1-y2)*(x3*y4 - y3*x4)) / d # 只考虑图像范围内或附近的交点 img_diag = np.sqrt(gray.shape[0]**2 + gray.shape[1]**2) if -img_diag < px < 2*gray.shape[1] and -img_diag < py < 2*gray.shape[0]: vanishing_points.append((px, py)) if vanishing_points: # 分析消失点的聚集程度 - 真实照片的消失点通常更聚集 vp_x = [p[0] for p in vanishing_points] vp_y = [p[1] for p in vanishing_points] features["perspective_consistency"] = float(1 / (1 + np.std(vp_x) + np.std(vp_y))) except: # 如果分析失败，不添加物理一致性特征 pass return features def analyze_detail_coherence(image): """分析图像细节的连贯性""" features = {} try: # 转换为灰度图 if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) else: gray = image # 多尺度细节分析 scales = [3, 5, 9] detail_levels = [] for scale in scales: # 使用不同尺度的拉普拉斯算子提取细节 laplacian = cv2.Laplacian(gray, cv2.CV_64F, ksize=scale) abs_laplacian = np.abs(laplacian) detail_levels.append(np.mean(abs_laplacian)) # 计算细节随尺度变化的一致性 - 真实照片的细节随尺度变化更自然 if len(detail_levels) > 1: features["detail_scale_consistency"] = float(np.std(detail_levels) / max(np.mean(detail_levels), 0.001)) # 分析图像不同区域的细节一致性 block_size = 64 detail_blocks = [] for i in range(0, gray.shape[0]-block_size, block_size): for j in range(0, gray.shape[1]-block_size, block_size): block = gray[i:i+block_size, j:j+block_size] # 计算块的细节水平 block_laplacian = cv2.Laplacian(block, cv2.CV_64F) detail_blocks.append(np.mean(np.abs(block_laplacian))) if detail_blocks: # 计算细节分布的均匀性 - AI生成图像的细节分布通常不够均匀 features["detail_spatial_std"] = float(np.std(detail_blocks)) features["detail_spatial_entropy"] = float(stats.entropy(detail_blocks + 1e-10)) # 边缘过渡分析 edges = cv2.Canny(gray, 50, 150) dilated = cv2.dilate(edges, np.ones((3,3), np.uint8)) edge_transition = cv2.absdiff(dilated, edges) # 计算边缘过渡区域的特性 - 真实照片的边缘过渡更自然 if np.sum(edge_transition) > 0: transition_values = gray[edge_transition > 0] if len(transition_values) > 0: features["edge_transition_std"] = float(np.std(transition_values)) except: # 如果分析失败，不添加细节连贯性特征 pass return features def analyze_clothing_details(image): """分析衣物细节的自然度""" features = {} try: # 转换为灰度图 if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) else: gray = image # 使用Canny边缘检测 edges = cv2.Canny(gray, 50, 150) # 使用霍夫变换检测直线 lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, minLineLength=50, maxLineGap=10) if lines is not None: # 计算直线的角度分布 angles = [] for line in lines: x1, y1, x2, y2 = line[0] if x2 - x1 != 0: # 避免除以零 angle = np.arctan((y2 - y1) / (x2 - x1)) * 180 / np.pi angles.append(angle) if angles: # 计算角度的标准差 - AI生成的衣物褶皱通常角度分布不自然 features["clothing_angle_std"] = float(np.std(angles)) # 计算角度的直方图 - 检查是否有过多相似角度（AI生成特征） hist, _ = np.histogram(angles, bins=18, range=(-90, 90)) max_count = np.max(hist) total_count = np.sum(hist) features["clothing_angle_uniformity"] = float(max_count / max(total_count, 1)) # 分析纹理的一致性 # 将图像分成小块，计算每个块的纹理特征 block_size = 32 h, w = gray.shape texture_variations = [] for i in range(0, h-block_size, block_size): for j in range(0, w-block_size, block_size): block = gray[i:i+block_size, j:j+block_size] # 计算局部LBP特征或简单的方差 texture_variations.append(np.var(block)) if texture_variations: # 计算纹理变化的标准差 - 真实衣物纹理变化更自然 features["clothing_texture_std"] = float(np.std(texture_variations)) # 计算纹理变化的均值 - AI生成的衣物纹理通常变化较小 features["clothing_texture_mean"] = float(np.mean(texture_variations)) # 计算纹理变化的熵 - 真实衣物纹理变化的熵更高 features["clothing_texture_entropy"] = float(stats.entropy(texture_variations + 1e-10)) # 褶皱分析 - 使用形态学操作提取可能的褶皱 _, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) kernel = np.ones((3,3), np.uint8) opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) # 寻找轮廓 contours, _ = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # 分析轮廓的复杂度 if contours: contour_complexities = [] for contour in contours: area = cv2.contourArea(contour) if area > 100: # 忽略太小的轮廓 perimeter = cv2.arcLength(contour, True) complexity = perimeter / max(np.sqrt(area), 1) contour_complexities.append(complexity) if contour_complexities: features["clothing_contour_complexity"] = float(np.mean(contour_complexities)) features["clothing_contour_std"] = float(np.std(contour_complexities)) except: # 如果分析失败，不添加衣物特征 pass return features def analyze_extremities(image): """分析手指、脚趾等末端细节""" features = {} try: # 转换为灰度图 if len(image.shape) == 3: gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) else: gray = image # 使用形态学操作提取可能的手部区域 _, thresh = cv2.threshold(gray, 120, 255, cv2.THRESH_BINARY) kernel = np.ones((5,5), np.uint8) opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel) # 寻找轮廓 contours, _ = cv2.findContours(opening, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) # 分析轮廓的复杂度 if contours: # 计算轮廓的周长与面积比 - 手指等细节会增加这个比值 perimeter_area_ratios = [] for contour in contours: area = cv2.contourArea(contour) if area > 100: # 忽略太小的轮廓 perimeter = cv2.arcLength(contour, True) ratio = perimeter / max(area, 1) perimeter_area_ratios.append(ratio) if perimeter_area_ratios: features["extremity_perimeter_area_ratio"] = float(np.mean(perimeter_area_ratios)) # 计算凸包缺陷 - 手指之间的间隙会产生凸包缺陷 defect_depths = [] for contour in contours: if len(contour) > 5: # 需要足够多的点来计算凸包 hull = cv2.convexHull(contour, returnPoints=False) if len(hull) > 3: # 需要至少4个点来计算凸包缺陷 try: defects = cv2.convexityDefects(contour, hull) if defects is not None: for i in range(defects.shape[0]): _, _, _, depth = defects[i, 0] defect_depths.append(depth) except: pass if defect_depths: features["extremity_defect_depth_mean"] = float(np.mean(defect_depths)) features["extremity_defect_depth_std"] = float(np.std(defect_depths)) # 分析缺陷的分布 - 真实手指的缺陷分布更自然 defect_hist, _ = np.histogram(defect_depths, bins=10) features["extremity_defect_entropy"] = float(stats.entropy(defect_hist + 1e-10)) # 分析轮廓的曲率变化 - 真实手指的曲率变化更自然 curvature_variations = [] for contour in contours: if len(contour) > 20: # 需要足够多的点来计算曲率 # 简化轮廓以减少噪声 epsilon = 0.01 * cv2.arcLength(contour, True) approx = cv2.approxPolyDP(contour, epsilon, True) # 计算相邻点之间的角度变化 angles = [] for i in range(len(approx)): p1 = approx[i][0] p2 = approx[(i+1) % len(approx)][0] p3 = approx[(i+2) % len(approx)][0] # 计算两个向量之间的角度 v1 = p2 - p1 v2 = p3 - p2 if np.linalg.norm(v1) > 0 and np.linalg.norm(v2) > 0: cos_angle = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)) cos_angle = np.clip(cos_angle, -1.0, 1.0) # 确保在有效范围内 angle = np.arccos(cos_angle) angles.append(angle) if angles: curvature_variations.append(np.std(angles)) if curvature_variations: features["extremity_curvature_std"] = float(np.mean(curvature_variations)) except: # 如果分析失败，不添加末端特征 pass return features def check_ai_specific_features(image_features): """检查AI生成图像的典型特征，增强对最新AI模型的检测能力""" ai_score = 0 ai_signs = [] # 增加对微观纹理的分析权重 if "lbp_entropy" in image_features: if image_features["lbp_entropy"] < 2.0: ai_score += 0.4 # 提高权重 ai_signs.append("微观纹理熵极低，典型AI生成特征") elif image_features["lbp_entropy"] < 3.0: ai_score += 0.3 ai_signs.append("微观纹理熵异常低") # 增加对频率分布各向异性的分析权重 if "freq_anisotropy" in image_features: if image_features["freq_anisotropy"] < 0.05: ai_score += 0.4 # 提高权重 ai_signs.append("频率分布各向异性极低，典型AI生成特征") elif image_features["freq_anisotropy"] < 0.5: ai_score += 0.3 ai_signs.append("频率分布各向异性异常低") # 增加对细节一致性的分析 if "detail_scale_consistency" in image_features and "detail_spatial_std" in image_features: if image_features["detail_scale_consistency"] < 0.2 and image_features["detail_spatial_std"] < 5: ai_score += 0.3 ai_signs.append("细节一致性异常，典型AI生成特征") # 检查对称性 - AI生成图像通常对称性高 if "horizontal_symmetry" in image_features and "vertical_symmetry" in image_features: avg_symmetry = (image_features["horizontal_symmetry"] + image_features["vertical_symmetry"]) / 2 if avg_symmetry > 0.8: ai_score += 0.15 ai_signs.append("图像对称性异常高") elif avg_symmetry > 0.7: ai_score += 0.1 ai_signs.append("图像对称性较高") # 检查纹理相关性 - AI生成图像通常纹理相关性高 if "texture_correlation" in image_features: if image_features["texture_correlation"] > 0.95: # 提高阈值 ai_score += 0.15 ai_signs.append("纹理相关性异常高") elif image_features["texture_correlation"] > 0.9: ai_score += 0.1 ai_signs.append("纹理相关性较高") # 检查边缘与噪声的关系 - AI生成图像通常边缘清晰但噪声不自然 if "edge_density" in image_features and "noise_level" in image_features: edge_noise_ratio = image_features["edge_density"] / max(image_features["noise_level"], 0.001) if edge_noise_ratio < 0.01: ai_score += 0.15 ai_signs.append("边缘与噪声分布不自然") # 检查颜色平滑度 - AI生成图像通常颜色过渡更平滑 if "color_std" in image_features and image_features["color_std"] < 10: ai_score += 0.1 ai_signs.append("颜色过渡异常平滑") # 检查颜色熵 - AI生成图像通常颜色熵较低 if "color_entropy" in image_features and image_features["color_entropy"] < 5: ai_score += 0.15 ai_signs.append("颜色分布熵值异常低") # 检查纹理能量 - AI生成图像通常纹理能量分布不自然 if "texture_energy" in image_features and image_features["texture_energy"] < 0.01: ai_score += 0.15 ai_signs.append("纹理能量分布不自然") # 检查频率比例 - AI生成图像通常频率分布不自然 if "freq_ratio" in image_features: if image_features["freq_ratio"] < 0.1 or image_features["freq_ratio"] > 2.0: ai_score += 0.1 ai_signs.append("频率分布不自然") # 检查噪声频谱 - 真实照片的噪声频谱更自然 if "noise_spectrum_std" in image_features and image_features["noise_spectrum_std"] < 1000: ai_score += 0.15 ai_signs.append("噪声频谱异常规则") # 检查噪声空间分布 - 真实照片的噪声空间分布更自然 if "noise_spatial_std" in image_features and image_features["noise_spatial_std"] < 0.5: ai_score += 0.15 ai_signs.append("噪声空间分布异常均匀") # 检查细节尺度一致性 - AI生成图像的细节尺度一致性通常不够自然 if "detail_scale_consistency" in image_features and image_features["detail_scale_consistency"] < 0.2: ai_score += 0.15 ai_signs.append("细节尺度变化异常均匀") # 检查细节空间分布 - AI生成图像的细节空间分布通常不够自然 if "detail_spatial_std" in image_features and image_features["detail_spatial_std"] < 5: ai_score += 0.15 ai_signs.append("细节空间分布异常均匀") # 检查细节空间熵 - AI生成图像的细节空间熵通常较低 if "detail_spatial_entropy" in image_features and image_features["detail_spatial_entropy"] < 1.5: ai_score += 0.15 ai_signs.append("细节空间熵异常低") # 检查边缘过渡 - AI生成图像的边缘过渡通常不够自然 if "edge_transition_std" in image_features and image_features["edge_transition_std"] < 10: ai_score += 0.15 ai_signs.append("边缘过渡异常均匀") # 检查光影一致性 - AI生成图像的光影一致性通常过高 if "light_direction_consistency" in image_features and image_features["light_direction_consistency"] > 0.7: ai_score += 0.15 ai_signs.append("光影方向一致性异常高") # 检查透视一致性 - AI生成图像的透视一致性通常过高 if "perspective_consistency" in image_features and image_features["perspective_consistency"] > 0.7: ai_score += 0.15 ai_signs.append("透视一致性异常高") # 检查人脸特征 - AI生成的人脸通常有特定特征 if "face_symmetry" in image_features and image_features["face_symmetry"] > 0.8: ai_score += 0.15 ai_signs.append("人脸对称性异常高") if "face_skin_std" in image_features and image_features["face_skin_std"] < 10: ai_score += 0.2 ai_signs.append("皮肤质感异常均匀") # 检查面部纹理变化 - AI生成的面部纹理变化通常不够自然 face_texture_keys = [k for k in image_features.keys() if k.startswith("face_") and k.endswith("_texture_variation")] if face_texture_keys: face_texture_variations = [image_features[k] for k in face_texture_keys] if np.mean(face_texture_variations) < 5: ai_score += 0.2 ai_signs.append("面部纹理变化异常均匀") # 检查衣物特征 - AI生成的衣物通常有特定问题 if "clothing_angle_uniformity" in image_features and image_features["clothing_angle_uniformity"] > 0.3: ai_score += 0.2 ai_signs.append("衣物褶皱角度分布不自然") if "clothing_texture_std" in image_features and image_features["clothing_texture_std"] < 100: ai_score += 0.15 ai_signs.append("衣物纹理变化异常均匀") if "clothing_texture_entropy" in image_features and image_features["clothing_texture_entropy"] < 1.5: ai_score += 0.15 ai_signs.append("衣物纹理熵异常低") if "clothing_contour_complexity" in image_features and image_features["clothing_contour_complexity"] < 5: ai_score += 0.15 ai_signs.append("衣物轮廓复杂度异常低") # 检查手部特征 - AI生成的手部通常有特定问题 if "extremity_perimeter_area_ratio" in image_features: if image_features["extremity_perimeter_area_ratio"] < 0.05: ai_score += 0.2 ai_signs.append("手部/末端轮廓异常平滑") if "extremity_defect_depth_std" in image_features and image_features["extremity_defect_depth_std"] < 10: ai_score += 0.15 ai_signs.append("手指间隙异常均匀") if "extremity_defect_entropy" in image_features and image_features["extremity_defect_entropy"] < 1.0: ai_score += 0.15 ai_signs.append("手指间隙分布熵异常低") if "extremity_curvature_std" in image_features and image_features["extremity_curvature_std"] < 0.2: ai_score += 0.15 ai_signs.append("手部曲率变化异常均匀") # 特别关注最新AI模型的特征组合 # 当多个特征同时出现时，这是强有力的AI生成证据 ai_feature_count = len(ai_signs) if ai_feature_count >= 5: # 如果检测到多个AI特征 ai_score = max(ai_score, 0.9) # 确保AI分数很高 elif ai_feature_count >= 3: ai_score = max(ai_score, 0.7) return min(ai_score, 1.0), ai_signs def detect_beauty_filter_signs(image_features): """检测美颜滤镜痕迹""" beauty_score = 0 beauty_signs = [] # 检查皮肤质感 if "face_skin_std" in image_features: if image_features["face_skin_std"] < 15: beauty_score += 0.3 beauty_signs.append("皮肤质感过于均匀，典型美颜特征") elif image_features["face_skin_std"] < 25: beauty_score += 0.2 beauty_signs.append("皮肤质感较为均匀，可能使用了美颜") # 检查局部对比度 - 美颜通常会降低局部对比度 if "face_local_contrast" in image_features: if image_features["face_local_contrast"] < 5: beauty_score += 0.2 beauty_signs.append("面部局部对比度低，典型美颜特征") # 检查边缘平滑度 - 美颜通常会平滑边缘 if "edge_density" in image_features: if image_features["edge_density"] < 0.03: beauty_score += 0.2 beauty_signs.append("边缘过于平滑，典型美颜特征") elif image_features["edge_density"] < 0.05: beauty_score += 0.1 beauty_signs.append("边缘较为平滑，可能使用了美颜") # 检查噪点 - 美颜通常会减少噪点 if "noise_level" in image_features: if image_features["noise_level"] < 1.0: beauty_score += 0.2 beauty_signs.append("噪点异常少，典型美颜特征") elif image_features["noise_level"] < 2.0: beauty_score += 0.1 beauty_signs.append("噪点较少，可能使用了美颜") # 检查人脸对称性 - 美颜通常会增加对称性 if "face_symmetry" in image_features: if image_features["face_symmetry"] > 0.8: beauty_score += 0.2 beauty_signs.append("面部对称性异常高，典型美颜特征") elif image_features["face_symmetry"] > 0.7: beauty_score += 0.1 beauty_signs.append("面部对称性较高，可能使用了美颜") # 检查面部纹理变化 - 美颜通常会使面部纹理更均匀 face_texture_keys = [k for k in image_features.keys() if k.startswith("face_") and k.endswith("_texture_variation")] if face_texture_keys: face_texture_variations = [image_features[k] for k in face_texture_keys] if np.mean(face_texture_variations) < 10: beauty_score += 0.2 beauty_signs.append("面部纹理变化异常均匀，典型美颜特征") # 检查边缘过渡 - 美颜通常会使边缘过渡更平滑 if "edge_transition_std" in image_features and image_features["edge_transition_std"] < 15: beauty_score += 0.2 beauty_signs.append("边缘过渡异常平滑，典型美颜特征") return min(beauty_score, 1.0), beauty_signs def detect_photoshop_signs(image_features): """检测图像中的PS痕迹""" ps_score = 0 ps_signs = [] # 检查皮肤质感 if "texture_homogeneity" in image_features: if image_features["texture_homogeneity"] > 0.4: ps_score += 0.2 ps_signs.append("皮肤质感过于均匀") elif image_features["texture_homogeneity"] > 0.3: ps_score += 0.1 ps_signs.append("皮肤质感较为均匀") # 检查边缘不自然 if "edge_density" in image_features: if image_features["edge_density"] < 0.01: ps_score += 0.2 ps_signs.append("边缘过于平滑") elif image_features["edge_density"] < 0.03: ps_score += 0.1 ps_signs.append("边缘较为平滑") # 检查颜色不自然 if "color_std" in image_features: if image_features["color_std"] > 50: ps_score += 0.2 ps_signs.append("颜色分布极不自然") elif image_features["color_std"] > 30: ps_score += 0.1 ps_signs.append("颜色分布略不自然") # 检查噪点不一致 if "noise_level" in image_features and "noise_std" in image_features: noise_ratio = image_features["noise_std"] / max(image_features["noise_level"], 0.001) if noise_ratio < 0.5: ps_score += 0.2 ps_signs.append("噪点分布不自然") elif noise_ratio < 0.7: ps_score += 0.1 ps_signs.append("噪点分布略不自然") # 检查频率分布不自然 if "freq_ratio" in image_features: if image_features["freq_ratio"] < 0.2: ps_score += 0.2 ps_signs.append("频率分布不自然，可能有过度模糊处理") elif image_features["freq_ratio"] > 2.0: ps_score += 0.2 ps_signs.append("频率分布不自然，可能有过度锐化处理") # 检查细节不一致 if "detail_spatial_std" in image_features and image_features["detail_spatial_std"] > 50: ps_score += 0.2 ps_signs.append("图像细节分布不一致，可能有局部修饰") # 检查边缘过渡不自然 if "edge_transition_std" in image_features: if image_features["edge_transition_std"] > 50: ps_score += 0.2 ps_signs.append("边缘过渡不自然，可能有选区修饰") elif image_features["edge_transition_std"] < 5: ps_score += 0.2 ps_signs.append("边缘过渡过于平滑，可能有过度修饰") return min(ps_score, 1.0), ps_signs # 在这里添加get_detailed_analysis函数 def get_detailed_analysis(ai_probability, ps_score, beauty_score, ps_signs, ai_signs, beauty_signs, valid_models_count, ai_feature_score, image_features=None): """提供更详细的分析结果，使用二级分类框架，优先考虑AI特征分析""" # 根据有效模型数量调整置信度描述 confidence_prefix = "" if valid_models_count >= 3: confidence_prefix = "极高置信度：" elif valid_models_count == 2: confidence_prefix = "高置信度：" elif valid_models_count == 1: confidence_prefix = "中等置信度：" # 特征与模型判断严重不一致时的处理 if ai_feature_score > 0.8 and ai_probability < 0.6: ai_probability = max(0.8, ai_probability) # 当AI特征分数非常高时，覆盖模型判断 category = confidence_prefix + "AI生成图像（基于特征分析）" description = "基于多种典型AI特征分析，该图像很可能是AI生成的，尽管模型判断结果不确定。" main_category = "AI生成" elif ai_feature_score > 0.6 and ai_probability < 0.5: ai_probability = max(0.7, ai_probability) # 当AI特征分数高时，提高AI概率 # 特定关键特征的硬性覆盖 if image_features is not None: if "lbp_entropy" in image_features and image_features["lbp_entropy"] < 2.0: if "freq_anisotropy" in image_features and image_features["freq_anisotropy"] < 0.05: # 当微观纹理熵极低且频率分布各向异性极低时，几乎可以确定是AI生成 ai_probability = 0.95 category = confidence_prefix + "AI生成图像（确定）" description = "检测到多个决定性AI生成特征，该图像几乎可以确定是AI生成的。" main_category = "AI生成" # 添加具体的PS痕迹描述 if ps_signs: ps_details = "检测到的修图痕迹：" + "、".join(ps_signs) else: ps_details = "未检测到明显的修图痕迹。" # 添加AI特征描述 if ai_signs: ai_details = "检测到的AI特征：" + "、".join(ai_signs) else: ai_details = "未检测到明显的AI生成特征。" # 添加美颜特征描述 if beauty_signs: beauty_details = "检测到的美颜特征：" + "、".join(beauty_signs) else: beauty_details = "未检测到明显的美颜特征。" return category, description, ps_details, ai_details, beauty_details, main_category # 第一级分类：AI生成 vs 真人照片 if ai_probability > 0.6: # 降低AI判定阈值，提高AI检出率 category = confidence_prefix + "AI生成图像" description = "图像很可能是由AI完全生成，几乎没有真人照片的特征。" main_category = "AI生成" else: # 第二级分类：真实素人 vs 修图痕迹明显 combined_edit_score = max(ps_score, beauty_score) # 取PS和美颜中的较高分 if combined_edit_score > 0.5: category = confidence_prefix + "真人照片，修图痕迹明显" description = "图像基本是真人照片，但经过了明显的后期处理或美颜，修饰痕迹明显。" main_category = "真人照片-修图明显" else: category = confidence_prefix + "真实素人照片" description = "图像很可能是未经大量处理的真人照片，保留了自然的细节和特征。" main_category = "真人照片-素人" # 处理边界情况 - 当AI概率和修图分数都很高时 if ai_probability > 0.45 and combined_edit_score > 0.7: # 这是一个边界情况，可能是高度修图的真人照片，也可能是AI生成的 category = confidence_prefix + "真人照片，修图痕迹明显（也可能是AI生成）" description = "图像可能是真人照片经过大量后期处理，也可能是AI生成图像。由于现代AI技术与高度修图效果相似，难以完全区分。" main_category = "真人照片-修图明显" # 添加具体的PS痕迹描述 if ps_signs: ps_details = "检测到的修图痕迹：" + "、".join(ps_signs) else: ps_details = "未检测到明显的修图痕迹。" # 添加AI特征描述 if ai_signs: ai_details = "检测到的AI特征：" + "、".join(ai_signs) else: ai_details = "未检测到明显的AI生成特征。" # 添加美颜特征描述 if beauty_signs: beauty_details = "检测到的美颜特征：" + "、".join(beauty_signs) else: beauty_details = "未检测到明显的美颜特征。" return category, description, ps_details, ai_details, beauty_details, main_category def detect_ai_image(image): """主检测函数""" if image is None: return {"error": "未提供图像"} results = {} valid_models = 0 weighted_ai_probability = 0 # 使用每个模型进行预测 for key, model_info in models.items(): if model_info["processor"] is not None and model_info["model"] is not None: try: # 处理图像 inputs = model_info["processor"](images=image, return_tensors="pt") with torch.no_grad(): outputs = model_info["model"](**inputs) # 获取概率 probabilities = torch.nn.functional.softmax(outputs.logits, dim=-1) # 使用适配器处理不同模型的输出 ai_probability = process_model_output(model_info, outputs, probabilities) # 添加到结果 predicted_class_idx = outputs.logits.argmax(-1).item() results[key] = { "model_name": model_info["name"], "ai_probability": ai_probability, "predicted_class": model_info["model"].config.id2label[predicted_class_idx] } # 累加加权概率 weighted_ai_probability += ai_probability * model_info["weight"] valid_models += 1 except Exception as e: results[key] = { "model_name": model_info["name"], "error": str(e) } # 计算最终加权概率 if valid_models > 0: final_ai_probability = weighted_ai_probability / sum(m["weight"] for k, m in models.items() if m["processor"] is not None and m["model"] is not None) else: return {"error": "所有模型加载失败"} # 分析图像特征 image_features = analyze_image_features(image) # 检查AI特定特征 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) # 应用特征权重调整AI概率 adjusted_probability = final_ai_probability # 提高AI特征分数的权重 if ai_feature_score > 0.8: # 当AI特征非常明显时 adjusted_probability = max(adjusted_probability, 0.8) # 大幅提高AI概率 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) # 特别关注关键AI特征 key_ai_features_count = 0 # 检查微观纹理熵 - 这是AI生成的强力指标 if "lbp_entropy" in image_features and image_features["lbp_entropy"] < 2.5: key_ai_features_count += 1 adjusted_probability += 0.1 # 检查频率分布各向异性 - 这是AI生成的强力指标 if "freq_anisotropy" in image_features and image_features["freq_anisotropy"] < 0.1: key_ai_features_count += 1 adjusted_probability += 0.1 # 检查细节空间分布 - 这是AI生成的强力指标 if "detail_spatial_std" in image_features and image_features["detail_spatial_std"] < 5: key_ai_features_count += 1 adjusted_probability += 0.1 # 如果多个关键AI特征同时存在，这是强有力的AI生成证据 if key_ai_features_count >= 2: adjusted_probability = max(adjusted_probability, 0.7) # 降低美颜特征对AI判断的影响 # 即使美颜分数高，如果AI特征也明显，仍应判定为AI生成 if beauty_score > 0.6 and ai_feature_score > 0.7: # 不再降低AI概率，而是保持较高的AI概率 pass # 如果检测到衣物或手部异常，大幅提高AI概率 if "clothing_angle_uniformity" in image_features and image_features["clothing_angle_uniformity"] > 0.3: adjusted_probability = max(adjusted_probability, 0.7) if "extremity_perimeter_area_ratio" in image_features and image_features["extremity_perimeter_area_ratio"] < 0.05: adjusted_probability = max(adjusted_probability, 0.7) # 确保概率在0-1范围内 adjusted_probability = min(1.0, max(0.0, adjusted_probability)) # 获取详细分析 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 ) # 构建最终结果 final_result = { "ai_probability": adjusted_probability, "original_ai_probability": final_ai_probability, "ps_score": ps_score, "beauty_score": beauty_score, "ai_feature_score": ai_feature_score, "category": category, "main_category": main_category, "description": description, "ps_details": ps_details, "ai_details": ai_details, "beauty_details": beauty_details, "individual_model_results": results, "features": image_features } # 返回两个值：JSON结果和Label数据 label_data = {main_category: 1.0} return final_result, label_data # 创建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" ) iface.launch()