image-evaluator 0.0.1__tar.gz

image_evaluator-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Faych Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

image_evaluator-0.0.1/PKG-INFO

@@ -0,0 +1,28 @@
+Metadata-Version: 2.3
+Name: image-evaluator
+Version: 0.0.1
+Summary: An automatic image evaluation script
+License: MIT
+Author: neverbiasu
+Requires-Python: >=3.8,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: clip-score
+Requires-Dist: insightface
+Requires-Dist: numpy
+Requires-Dist: open-clip-torch
+Requires-Dist: pillow
+Requires-Dist: torch (>=1.7.0)
+Requires-Dist: tqdm
+Requires-Dist: transformers
+Description-Content-Type: text/markdown
+
+# image-evaluator
+An automatic image evaluation script
+

image_evaluator-0.0.1/README.md

@@ -0,0 +1,2 @@
+# image-evaluator
+An automatic image evaluation script

image_evaluator-0.0.1/image_evaluator/arcface_dist_predictor.py

@@ -0,0 +1,90 @@
+import os
+import torch
+import torch.nn.functional as F
+from torchvision import transforms
+from PIL import Image
+from insightface.app import FaceAnalysis
+import numpy as np
+
+
+class ArcFaceDistPredictor:
+    def __init__(self, model_name="buffalo_l", device=None):
+        """Initialize ArcFace distance predictor"""
+        if device is None:
+            ctx_id = 0 if torch.cuda.is_available() else -1
+        else:
+            ctx_id = 0 if device == 'cuda' else -1
+
+        # Initialize ArcFace model
+        self.app = FaceAnalysis(model_name)
+        self.app.prepare(ctx_id=ctx_id)
+
+        # Image preprocessing
+        self.transform = transforms.Compose(
+            [
+                transforms.Resize((112, 112)),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+            ]
+        )
+
+    def get_face_embedding(self, image_path):
+        """Get face embedding vector
+
+        Args:
+            image_path: Image file path
+
+        Returns:
+            numpy.ndarray: Face embedding vector or None (if no face is detected)
+        """
+        # Read image and convert to NumPy array
+        img = Image.open(image_path).convert("RGB")
+        img = np.array(img)
+
+        # Get face embedding
+        faces = self.app.get(img)
+        if len(faces) == 0:
+            return None
+        return faces[0].embedding
+
+    def evaluate_arcface_distance(self, reference_path, generated_path):
+        """Evaluate ArcFace distance between two images
+
+        Args:
+            reference_path: Reference image file path
+            generated_path: Generated image file path
+
+        Returns:
+            float: ArcFace distance score or None (if face not detected in either image)
+        """
+        ref_embedding = self.get_face_embedding(reference_path)
+        gen_embedding = self.get_face_embedding(generated_path)
+        if ref_embedding is None or gen_embedding is None:
+            return None
+        return (
+            1
+            - F.cosine_similarity(
+                torch.tensor(ref_embedding), torch.tensor(gen_embedding), dim=0
+            ).item()
+        )
+
+    def evaluate_folder_arcface_distance(self, reference_folder, generated_folder):
+        """Evaluate average ArcFace distance between images in two folders
+
+        Args:
+            reference_folder: Folder path containing reference images
+            generated_folder: Folder path containing generated images
+
+        Returns:
+            float: Average ArcFace distance
+        """
+        reference_images = sorted(os.listdir(reference_folder))
+        generated_images = sorted(os.listdir(generated_folder))
+        distances = []
+        for ref_img, gen_img in zip(reference_images, generated_images):
+            ref_path = os.path.join(reference_folder, ref_img)
+            gen_path = os.path.join(generated_folder, gen_img)
+            dist = self.evaluate_arcface_distance(ref_path, gen_path)
+            if dist is not None:
+                distances.append(dist)
+        return np.mean(distances) if distances else None

image_evaluator-0.0.1/image_evaluator/clip_score_predictor.py

@@ -0,0 +1,296 @@
+# Taken from https://github.com/Taited/clip-score/blob/master/src/clip_score/clip_score.py
+
+import os
+import torch
+import os.path as osp
+from PIL import Image
+from tqdm import tqdm
+from torch.utils.data import DataLoader, Dataset
+from transformers import AutoModel, AutoProcessor, AutoTokenizer
+
+
+class DummyDataset(Dataset):
+
+    FLAGS = ['img', 'txt']
+
+    def __init__(
+        self,
+        real_path,
+        fake_path,
+        real_flag: str = 'img',
+        fake_flag: str = 'txt',
+        transform=None,
+        tokenizer=None,
+    ) -> None:
+        super().__init__()
+        if real_flag not in self.FLAGS or fake_flag not in self.FLAGS:
+            raise TypeError(
+                'CLIP Score only support modality of {}. '
+                'However, get {} and {}'.format(self.FLAGS, real_flag, fake_flag)
+            )
+        self.real_folder = self._combine_without_prefix(real_path)
+        self.real_flag = real_flag
+        self.fake_folder = self._combine_without_prefix(fake_path)
+        self.fake_flag = fake_flag
+        self.transform = transform
+        self.tokenizer = tokenizer
+        # assert self._check()
+
+    def __len__(self):
+        if isinstance(self.real_folder, list):
+            real_folder_length = len(self.real_folder)
+        else:
+            real_folder_lenghth = 1
+        if isinstance(self.fake_folder, list):
+            fake_folder_length = len(self.fake_folder)
+        else:
+            fake_folder_lenghth = 1
+        return max(real_folder_lenghth, fake_folder_length)
+
+    def __getitem__(self, index):
+        if index >= len(self):
+            raise IndexError
+        if isinstance(self.real_folder, list):
+            real_path = self.real_folder[index]
+        else:
+            real_path = self.real_folder
+        if isinstance(self.fake_folder, list):
+            fake_path = self.fake_folder[index]
+        else:
+            fake_path = self.fake_folder
+        real_data = self._load_modality(real_path, self.real_flag)
+        fake_data = self._load_modality(fake_path, self.fake_flag)
+
+        sample = dict(real=real_data, fake=fake_data)
+        return sample
+
+    def _load_modality(self, path, modality):
+        if modality == 'img':
+            data = self._load_img(path)
+        elif modality == 'txt':
+            data = self._load_txt(path)
+        else:
+            raise TypeError('Got unexpected modality: {}'.format(modality))
+        return data
+
+    def _load_img(self, path):
+        img = Image.open(path)
+        if self.transform is not None:
+            img = self.transform(text=None, images=img)
+            img['pixel_values'] = img['pixel_values'][0]
+        return img
+
+    def _load_txt(self, path):
+        if osp.exists(path):
+            with open(path, 'r') as fp:
+                data = fp.read()
+                fp.close()
+        else:
+            data = path
+        if self.transform is not None:
+            data = self.tokenizer(data, padding=True, return_tensors='pt')
+            for key in data:
+                data[key] = data[key].squeeze()
+        return data
+
+    def _check(self):
+        for idx in range(len(self)):
+            real_name = self.real_folder[idx].split('.')
+            fake_name = self.fake_folder[idx].split('.')
+            if fake_name != real_name:
+                return False
+        return True
+
+    def _combine_without_prefix(self, folder_path, prefix='.'):
+        if not osp.exists(folder_path):
+            return folder_path
+        folder = []
+        for name in os.listdir(folder_path):
+            if name[0] == prefix:
+                continue
+            folder.append(osp.join(folder_path, name))
+        folder.sort()
+        return folder
+
+
+class ClipScorePredictor:
+    def __init__(self, clip_model='openai/clip-vit-base-patch32', device=None):
+        if device is None:
+            self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        else:
+            self.device = torch.device(device)
+
+        print('Loading CLIP model: {}'.format(clip_model))
+        self.model = AutoModel.from_pretrained(clip_model).to(self.device)
+        self.processor = AutoProcessor.from_pretrained(clip_model)
+        self.tokenizer = AutoTokenizer.from_pretrained(clip_model)
+
+    def evaluate_clip_score(
+        self,
+        real_path,
+        fake_path,
+        real_flag='img',
+        fake_flag='txt',
+        batch_size=50,
+        num_workers=None,
+    ):
+        """Evaluate CLIP score between images and text
+
+        Supports both single files and folders evaluation.
+
+        Args:
+            real_path: Path to real image or folder
+            fake_path: Path to text prompt or folder, or text string directly
+            real_flag: Type of real input modality, 'img' or 'txt'
+            fake_flag: Type of fake input modality, 'img' or 'txt'
+            batch_size: Batch size
+            num_workers: Number of workers for data loader
+
+        Returns:
+            float: CLIP score
+        """
+        # Check if it's a single file
+        if os.path.isfile(real_path) and (
+            not os.path.exists(fake_path) or os.path.isfile(fake_path)
+        ):
+            return self._evaluate_single_file(
+                real_path, fake_path, real_flag, fake_flag
+            )
+        else:
+            return self.evaluate_folder_clip_score(
+                real_path, fake_path, real_flag, fake_flag, batch_size, num_workers
+            )
+
+    def evaluate_folder_clip_score(
+        self,
+        real_path,
+        fake_path,
+        real_flag='img',
+        fake_flag='txt',
+        batch_size=50,
+        num_workers=None,
+    ):
+        """Evaluate CLIP score between multiple files in folders
+
+        Args:
+            real_path: Path to folder containing real inputs
+            fake_path: Path to folder containing fake inputs
+            real_flag: Type of real input modality, 'img' or 'txt'
+            fake_flag: Type of fake input modality, 'img' or 'txt'
+            batch_size: Batch size
+            num_workers: Number of workers for data loader
+
+        Returns:
+            float: CLIP score
+        """
+        if num_workers is None:
+            try:
+                num_cpus = len(os.sched_getaffinity(0))
+            except AttributeError:
+                num_cpus = os.cpu_count()
+            num_workers = min(num_cpus, 8) if num_cpus is not None else 0
+
+        dataset = DummyDataset(
+            real_path,
+            fake_path,
+            real_flag,
+            fake_flag,
+            transform=self.processor,
+            tokenizer=self.tokenizer,
+        )
+        dataloader = DataLoader(
+            dataset, batch_size, num_workers=num_workers, pin_memory=True
+        )
+
+        print('Calculating CLIP Score:')
+        score_acc = 0.0
+        sample_num = 0.0
+        for batch_data in tqdm(dataloader):
+            real = batch_data['real']
+            real_features = self._forward_modality(real, real_flag)
+            fake = batch_data['fake']
+            fake_features = self._forward_modality(fake, fake_flag)
+
+            # normalize features
+            real_features = real_features / real_features.norm(dim=1, keepdim=True).to(
+                torch.float32
+            )
+            fake_features = fake_features / fake_features.norm(dim=1, keepdim=True).to(
+                torch.float32
+            )
+
+            # calculate scores
+            score = (fake_features * real_features).sum()
+            score_acc += score
+            sample_num += real_features.shape[0]
+
+        clip_score = score_acc / sample_num
+        return clip_score.cpu().item()
+
+    def _evaluate_single_file(
+        self, image_path, text_path_or_string, image_flag='img', text_flag='txt'
+    ):
+        """Evaluate CLIP score between a single image file and text
+
+        Args:
+            image_path: Path to image file
+            text_path_or_string: Path to text file or text string directly
+            image_flag: Type of image input modality, default is 'img'
+            text_flag: Type of text input modality, default is 'txt'
+
+        Returns:
+            float: CLIP score
+        """
+        # Determine which is image and which is text
+        if image_flag == 'img' and text_flag == 'txt':
+            img_path, txt_path = image_path, text_path_or_string
+            img_flag, txt_flag = image_flag, text_flag
+        elif image_flag == 'txt' and text_flag == 'img':
+            img_path, txt_path = text_path_or_string, image_path
+            img_flag, txt_flag = text_flag, image_flag
+        else:
+            raise ValueError("Must specify one 'img' and one 'txt' modality")
+
+        # Create a single sample dataset
+        dataset = DummyDataset(
+            img_path,
+            txt_path,
+            img_flag,
+            txt_flag,
+            transform=self.processor,
+            tokenizer=self.tokenizer,
+        )
+
+        # Get data
+        sample = dataset[0]
+        img_data = sample['real'] if img_flag == 'real_flag' else sample['fake']
+        txt_data = sample['fake'] if txt_flag == 'txt' else sample['real']
+
+        # Compute features
+        img_features = self._forward_modality(img_data, 'img')
+        txt_features = self._forward_modality(txt_data, 'txt')
+
+        # Normalize features
+        img_features = img_features / img_features.norm(dim=1, keepdim=True).to(
+            torch.float32
+        )
+        txt_features = txt_features / txt_features.norm(dim=1, keepdim=True).to(
+            torch.float32
+        )
+
+        # Compute score
+        score = (img_features * txt_features).sum()
+
+        return score.cpu().item()
+
+    def _forward_modality(self, data, flag):
+        device = self.device
+        for key in data:
+            data[key] = data[key].to(device)
+        if flag == 'img':
+            features = self.model.get_image_features(**data)
+        elif flag == 'txt':
+            features = self.model.get_text_features(**data)
+        else:
+            raise TypeError(f'Got unexpected modality: {flag}')
+        return features

image_evaluator-0.0.1/image_evaluator/laion_ai_aesthetic_predictor.py

@@ -0,0 +1,100 @@
+# Taken from https://github.com/LAION-AI/aesthetic-predictor/blob/main/asthetics_predictor.ipynb
+
+import os
+import torch
+import open_clip
+import torch.nn as nn
+from PIL import Image
+from os.path import expanduser  # pylint: disable=import-outside-toplevel
+from urllib.request import urlretrieve  # pylint: disable=import-outside-toplevel
+
+
+class LaionAIAestheticPredictor:
+    def __init__(self, model_name="vit_l_14"):
+        """Initialize the aesthetic predictor with a specified model."""
+        self.model_name = model_name
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.aes_model = self.get_aesthetic_model()
+
+    def get_aesthetic_model(self):
+        """Load the aesthetic model based on the model type defined in __init__."""
+        home = expanduser("~")
+        cache_folder = home + "/.cache/emb_reader"
+        path_to_model = cache_folder + f"/sa_0_4_{self.model_name}_linear.pth"
+
+        if not os.path.exists(path_to_model):
+            os.makedirs(cache_folder, exist_ok=True)
+            url_model = f"https://github.com/LAION-AI/aesthetic-predictor/blob/main/sa_0_4_{self.model_name}_linear.pth?raw=true"
+            urlretrieve(url_model, path_to_model)
+
+        if self.model_name == "vit_l_14":
+            m = nn.Linear(768, 1)
+        elif self.model_name == "vit_b_32":
+            m = nn.Linear(512, 1)
+        else:
+            raise ValueError(f"Unsupported model: {self.model_name}")
+
+        s = torch.load(path_to_model, map_location=self.device)
+        m.load_state_dict(s)
+        m.to(self.device)
+        m.eval()
+        return m
+
+    def evaluate_aesthetic_score(self, image_path):
+        """Evaluate the aesthetic score of a single image
+
+        Args:
+            image_path: Path to the image file
+
+        Returns:
+            float: Aesthetic score of the image
+        """
+        if self.aes_model is None:
+            self.aes_model = self.get_aesthetic_model()
+
+        model, _, preprocess = open_clip.create_model_and_transforms(
+            'ViT-L-14', pretrained='openai'
+        )
+        try:
+            image = Image.open(image_path).convert('RGB')
+            image_tensor = preprocess(image).unsqueeze(0).to(self.device)
+
+            with torch.no_grad():
+                image_features = model.encode_image(image_tensor)
+                image_features /= image_features.norm(dim=-1, keepdim=True)
+                score = self.aes_model(image_features)
+
+            return score[0][0].item()
+        except Exception as e:
+            print(f"Error evaluating image {image_path}: {e}")
+            return None
+
+    def evaluate_folder_aesthetic_score(self, folder_path):
+        """Evaluate the average aesthetic score of all images in a folder
+
+        Args:
+            folder_path: Path to folder containing images
+
+        Returns:
+            float: Average aesthetic score of all images in the folder
+        """
+        if not os.path.isdir(folder_path):
+            raise ValueError(f"{folder_path} is not a valid folder path")
+
+        image_files = [
+            f
+            for f in os.listdir(folder_path)
+            if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.webp'))
+        ]
+
+        if not image_files:
+            return None
+
+        scores = []
+        for img_file in image_files:
+            img_path = os.path.join(folder_path, img_file)
+            score = self.evaluate_aesthetic_score(img_path)
+            if score is not None:
+                scores.append(score)
+
+        return sum(scores) / len(scores) if scores else None

image_evaluator-0.0.1/image_evaluator/main.py

@@ -0,0 +1,67 @@
+import argparse
+import os
+from image_evaluator.laion_ai_aesthetic_predictor import LaionAIAestheticPredictor
+from image_evaluator.clip_score_predictor import ClipScorePredictor
+from image_evaluator.arcface_dist_predictor import ArcFaceDistPredictor
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Evaluate the aesthetic score of an image."
+    )
+    parser.add_argument("--image", type=str, help="Path to the image file or folder")
+    parser.add_argument(
+        "--prompt",
+        type=str,
+        default=None,
+        help="Path to the prompt file or text prompt",
+    )
+    parser.add_argument(
+        "--reference",
+        type=str,
+        default=None,
+        help="Path to the reference image for ArcFace distance",
+    )
+    args = parser.parse_args()
+
+    # Check if it's a file or folder
+    is_folder = os.path.isdir(args.image) if args.image else False
+
+    # LAION AI Aesthetic Score
+    laion_ai_aesthetic_predictor = LaionAIAestheticPredictor()
+    if is_folder:
+        laion_ai_aesthetic_score = (
+            laion_ai_aesthetic_predictor.evaluate_folder_aesthetic_score(args.image)
+        )
+    else:
+        laion_ai_aesthetic_score = (
+            laion_ai_aesthetic_predictor.evaluate_aesthetic_score(args.image)
+        )
+
+    # CLIP Score Evaluation
+    clip_score_predictor = ClipScorePredictor()
+    clip_score = clip_score_predictor.evaluate_clip_score(args.image, args.prompt)
+
+    # ArcFace Distance Evaluation
+    arcface_distance_predictor = ArcFaceDistPredictor()
+    if is_folder and args.reference and os.path.isdir(args.reference):
+        arcface_distance = arcface_distance_predictor.evaluate_folder_arcface_distance(
+            args.reference, args.image
+        )
+    elif args.reference:
+        arcface_distance = arcface_distance_predictor.evaluate_arcface_distance(
+            args.reference, args.image
+        )
+    else:
+        arcface_distance = None
+
+    print(f"LAION AI Aesthetic Score: {laion_ai_aesthetic_score}")
+    print(f"CLIP Score: {clip_score}")
+    if arcface_distance is not None:
+        print(f"ArcFace Distance: {arcface_distance}")
+    else:
+        print("ArcFace Distance: Not evaluated (reference image required)")
+
+
+if __name__ == "__main__":
+    main()

image_evaluator-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[tool.poetry]
+name = "image-evaluator"
+version = "0.0.1"
+description = "An automatic image evaluation script"
+authors = ["neverbiasu"]
+license = "MIT"
+readme = "README.md"
+packages = [{include = "image_evaluator"}]
+
+[tool.poetry.dependencies]
+python = "^3.8"
+clip-score = "*"
+insightface = "*"
+open-clip-torch = "*"
+torch = ">=1.7.0"
+transformers = "*"
+pillow = "*"
+numpy = "*"
+tqdm = "*"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.0.0"
+black = "^23.0.0"
+isort = "^5.12.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+image-evaluator = "image_evaluator.main:main"