Gemini にスクリーンショットを採点させたら、全部78〜85点だった — 絶対スコアを捨ててペア比較に切り替えるまで

from PIL import Image, ImageEnhance
 
 
def make_degraded_variants(src_path: str, out_dir: str) -> dict[str, str]:
    """検証用に、意図的に品質を落とした画像を生成する。
 
    採点器が「悪くしたこと」を検出できるかを測るための対照群。
    """
    out = Path(out_dir)
    out.mkdir(parents=True, exist_ok=True)
    img = Image.open(src_path).convert("RGB")
    stem = Path(src_path).stem
    variants = {}
 
    # (1) コントラストを 30% まで落とす — 視認性の劣化
    low_contrast = ImageEnhance.Contrast(img).enhance(0.3)
    p = out / f"{stem}_lowcontrast.png"
    low_contrast.save(p)
    variants["low_contrast"] = str(p)
 
    # (2) 上半分を単色で塗り潰す — キャッチコピー領域の消去
    no_text = img.copy()
    w, h = no_text.size
    no_text.paste((242, 242, 242), (0, 0, w, h // 3))
    p = out / f"{stem}_notext.png"
    no_text.save(p)
    variants["no_text"] = str(p)
 
    # (3) 極端に縮小してから戻す — 解像度の劣化
    blurred = img.resize((w // 8, h // 8)).resize((w, h))
    p = out / f"{stem}_lowres.png"
    blurred.save(p)
    variants["low_res"] = str(p)
 
    return variants

def discrimination_margin(
    original: list[str],
    degraded: list[str],
    app_name: str,
    noise_stdev: float,
    n: int = 5,
) -> dict:
    """弁別マージン = (原本スコア - 劣化スコア) / ノイズ標準偏差。
 
    1.0 を下回るなら、スコア差はノイズに埋もれていて意味を持たない。
    """
    orig_scores = [score_absolute(original, app_name)["overall_score"] for _ in range(n)]
    deg_scores = [score_absolute(degraded, app_name)["overall_score"] for _ in range(n)]
 
    gap = statistics.mean(orig_scores) - statistics.mean(deg_scores)
    return {
        "original_mean": statistics.mean(orig_scores),
        "degraded_mean": statistics.mean(deg_scores),
        "gap": gap,
        "margin": gap / noise_stdev if noise_stdev > 0 else float("inf"),
        "usable": (gap / noise_stdev) >= 2.0 if noise_stdev > 0 else True,
    }

def pairwise_compare(
    a_paths: list[str],
    b_paths: list[str],
    app_name: str,
    market: str = "日本",
) -> dict:
    """2つのスクリーンショット案を比較し、勝者を返す。"""
    parts = [
        types.Part.from_text(
            f"""App Store のスクリーンショット案を2つ比較します。
 
アプリ名: {app_name}
対象市場: {market}
 
判断基準は「ストアを流し見しているユーザーが、最初の1秒でこのアプリを
使いたいと思う確率が高いのはどちらか」の一点のみです。
デザインの巧拙ではなく、ダウンロードにつながるかで判断してください。
 
次の JSON 形式で返してください:
{{
  "winner": "A" | "B" | "tie",
  "confidence": "high" | "medium" | "low",
  "reason": "決め手となった具体的な違い（1〜2文）"
}}"""
        )
    ]
 
    parts.append(types.Part.from_text("=== 案 A ==="))
    for p in a_paths:
        parts.append(load_image(p))
 
    parts.append(types.Part.from_text("=== 案 B ==="))
    for p in b_paths:
        parts.append(load_image(p))
 
    resp = client.models.generate_content(
        model=JUDGE_MODEL,
        contents=parts,
        config=types.GenerateContentConfig(
            response_mime_type="application/json",
            temperature=0.3,
        ),
    )
    return json.loads(resp.text)

def compare_debiased(a_paths, b_paths, app_name) -> str:
    """順序を入れ替えて2回比較し、位置バイアスを打ち消す。
 
    戻り値: "A" / "B" / "tie"
    2回の結果が一致しない場合は引き分け扱いにする。
    """
    first = pairwise_compare(a_paths, b_paths, app_name)["winner"]
 
    # A と B を入れ替えて再度比較（返り値も読み替える）
    swapped = pairwise_compare(b_paths, a_paths, app_name)["winner"]
    second = {"A": "B", "B": "A", "tie": "tie"}[swapped]
 
    if first == second:
        return first
    return "tie"

def rank_candidates(candidates: dict[str, list[str]], app_name: str) -> list[dict]:
    """候補案を総当たりで比較し、勝率順に並べる。
 
    candidates: {"案の名前": [スクリーンショットのパス, ...]}
    """
    names = list(candidates.keys())
    wins = {n: 0.0 for n in names}
    matches = {n: 0 for n in names}
    log = []
 
    for a, b in combinations(names, 2):
        winner = compare_debiased(candidates[a], candidates[b], app_name)
        matches[a] += 1
        matches[b] += 1
 
        if winner == "A":
            wins[a] += 1.0
        elif winner == "B":
            wins[b] += 1.0
        else:  # tie
            wins[a] += 0.5
            wins[b] += 0.5
 
        log.append({"a": a, "b": b, "winner": winner})
        print(f"  {a} vs {b} → {winner}")
 
    ranked = [
        {
            "name": n,
            "win_rate": round(wins[n] / matches[n], 3) if matches[n] else 0.0,
            "wins": wins[n],
            "matches": matches[n],
        }
        for n in names
    ]
    ranked.sort(key=lambda x: x["win_rate"], reverse=True)
    return ranked