AI生成画像 品質管理・自動採点・リジェクトシステム構築完全ガイド 2026年版

1-1. スコアリングアーキテクチャ全体像

AI生成画像の自動品質評価には、現在3つのアプローチが実用段階にある。いずれも CLIP ViT-L/14 の画像エンベディングを基盤とし、その上に軽量な評価器を乗せる設計だ。

1-2. LAION Aesthetic Predictorの実装コード

インストールと基本推論の完全実装：

# ===== インストール =====
# pip install torch torchvision open_clip_torch Pillow

import torch
import torch.nn as nn
import open_clip
from PIL import Image
from urllib.request import urlretrieve
import os

# ===== モデルロード =====
def load_aesthetic_model(clip_model="ViT-L-14"):
    """LAION Aesthetic Predictor v2をロード"""
    home = os.path.expanduser("~")
    cache_dir = os.path.join(home, ".cache/aesthetic_predictor")
    os.makedirs(cache_dir, exist_ok=True)

    model_url = (
        "https://github.com/LAION-AI/aesthetic-predictor/"
        "blob/main/sa_0_4_vit_l_14_linear.pth?raw=true"
    )
    model_path = os.path.join(cache_dir, "sa_0_4_vit_l_14_linear.pth")

    if not os.path.exists(model_path):
        print("モデルをダウンロード中...")
        urlretrieve(model_url, model_path)

    # 線形1層モデル (CLIP ViT-L/14 embedding dim = 768)
    aesthetic_model = nn.Linear(768, 1)
    state = torch.load(model_path, map_location="cpu")
    aesthetic_model.load_state_dict(state)
    aesthetic_model.eval()
    return aesthetic_model

# ===== CLIPとAesthetic Predictorのセットアップ =====
device = "cuda" if torch.cuda.is_available() else "cpu"

clip_model, _, preprocess = open_clip.create_model_and_transforms(
    "ViT-L-14", pretrained="openai"
)
clip_model = clip_model.to(device).eval()
aesthetic_model = load_aesthetic_model().to(device)

# ===== 単画像スコアリング =====
def score_image(image_path: str) -> float:
    with torch.no_grad():
        img = Image.open(image_path).convert("RGB")
        img_tensor = preprocess(img).unsqueeze(0).to(device)
        embedding = clip_model.encode_image(img_tensor)
        embedding = embedding / embedding.norm(dim=-1, keepdim=True)
        score = aesthetic_model(embedding.float())
    return score.item()

# 使用例
score = score_image("generated_001.png")
print(f"Aesthetic Score: {score:.2f}")
# → Aesthetic Score: 7.23

1-3. バッチ処理最適化版

from pathlib import Path
from torch.utils.data import DataLoader, Dataset
import json

class ImageDataset(Dataset):
    def __init__(self, image_paths, transform):
        self.paths = image_paths
        self.transform = transform

    def __len__(self): return len(self.paths)

    def __getitem__(self, idx):
        try:
            img = Image.open(self.paths[idx]).convert("RGB")
            return self.transform(img), str(self.paths[idx])
        except:
            return torch.zeros(3, 224, 224), str(self.paths[idx])

def batch_score_folder(
    folder: str,
    threshold: float = 6.5,
    batch_size: int = 32,
    output_json: str = "scores.json"
):
    """フォルダ内の全画像をバッチスコアリング → 合格リスト返却"""
    paths = list(Path(folder).glob("*.png")) + list(Path(folder).glob("*.jpg"))
    dataset = ImageDataset(paths, preprocess)
    loader = DataLoader(dataset, batch_size=batch_size, num_workers=4, pin_memory=True)

    results = []
    passed = []

    with torch.no_grad():
        for imgs, img_paths in loader:
            imgs = imgs.to(device)
            embeddings = clip_model.encode_image(imgs)
            embeddings = embeddings / embeddings.norm(dim=-1, keepdim=True)
            scores = aesthetic_model(embeddings.float()).squeeze(-1)

            for path, score in zip(img_paths, scores.cpu().tolist()):
                entry = {"path": path, "score": round(score, 3)}
                results.append(entry)
                if score >= threshold:
                    passed.append(entry)

    # スコアをJSONに保存
    with open(output_json, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)

    print(f"総数: {len(results)} | 合格: {len(passed)} | 合格率: {len(passed)/len(results)*100:.1f}%")
    return passed

# 実行例
passed_images = batch_score_folder(
    folder="D:/generated_images/batch_001",
    threshold=6.5,
    batch_size=32
)

2-1. 検出レイヤーの設計

解剖学的品質チェックは「複数の検出器を層状に重ねる」設計が最も堅牢。単一モデルへの依存を避けること。

2-2. 指崩れ検出の実装 (MediaPipe)

import mediapipe as mp
from mediapipe.tasks import python as mp_python
from mediapipe.tasks.python import vision
import numpy as np
import cv2

# MediaPipe Hand Landmarkerの初期化
BaseOptions = mp_python.BaseOptions
HandLandmarker = vision.HandLandmarker
HandLandmarkerOptions = vision.HandLandmarkerOptions

options = HandLandmarkerOptions(
    base_options=BaseOptions(model_asset_path="hand_landmarker.task"),
    num_hands=4,  # 最大4手まで検出
    min_hand_detection_confidence=0.5,
    min_tracking_confidence=0.5
)
hand_detector = HandLandmarker.create_from_options(options)

def check_hand_quality(image_path: str) -> dict:
    """
    指の解剖学的整合性チェック
    Returns: {ok: bool, reason: str, hands_found: int}
    """
    img = mp.Image.create_from_file(image_path)
    result = hand_detector.detect(img)

    if not result.hand_landmarks:
        return {"ok": True, "reason": "no_hands", "hands_found": 0}

    issues = []
    for hand_idx, landmarks in enumerate(result.hand_landmarks):
        # === 指の本数チェック ===
        # 各指先のランドマークID: 4(親), 8(人), 12(中), 16(薬), 20(小)
        fingertip_ids = [4, 8, 12, 16, 20]
        fingertips = [landmarks[i] for i in fingertip_ids]

        # 指先間の最小距離をチェック (異常に近い = 融合/崩れ)
        coords = np.array([[f.x, f.y] for f in fingertips])
        for i in range(len(coords)):
            for j in range(i+1, len(coords)):
                dist = np.linalg.norm(coords[i] - coords[j])
                if dist < 0.02:  # 正規化座標で2%未満 = 指融合の疑い
                    issues.append(f"hand{hand_idx}: fingertip_fusion dist={dist:.3f}")

        # === 指の長さ比率チェック ===
        # 正常な手は MCP→PIP→DIP→TIP で段々短くなる
        for finger_base in [5, 9, 13, 17]:  # 各指のMCP
            mcp = np.array([landmarks[finger_base].x, landmarks[finger_base].y])
            pip_ = np.array([landmarks[finger_base+1].x, landmarks[finger_base+1].y])
            dip = np.array([landmarks[finger_base+2].x, landmarks[finger_base+2].y])
            tip = np.array([landmarks[finger_base+3].x, landmarks[finger_base+3].y])

            seg1 = np.linalg.norm(pip_ - mcp)
            seg2 = np.linalg.norm(dip - pip_)
            seg3 = np.linalg.norm(tip - dip)

            if seg2 > seg1 * 1.5 or seg3 > seg1 * 1.5:
                issues.append(f"hand{hand_idx}: abnormal_segment_ratio")

    ok = len(issues) == 0
    return {
        "ok": ok,
        "reason": ", ".join(issues) if issues else "pass",
        "hands_found": len(result.hand_landmarks)
    }

2-3. 顔品質チェックの実装

# MediaPipe Face Landmarker (468点)
FaceLandmarker = vision.FaceLandmarker
FaceLandmarkerOptions = vision.FaceLandmarkerOptions

face_options = FaceLandmarkerOptions(
    base_options=BaseOptions(model_asset_path="face_landmarker.task"),
    output_face_blendshapes=True,
    num_faces=3
)
face_detector = FaceLandmarker.create_from_options(face_options)

def check_face_quality(image_path: str) -> dict:
    """顔の解剖学的整合性チェック"""
    img = mp.Image.create_from_file(image_path)
    result = face_detector.detect(img)

    if not result.face_landmarks:
        return {"ok": True, "reason": "no_face", "faces_found": 0}

    issues = []
    for face_idx, landmarks in enumerate(result.face_landmarks):
        lm = landmarks

        # 左右目の対称性チェック (正常ならほぼ同じy座標)
        left_eye_y = lm[33].y   # 左目外角
        right_eye_y = lm[263].y  # 右目外角
        eye_y_diff = abs(left_eye_y - right_eye_y)
        if eye_y_diff > 0.08:
            issues.append(f"face{face_idx}: eye_asymmetry={eye_y_diff:.3f}")

        # 口の幅チェック (口が異常に広い/狭いケース)
        mouth_left = lm[61].x
        mouth_right = lm[291].x
        mouth_width = abs(mouth_right - mouth_left)
        face_width = abs(lm[234].x - lm[454].x)  # 顔全幅
        mouth_ratio = mouth_width / (face_width + 1e-6)
        if mouth_ratio > 0.9 or mouth_ratio < 0.15:
            issues.append(f"face{face_idx}: abnormal_mouth_ratio={mouth_ratio:.3f}")

        # 鼻の位置チェック (顔中心からのずれ)
        nose_tip_x = lm[1].x
        face_center_x = (lm[234].x + lm[454].x) / 2
        nose_offset = abs(nose_tip_x - face_center_x) / (face_width + 1e-6)
        if nose_offset > 0.15:
            issues.append(f"face{face_idx}: nose_misaligned={nose_offset:.3f}")

    return {
        "ok": len(issues) == 0,
        "reason": ", ".join(issues) if issues else "pass",
        "faces_found": len(result.face_landmarks)
    }

2-4. HuggingFace Bad Anatomy Classifierの活用

from transformers import pipeline as hf_pipeline

# 4クラス分類: Unrealistic Bad Anatomy / Unrealistic Good Anatomy
#              / Realistic Good Anatomy / Realistic Bad Anatomy
anatomy_classifier = hf_pipeline(
    "image-classification",
    model="angusleung100/bad-anatomy-realism-classifier",
    device=0 if torch.cuda.is_available() else -1
)

def check_anatomy(image_path: str) -> dict:
    results = anatomy_classifier(image_path)
    top = results[0]
    # "Unrealistic Bad Anatomy" が最高スコアならリジェクト
    is_bad = (top["label"] == "Unrealistic Bad Anatomy" and top["score"] > 0.6)
    return {"ok": not is_bad, "label": top["label"], "confidence": top["score"]}

3-1. 推奨カスタムノードセット

3-2. ワークフロー構造設計

↓ 各STEP でリジェクト → 破棄フォルダへ

3-3. ComfyUI APIを使った外部品質フィルターの接続

# ComfyUI APIに品質チェック済み画像のみ保存させる統合スクリプト
import requests, json, time, shutil
from pathlib import Path
import websocket

COMFYUI_URL = "http://127.0.0.1:8188"
OUTPUT_DIR = Path("D:/generated_output/approved")
REJECT_DIR = Path("D:/generated_output/rejected")
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
REJECT_DIR.mkdir(parents=True, exist_ok=True)

def queue_workflow(workflow: dict) -> str:
    res = requests.post(f"{COMFYUI_URL}/prompt", json={"prompt": workflow})
    return res.json()["prompt_id"]

def wait_for_completion(prompt_id: str, timeout: int = 300) -> list:
    """WebSocketで完了を待ち、出力画像パスを返す"""
    ws = websocket.WebSocket()
    ws.connect(f"ws://127.0.0.1:8188/ws?clientId=quality_filter")
    deadline = time.time() + timeout

    while time.time() < deadline:
        msg = json.loads(ws.recv())
        if msg["type"] == "executed" and msg["data"].get("prompt_id") == prompt_id:
            output_images = []
            history = requests.get(f"{COMFYUI_URL}/history/{prompt_id}").json()
            for node_output in history[prompt_id]["outputs"].values():
                if "images" in node_output:
                    for img_info in node_output["images"]:
                        output_images.append(img_info["filename"])
            ws.close()
            return output_images
    ws.close()
    return []

def process_with_quality_gate(workflow: dict, batch_count: int = 10):
    """生成→採点→振り分けの完全パイプライン"""
    approved = rejected = 0
    for i in range(batch_count):
        # シードをランダムに変更
        workflow["3"]["inputs"]["seed"] = int(time.time() * 1000) % 2**32

        prompt_id = queue_workflow(workflow)
        img_files = wait_for_completion(prompt_id)

        for fname in img_files:
            src = Path(f"D:/ComfyUI_portable/ComfyUI/output/{fname}")
            if not src.exists():
                continue

            # Aestheticスコア判定
            aes_score = score_image(str(src))
            hand_ok = check_hand_quality(str(src))["ok"]
            face_ok = check_face_quality(str(src))["ok"]

            if aes_score >= 6.5 and hand_ok and face_ok:
                shutil.copy(src, OUTPUT_DIR / fname)
                approved += 1
            else:
                shutil.copy(src, REJECT_DIR / f"rej_aes{aes_score:.1f}_{fname}")
                rejected += 1

        print(f"[{i+1}/{batch_count}] 承認:{approved} 却下:{rejected}")

    return approved, rejected

3-4. ComfyUI ネイティブ品質フィルターワークフロー (JSON概要)

以下のノード接続順で ComfyUI 内に完結するワークフローを構築できる：

• CheckpointLoaderSimple → CLIPTextEncode (Pos/Neg) → KSampler
• KSampler → VAEDecode → LoadAestheticModel + CalculateAestheticScore
• CalculateAestheticScore → ScoreToNumber → ImageFilterByFloatScoreNode (threshold: 6.5)
• フィルター通過 → SaveImage (approved/ フォルダ)
• フィルター不通過 → ワークフロー終了 or PreviewImage (rejected/)

4-1. フルパイプラインアーキテクチャ

4-2. 本番運用フルパイプラインコード

import torch, shutil, json, time, csv
from pathlib import Path
from datetime import datetime
from dataclasses import dataclass, asdict
from typing import Optional
import pybrisque  # pip install pybrisque

@dataclass
class ImageResult:
    path: str
    aesthetic_score: float
    hand_ok: bool
    face_ok: bool
    brisque_score: float  # 低いほど良い (0-100)
    passed: bool
    reject_reason: Optional[str]
    timestamp: str

class QualityPipeline:
    """大量生成 + 自動品質管理パイプライン"""

    def __init__(self,
        out_dir: str = "D:/output/approved",
        reject_dir: str = "D:/output/rejected",
        aesthetic_threshold: float = 6.5,
        brisque_threshold: float = 40.0,  # 40超 = ブラー/ノイズあり
        log_csv: str = "quality_log.csv"
    ):
        self.out_dir = Path(out_dir)
        self.reject_dir = Path(reject_dir)
        self.aes_thresh = aesthetic_threshold
        self.brisque_thresh = brisque_threshold
        self.log_csv = log_csv

        for d in [self.out_dir, self.reject_dir]:
            d.mkdir(parents=True, exist_ok=True)

        # ログCSV初期化
        if not Path(log_csv).exists():
            with open(log_csv, "w", newline="") as f:
                writer = csv.DictWriter(f, fieldnames=list(ImageResult.__dataclass_fields__.keys()))
                writer.writeheader()

    def evaluate(self, image_path: str) -> ImageResult:
        """単画像の全品質チェック実行"""
        ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        # Aesthetic Score
        aes = score_image(image_path)

        # 解剖学チェック (Aestheticが低ければスキップして高速化)
        if aes < self.aes_thresh:
            return ImageResult(
                path=image_path, aesthetic_score=aes,
                hand_ok=False, face_ok=False, brisque_score=-1,
                passed=False, reject_reason=f"aesthetic_too_low:{aes:.2f}",
                timestamp=ts
            )

        hand_result = check_hand_quality(image_path)
        face_result = check_face_quality(image_path)

        # BRISQUE (ブラー・ノイズ検出)
        try:
            brisque_score = pybrisque.score(image_path)
        except:
            brisque_score = 0.0  # エラー時はパス

        # 総合判定
        reasons = []
        if not hand_result["ok"]:
            reasons.append(f"hand_issue:{hand_result['reason']}")
        if not face_result["ok"]:
            reasons.append(f"face_issue:{face_result['reason']}")
        if brisque_score > self.brisque_thresh:
            reasons.append(f"blur_noise:{brisque_score:.1f}")

        passed = len(reasons) == 0
        return ImageResult(
            path=image_path, aesthetic_score=aes,
            hand_ok=hand_result["ok"], face_ok=face_result["ok"],
            brisque_score=brisque_score, passed=passed,
            reject_reason="; ".join(reasons) if reasons else None,
            timestamp=ts
        )

    def process_folder(self, src_folder: str):
        """フォルダ内全画像を処理して振り分け"""
        images = list(Path(src_folder).glob("*.png")) + list(Path(src_folder).glob("*.jpg"))
        approved = rejected = 0
        stats = {"aesthetic_too_low": 0, "anatomy": 0, "blur": 0}

        with open(self.log_csv, "a", newline="") as logfile:
            writer = csv.DictWriter(logfile, fieldnames=list(ImageResult.__dataclass_fields__.keys()))

            for img_path in images:
                result = self.evaluate(str(img_path))
                writer.writerow(asdict(result))

                if result.passed:
                    shutil.copy(img_path, self.out_dir / img_path.name)
                    approved += 1
                else:
                    reason_tag = result.reject_reason.split(":")[0] if result.reject_reason else "unknown"
                    reject_name = f"[{reason_tag}]_{img_path.name}"
                    shutil.copy(img_path, self.reject_dir / reject_name)
                    rejected += 1

                    # 失敗原因を集計
                    if "aesthetic" in (result.reject_reason or ""):
                        stats["aesthetic_too_low"] += 1
                    elif "hand" in (result.reject_reason or "") or "face" in (result.reject_reason or ""):
                        stats["anatomy"] += 1
                    else:
                        stats["blur"] += 1

        total = approved + rejected
        print(f"\n=== Quality Pipeline 完了 ===")
        print(f"総数: {total} | 承認: {approved} ({approved/total*100:.1f}%) | 却下: {rejected}")
        print(f"却下内訳: 低スコア={stats['aesthetic_too_low']} 解剖={stats['anatomy']} ブラー={stats['blur']}")
        return approved, rejected, stats

# 実行
pipeline = QualityPipeline(
    out_dir="D:/output/approved",
    reject_dir="D:/output/rejected",
    aesthetic_threshold=6.5,
    brisque_threshold=40.0
)
pipeline.process_folder("D:/output/raw_generated")

4-3. メタデータ付き保存 (品質スコアをファイル名に埋め込む)

import struct
from PIL import Image as PILImage
from PIL.PngImagePlugin import PngInfo

def save_with_metadata(src_path: str, dst_dir: str, result: ImageResult):
    """Aesthetic Scoreをファイル名とPNGメタデータに埋め込んで保存"""
    score_str = f"{result.aesthetic_score:.2f}".replace(".", "p")
    ts_str = datetime.now().strftime("%Y%m%d_%H%M%S")
    dst_name = f"aes{score_str}_{ts_str}.png"

    img = PILImage.open(src_path)
    meta = PngInfo()
    meta.add_text("aesthetic_score", str(result.aesthetic_score))
    meta.add_text("hand_ok", str(result.hand_ok))
    meta.add_text("face_ok", str(result.face_ok))
    meta.add_text("brisque_score", str(result.brisque_score))
    meta.add_text("generated_at", result.timestamp)
    img.save(Path(dst_dir) / dst_name, pnginfo=meta)
    return dst_name

5-1. 工数削減のロジック設計

5-2. 閾値チューニング戦略 (90%削減の実現方法)

5-3. 自動改善ループ (リジェクト原因フィードバック)

def analyze_rejection_patterns(log_csv: str):
    """品質ログを分析してプロンプト改善示唆を出す"""
    import pandas as pd

    df = pd.read_csv(log_csv)
    total = len(df)
    passed = df[df["passed"] == True]

    print(f"\n=== リジェクト原因分析 ===")
    print(f"合格率: {len(passed)/total*100:.1f}%")
    print(f"平均 Aesthetic Score: {df['aesthetic_score'].mean():.2f}")
    print(f"Aesthetic Score 分布:")
    print(df["aesthetic_score"].describe())

    # 失敗原因の集計
    rejected = df[df["passed"] == False]
    if not rejected.empty:
        reasons = rejected["reject_reason"].value_counts().head(10)
        print(f"\nTop10リジェクト理由:\n{reasons}")

        # 改善提案
        hand_fail_rate = rejected["reject_reason"].str.contains("hand", na=False).sum() / total
        if hand_fail_rate > 0.3:
            print("\n[改善提案] 手の破綻が多い → ネガティブプロンプトに追加:")
            print("  'bad hands, extra fingers, mutated hands, poorly drawn hands'")

        face_fail_rate = rejected["reject_reason"].str.contains("face", na=False).sum() / total
        if face_fail_rate > 0.2:
            print("\n[改善提案] 顔崩れが多い → FaceDetailerの導入または:")
            print("  CFGスケールを下げる / ステップ数を増やす")

5-4. 夜間自動生成＋採点バッチの設定

# Windowsタスクスケジューラ or cronで夜間自動実行
# save as: D:/scripts/nightly_batch.py

if __name__ == "__main__":
    from datetime import datetime
    print(f"[{datetime.now():%Y-%m-%d %H:%M}] 夜間バッチ開始")

    # ComfyUI APIでバッチ生成 (例: 200枚)
    workflow = json.load(open("D:/workflows/main_workflow.json"))
    approved, rejected = process_with_quality_gate(workflow, batch_count=200)

    # Discord通知 (任意)
    import requests
    msg = f"夜間バッチ完了: 承認={approved} 却下={rejected} 合格率={approved/(approved+rejected)*100:.1f}%"
    # requests.post(DISCORD_WEBHOOK_URL, json={"content": msg})
    print(msg)

6-1. 各処理ステップの速度実測値

6-2. パイプライン全体のスループット試算

6-3. 実用シナリオ別の時間試算

6-4. VRAM最適化テクニック

# ComfyUI + 品質チェックのVRAM共存戦略

# === 方法1: 生成後にCLIPモデルを空きVRAMで動かす ===
# ComfyUIの /free エンドポイントでモデルをアンロード後に採点
def free_comfyui_vram():
    requests.post(f"{COMFYUI_URL}/free", json={"unload_models": True})
    time.sleep(2)

# === 方法2: CLIP FP16で動かしてVRAM削減 ===
clip_model, _, preprocess = open_clip.create_model_and_transforms(
    "ViT-L-14", pretrained="openai",
    precision="fp16"  # VRAM半減: 1.7GB → ~0.85GB
)

# === 方法3: バッチサイズを動的調整 ===
def get_optimal_batch_size() -> int:
    if not torch.cuda.is_available():
        return 4
    free_vram = torch.cuda.get_device_properties(0).total_memory - torch.cuda.memory_allocated()
    free_gb = free_vram / 1e9
    if free_gb > 10: return 64
    elif free_gb > 5: return 32
    elif free_gb > 2: return 16
    else: return 4

# === 方法4: 50〜100枚ごとにVRAMクリア ===
for i, batch in enumerate(batches):
    process_batch(batch)
    if i % 3 == 0:  # 3バッチ = 96〜192枚ごと
        torch.cuda.empty_cache()

6-5. BRISQUEをGPUで高速化 (IQA-PyTorch)

# pip install pyiqa  ← IQA-PyTorch (GPU対応の最新版)
import pyiqa

# GPU対応の高品質NR-IQAメトリクス (BRISQUEより精度高い)
niqe_metric = pyiqa.create_metric("niqe", device=device)   # GPU対応
musiq_metric = pyiqa.create_metric("musiq", device=device)  # MUSIQはより高精度
nima_metric = pyiqa.create_metric("nima", device=device)    # Flickr学習済み

def check_technical_quality_gpu(image_path: str) -> dict:
    """GPU上でIQA-PyTorchを使った高速品質評価"""
    from torchvision import transforms
    img = PILImage.open(image_path).convert("RGB")
    tensor = transforms.ToTensor()(img).unsqueeze(0).to(device)

    with torch.no_grad():
        niqe_score = niqe_metric(tensor).item()   # 低いほど良い
        musiq_score = musiq_metric(tensor).item()  # 高いほど良い (0-100)

    return {
        "niqe": niqe_score,
        "musiq": musiq_score,
        "ok": niqe_score < 5.0 and musiq_score > 40
    }

推奨ライブラリ一覧

• LAION-AI/aesthetic-predictor — GitHub
• christophschuhmann/improved-aesthetic-predictor — CLIP+MLP Aesthetic Score Predictor
• angusleung100/bad-anatomy-realism-classifier — HuggingFace
• OpenCLIP Throughput Benchmarks — RTX3090実測値 (GitHub Gist)
• IQA-PyTorch — GPU対応品質評価ツールボックス (NIQE/MUSIQ/NIMA等)
• MediaPipe Hand Landmarker Python Guide — Google AI Edge
• MediaPipe Face Landmarker Guide — Google AI Edge
• ComfyUI-Impact-Pack — FaceDetailer/Detector
• ComfyUI-Strimmlarns-Aesthetic-Score — ComfyUIネイティブAesthetic採点ノード
• ComfyUI Batch Processing 1000+ Images Automation 2026 — Apatero Blog
• NVIDIA NeMo Curator Aesthetic Classifier — 公式ドキュメント
• Automatically Selecting the Best Images Generated by Stable Diffusion — Medium