# Copyright 2024 Hui Lu, Fang Dai, Siqiong Yao. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import os # import torch # import numpy as np # import torchvision.transforms as transforms # from torch.utils.data import DataLoader, Dataset # from PIL import Image # from gtda.images import Binarizer, HeightFiltration # from gtda.homology import CubicalPersistence # from gtda.diagrams import Amplitude # from sklearn.metrics import pairwise_distances # transform = transforms.Compose([ # transforms.Resize((256, 256)), # transforms.ToTensor(), # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # ]) # class ImageFolderDataset(Dataset): # def __init__(self, folder_path, transform=None): # self.file_paths = [os.path.join(folder_path, f) for f in os.listdir(folder_path) if f.endswith('.png')] # self.transform = transform # def __len__(self): # return len(self.file_paths) # def __getitem__(self, idx): # img_path = self.file_paths[idx] # image = Image.open(img_path).convert('RGB') # if self.transform: # image = self.transform(image) # return image # def load_data(folder_path): # dataset = ImageFolderDataset(folder_path, transform=transform) # loader = DataLoader(dataset, batch_size=10, shuffle=False) # return loader # # 计算Diversity Score # def calculate_diversity_score(features): # distances = pairwise_distances(features, metric='euclidean') # diversity_score = np.mean(distances) # return diversity_score # # 计算Geometry Score # def calculate_geometry_score(images): # binarizer = Binarizer(threshold=0.5) # height_filtration = HeightFiltration(direction=np.array([1, 1, 1])) # cubical_persistence = CubicalPersistence(homology_dimensions=[0, 1], coeff=2) # amplitude = Amplitude(metric='wasserstein', metric_params={'p': 2}) # # Preprocess images # images = np.array([img.numpy() if isinstance(img, torch.Tensor) else img for img in images]) # images_binarized = binarizer.fit_transform(images) # images_filtered = height_filtration.fit_transform(images_binarized) # diagrams = cubical_persistence.fit_transform(images_filtered) # gs_score = amplitude.fit_transform(diagrams) # return gs_score.mean() # generated_images_loader = load_data('../figure/1') # real_images_loader = load_data('../figure/2') # generated_features = [] # real_features = [] # for img_batch in generated_images_loader: # generated_features.extend(img_batch.numpy()) # for img_batch in real_images_loader: # real_features.extend(img_batch.numpy()) # generated_features = np.array(generated_features) # real_features = np.array(real_features) # # 计算Diversity Score # generated_div_score = calculate_diversity_score(generated_features.reshape(len(generated_features), -1)) # real_div_score = calculate_diversity_score(real_features.reshape(len(real_features), -1)) # # 计算Geometry Score # generated_gs_score = calculate_geometry_score(generated_features) # real_gs_score = calculate_geometry_score(real_features) # print(f"Generated Images Diversity Score: {generated_div_score}") # print(f"Real Images Diversity Score: {real_div_score}") # print(f"Generated Images Geometry Score: {generated_gs_score}") # print(f"Real Images Geometry Score: {real_gs_score}") # import torch # import torch.nn.functional as F # from torchvision import transforms # from PIL import Image # import numpy as np # import os # # Function to load and preprocess images # def load_and_preprocess_image(img_path): # img = Image.open(img_path).convert('RGB') # preprocess = transforms.Compose([ # transforms.ToTensor(), # ]) # img = preprocess(img).unsqueeze(0) # Add batch dimension # return img # # Function to compute image gradients # def compute_gradients(img): # grad_x = img[:, :, 1:, :] - img[:, :, :-1, :] # grad_y = img[:, :, :, 1:] - img[:, :, :, :-1] # return grad_x, grad_y # # Function to calculate Gradient Similarity (GS) # def gradient_similarity(real_img, gen_img): # real_grad_x, real_grad_y = compute_gradients(real_img) # gen_grad_x, gen_grad_y = compute_gradients(gen_img) # grad_sim_x = F.cosine_similarity(real_grad_x, gen_grad_x, dim=1).mean() # grad_sim_y = F.cosine_similarity(real_grad_y, gen_grad_y, dim=1).mean() # gs = (grad_sim_x + grad_sim_y) / 2.0 # return gs.item() # # Example usage # real_img_dir = '../GS/real' # Replace with your real image directory # gen_img_dir = '../GS/fake' # Replace with your generated image directory # real_img_paths = [os.path.join(real_img_dir, fname) for fname in os.listdir(real_img_dir) if fname.endswith(('jpg', 'jpeg', 'png'))] # gen_img_paths = [os.path.join(gen_img_dir, fname) for fname in os.listdir(gen_img_dir) if fname.endswith(('jpg', 'jpeg', 'png'))] # # Ensure both directories have the same number of images # assert len(real_img_paths) == len(gen_img_paths), "The number of images in both directories must be the same" # gs_scores = [] # for real_img_path, gen_img_path in zip(real_img_paths, gen_img_paths): # real_img = load_and_preprocess_image(real_img_path) # gen_img = load_and_preprocess_image(gen_img_path) # gs = gradient_similarity(real_img, gen_img) # gs_scores.append(gs) # print(f'Processed {real_img_path} and {gen_img_path}: GS = {gs:.3e}') # mean_gs = np.mean(gs_scores) # print(f'Mean Gradient Similarity (GS) score: {mean_gs:.3e}') import torch import torch.nn as nn from torchvision import models, transforms from PIL import Image import numpy as np import os from prdc import compute_prdc # Function to load and preprocess images def load_and_preprocess_image(img_path): img = Image.open(img_path).convert('RGB') preprocess = transforms.Compose([ transforms.Resize((299, 299)), transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]), ]) img = preprocess(img).unsqueeze(0) # Add batch dimension return img # Function to extract features using InceptionV3 def extract_features(img_paths, model): features = [] with torch.no_grad(): for img_path in img_paths: img = load_and_preprocess_image(img_path) feature = model(img).numpy().squeeze() features.append(feature) features = np.array(features) return features # Load the InceptionV3 model model = models.resnet18(pretrained=False) model.load_state_dict(torch.load('../modelsaved/Pretrained_InceptionV3.pth', map_location=lambda storage, loc: storage),strict=False) model.fc = nn.Identity() # Remove the final classification layer model.eval() # Example usage real_img_dir = '../dataset/1' # Replace with your real image directory gen_img_dir = '../dataset/2' # Replace with your generated image directory real_img_paths = [os.path.join(real_img_dir, fname) for fname in os.listdir(real_img_dir) if fname.endswith(('jpg', 'jpeg', 'png'))] gen_img_paths = [os.path.join(gen_img_dir, fname) for fname in os.listdir(gen_img_dir) if fname.endswith(('jpg', 'jpeg', 'png'))] # Extract features for real and generated images real_features = extract_features(real_img_paths, model) gen_features = extract_features(gen_img_paths, model) # Calculate PRDC metrics metrics = compute_prdc(real_features=real_features, fake_features=gen_features, nearest_k=2) print(metrics) # import torch # from torch import nn # from clip import clip # import numpy as np # clip_model, preprocess = clip.load("ViT-L/14@336px", device="cuda") # def get_clip_embedding(images): # with torch.no_grad(): # images = preprocess(images).unsqueeze(0).to("cuda") # image_features = clip_model.encode_image(images) # return image_features # def compute_mmd(x, y, kernel): # xx = kernel(x, x) # yy = kernel(y, y) # xy = kernel(x, y) # mmd = torch.mean(xx) + torch.mean(yy) - 2 * torch.mean(xy) # return mmd # def gaussian_rbf_kernel(x, y, sigma=1.0): # dist = torch.cdist(x, y, p=2.0) # return torch.exp(-dist**2 / (2 * sigma**2)) # real_images = ... # generated_images = ... # real_features = get_clip_embedding(real_images) # generated_features = get_clip_embedding(generated_images) # sigma = 1.0 # mmd = compute_mmd(real_features, generated_features, lambda x, y: gaussian_rbf_kernel(x, y, sigma)) # cmmd = mmd * 1000 # print(f"CMMD: {cmmd.item()}")