画像生成モデル評価手法完全ガイド｜基礎から2025年最新技術まで徹底解説

FID = ||μ₁ - μ₂||² + Tr(Σ₁ + Σ₂ - 2(Σ₁Σ₂)^(1/2))

from torchmetrics.image.fid import FrechetInceptionDistance

fid = FrechetInceptionDistance(normalize=True)
fid.update(real_images, real=True)
fid.update(fake_images, real=False)
fid_score = fid.compute()
print(f"FID Score: {fid_score:.2f}")

# 評価基準
if fid_score < 10:
    print("生成画像の品質は非常に高い")
elif fid_score < 50:
    print("生成画像の品質は良好")
else:
    print("生成画像の品質改善が必要")

IS = exp(E[KL(p(y|x) || p(y))])

from torchmetrics.image.inception import InceptionScore

inception_score = InceptionScore()
inception_score.update(generated_images)
is_mean, is_std = inception_score.compute()
print(f"IS: {is_mean:.2f} ± {is_std:.2f}")

# 一般的な基準値
# IS > 8: 非常に良い
# IS > 5: 良い  
# IS < 3: 改善が必要

import lpips

# LPIPS損失関数の初期化
loss_fn = lpips.LPIPS(net='vgg')

# 2つの画像間の知覚的距離を計算
distance = loss_fn(image1, image2)
print(f"LPIPS Distance: {distance.item():.4f}")

# 評価基準
if distance < 0.1:
    print("非常に類似している")
elif distance < 0.3:
    print("やや類似している")  
else:
    print("大きく異なっている")

def calculate_ppl(generator, latent_codes, epsilon=1e-4):
    ppl_scores = []
    
    for z in latent_codes:
        # 元の潜在コードと微小変化させたコードから画像生成
        img1 = generator(z)
        img2 = generator(z + epsilon * torch.randn_like(z))
        
        # VGG特徴量での距離計算
        distance = vgg_distance(img1, img2)
        ppl_scores.append(distance)
    
    return np.mean(ppl_scores)

def compute_precision_recall(real_features, fake_features, k=3):
    # k-nearest neighbor による支配領域の計算
    real_distances = compute_knn_distances(real_features, k=k)
    
    precision = 0
    for fake_feat in fake_features:
        if is_in_manifold(fake_feat, real_features, real_distances):
            precision += 1
    precision /= len(fake_features)
    
    # Recallは逆の計算
    recall = compute_coverage(real_features, fake_features)
    
    return precision, recall

import clip
import torch
from PIL import Image

# CLIPモデルの読み込み
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

def calculate_clip_score(image, text_prompt):
    # 画像とテキストの前処理
    image_input = preprocess(image).unsqueeze(0).to(device)
    text_input = clip.tokenize([text_prompt]).to(device)
    
    # 特徴ベクトルの抽出
    with torch.no_grad():
        image_features = model.encode_image(image_input)
        text_features = model.encode_text(text_input)
    
    # コサイン類似度の計算
    similarity = torch.cosine_similarity(image_features, text_features)
    return similarity.item()

# 使用例
prompt = "a beautiful sunset over the ocean"
generated_image = Image.open("generated_sunset.jpg")
score = calculate_clip_score(generated_image, prompt)
print(f"CLIP Score: {score:.4f}")

from torchmetrics.multimodal import CLIPScore

clip_score = CLIPScore(model_name_or_path="openai/clip-vit-base-patch16")

# 品質評価プロンプト
quality_prompts = [
    "a high quality photo",
    "a clear and sharp image", 
    "a professional photograph"
]

scores = []
for prompt in quality_prompts:
    score = clip_score(generated_image, prompt)
    scores.append(score)

average_quality = np.mean(scores)
print(f"Average Quality Score: {average_quality:.4f}")

# 評価フォームの例
evaluation_criteria = {
    "realism": "画像のリアルさ（1-5点）",
    "prompt_alignment": "プロンプトとの一致度（1-5点）", 
    "aesthetic_quality": "美的な魅力（1-5点）",
    "technical_quality": "技術的品質（ノイズ、解像度等）（1-5点）",
    "creativity": "創造性・独創性（1-5点）"
}

evaluation_setup = {
    "evaluators": 50,  # 評価者数
    "images_per_evaluator": 100,  # 1人あたりの評価画像数
    "evaluation_time": "20分以内",
    "display_conditions": "同一環境での表示",
    "reference_images": "品質基準となる参考画像の提示"
}

import crowdsourcing_platform

def setup_evaluation_task():
    task = {
        "title": "画像品質評価タスク",
        "description": "生成された画像の品質を評価してください",
        "qualification_requirements": [
            "過去の評価精度が85%以上",
            "母国語が評価対象言語"
        ],
        "reward": "$0.10 per evaluation",
        "time_limit": "5分以内"
    }
    return task

# 品質管理
def quality_control(evaluations):
    # 一致率の低い評価者を除外
    reliable_evaluators = filter_reliable_evaluators(evaluations)
    
    # 異常値の検出と除去
    cleaned_data = remove_outliers(evaluations)
    
    return cleaned_data

import numpy as np
from scipy import stats

def analyze_evaluation_results(scores):
    # 基本統計量
    mean_score = np.mean(scores)
    std_score = np.std(scores)
    
    # 信頼区間の計算
    confidence_interval = stats.t.interval(
        0.95, len(scores)-1, 
        loc=mean_score, 
        scale=stats.sem(scores)
    )
    
    # 評価者間一致度
    inter_rater_reliability = calculate_icc(scores)
    
    return {
        "mean": mean_score,
        "std": std_score,
        "confidence_interval": confidence_interval,
        "reliability": inter_rater_reliability
    }

import openai

def evaluate_with_gpt4v(image_path, prompt):
    evaluation_prompt = f"""
    以下の画像を詳細に分析し、下記の観点から評価してください：
    
    1. 技術的品質（解像度、ノイズ、アーティファクト）: 1-10点
    2. プロンプト一致度: 1-10点  
    3. 美的魅力: 1-10点
    4. 創造性: 1-10点
    5. 実用性: 1-10点
    
    プロンプト: "{prompt}"
    
    各項目について具体的な理由も併せて説明してください。
    """
    
    response = openai.ChatCompletion.create(
        model="gpt-4-vision-preview",
        messages=[
            {
                "role": "user", 
                "content": [
                    {"type": "text", "text": evaluation_prompt},
                    {"type": "image_url", "image_url": {"url": image_path}}
                ]
            }
        ]
    )
    
    return response.choices[0].message.content

from torchmetrics.image import CLIP_IQA

clip_iqa = CLIP_IQA()

# Zero-shot評価（追加学習不要）
quality_score = clip_iqa(generated_image)
print(f"Image Quality Score: {quality_score:.4f}")

# 特殊ドメインでも安定した性能
document_score = clip_iqa(document_image)
artwork_score = clip_iqa(artwork_image)

class ComprehensiveImageEvaluator:
    def __init__(self):
        self.fid_evaluator = FIDEvaluator()
        self.is_evaluator = ISEvaluator()
        self.lpips_evaluator = LPIPSEvaluator()
        self.clip_evaluator = CLIPEvaluator()
        self.human_evaluator = HumanEvaluator()
    
    def evaluate_comprehensive(self, generated_images, real_images, prompts):
        results = {}
        
        # 定量的評価
        results['fid'] = self.fid_evaluator.compute(generated_images, real_images)
        results['is'] = self.is_evaluator.compute(generated_images)
        results['lpips'] = self.lpips_evaluator.compute(generated_images, real_images)
        results['clip_score'] = self.clip_evaluator.compute(generated_images, prompts)
        
        # 人間評価（サンプリング）
        sample_images = self.sample_for_human_eval(generated_images, n=100)
        results['human_eval'] = self.human_evaluator.evaluate(sample_images)
        
        # 総合スコアの計算
        results['overall_score'] = self.calculate_weighted_score(results)
        
        return results
    
    def calculate_weighted_score(self, results):
        # 用途に応じた重み付け
        weights = {
            'fid': 0.3,      # 品質重視
            'is': 0.2,       # 多様性
            'clip_score': 0.3, # プロンプト一致
            'human_eval': 0.2  # 主観評価
        }
        
        normalized_scores = self.normalize_scores(results)
        overall = sum(weights[k] * normalized_scores[k] for k in weights)
        return overall

commercial_evaluation_config = {
    "primary_metrics": ["human_evaluation", "clip_score"],
    "secondary_metrics": ["fid", "aesthetic_score"],
    "focus_areas": ["user_satisfaction", "prompt_accuracy", "brand_safety"],
    "evaluation_frequency": "weekly",
    "sample_size": 1000
}

research_evaluation_config = {
    "primary_metrics": ["fid", "is", "lpips"],
    "secondary_metrics": ["ppl", "precision_recall"],
    "focus_areas": ["technical_quality", "diversity", "novelty"],
    "evaluation_frequency": "per_experiment",
    "statistical_significance": 0.05
}

creative_evaluation_config = {
    "primary_metrics": ["human_evaluation", "aesthetic_score"],
    "secondary_metrics": ["creativity_score", "originality_index"],
    "focus_areas": ["artistic_value", "emotional_impact", "cultural_sensitivity"],
    "expert_panel": True,
    "artist_feedback": True
}

# 効率的な評価パイプライン
class EfficientEvaluationPipeline:
    def __init__(self):
        self.batch_size = 32
        self.gpu_parallel = True
        self.cache_features = True
    
    def evaluate_batch(self, images, use_cache=True):
        if use_cache and self.cached_features_exist(images):
            features = self.load_cached_features(images)
        else:
            features = self.extract_features_parallel(images)
            if use_cache:
                self.cache_features(images, features)
        
        scores = self.compute_scores_vectorized(features)
        return scores
    
    def smart_sampling(self, large_dataset, target_samples=1000):
        # 代表性を保ったサンプリング
        return self.stratified_sample(large_dataset, target_samples)

class ReproducibleEvaluator:
    def __init__(self, seed=42):
        self.seed = seed
        self.version_info = {
            "torch_version": torch.__version__,
            "numpy_version": np.__version__,
            "model_version": "stable-diffusion-v1.5",
            "evaluation_date": datetime.now().isoformat()
        }
    
    def set_deterministic_behavior(self):
        torch.manual_seed(self.seed)
        np.random.seed(self.seed)
        torch.backends.cudnn.deterministic = True
        torch.backends.cudnn.benchmark = False
    
    def log_evaluation_config(self, config):
        with open('evaluation_log.json', 'w') as f:
            json.dump({
                'config': config,
                'version_info': self.version_info,
                'random_seed': self.seed
            }, f, indent=2)

t2i_benchmark_2025 = {
    "total_prompts": 10000,
    "categories": [
        "realistic_photography", "artistic_illustration", 
        "technical_diagrams", "abstract_concepts",
        "cultural_specific", "multilingual_prompts"
    ],
    "evaluation_metrics": [
        "fid", "clip_score", "human_preference", 
        "cultural_appropriateness", "factual_accuracy"
    ],
    "languages": ["en", "ja", "zh", "es", "ar", "hi"]
}

def staged_evaluation_pipeline(generated_images, prompts):
    # Stage 1: 高速スクリーニング
    quick_scores = compute_basic_metrics(generated_images)
    candidates = filter_top_candidates(generated_images, quick_scores, top_k=1000)
    
    # Stage 2: 詳細評価
    detailed_scores = compute_comprehensive_metrics(candidates, prompts)
    finalists = select_finalists(candidates, detailed_scores, top_k=100)
    
    # Stage 3: 人間評価
    human_scores = conduct_human_evaluation(finalists)
    
    return combine_evaluation_results(quick_scores, detailed_scores, human_scores)

class ContinuousEvaluationSystem:
    def __init__(self):
        self.evaluation_history = []
        self.performance_thresholds = {
            'fid': 50.0,
            'clip_score': 0.7,
            'human_rating': 3.5
        }
    
    def monitor_model_drift(self, current_scores):
        # 性能劣化の検出
        historical_baseline = self.get_baseline_scores()
        drift_detected = self.detect_significant_change(
            current_scores, historical_baseline
        )
        
        if drift_detected:
            self.trigger_model_update_alert()
        
        return drift_detected
    
    def adaptive_evaluation_frequency(self, model_stability):
        # モデルの安定性に応じた評価頻度調整
        if model_stability < 0.8:
            return "daily"
        elif model_stability < 0.95:
            return "weekly"
        else:
            return "monthly"

class RobustEvaluationFramework:
    def __init__(self):
        self.max_retries = 3
        self.timeout_seconds = 300
        self.fallback_metrics = ['fid', 'is']  # 最低限の評価指標
    
    def safe_evaluation(self, images, metrics_config):
        results = {}
        
        for metric_name, metric_func in metrics_config.items():
            try:
                score = self.evaluate_with_timeout(metric_func, images)
                results[metric_name] = score
                
            except TimeoutError:
                logger.warning(f"{metric_name} evaluation timed out")
                results[metric_name] = None
                
            except Exception as e:
                logger.error(f"Error in {metric_name}: {str(e)}")
                if metric_name in self.fallback_metrics:
                    results[metric_name] = self.get_fallback_score(metric_name)
                else:
                    results[metric_name] = None
        
        # 必須指標の確認
        if not self.has_minimum_metrics(results):
            raise EvaluationError("Failed to compute minimum required metrics")
        
        return results
    
    def validate_evaluation_results(self, results):
        # 異常値の検出
        for metric, score in results.items():
            if score is not None:
                if not self.is_score_reasonable(metric, score):
                    logger.warning(f"Unusual {metric} score: {score}")
        
        return results

ethical_evaluation_framework = {
    "bias_detection": {
        "gender_bias": "generated_faces_gender_balance",
        "racial_bias": "skin_tone_diversity_index", 
        "age_bias": "age_representation_fairness"
    },
    "harmful_content": {
        "violence_detection": "nsfw_content_classifier",
        "stereotype_detection": "cultural_sensitivity_analyzer",
        "misinformation": "factual_accuracy_verifier"
    },
    "privacy_protection": {
        "face_anonymization": "identity_protection_score",
        "personal_info": "pii_detection_and_masking"
    }
}