Upload folder using huggingface_hub

top5000_clipframe_dino_clipt_dedup/README_gemini_label.md

@@ -1,6 +1,14 @@
 # Gemini Pro Aesthetic Labeling
 
 This directory contains the deduplicated Top5000 high/low video package.
+It is standalone: the runner uses scripts inside this directory, not
+`reference/benchmarks/critic/aesthetic_rm/label_aesthetic_api.py`.
+
+Required Python packages:
+
+```bash
+pip install openai imageio imageio-ffmpeg pillow
+```
 
 Generate API input and run a 10-item smoke test:
 

top5000_clipframe_dino_clipt_dedup/label_aesthetic_standalone.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+DIMENSIONS = [
+    "narrative_emotional_fit",
+    "style_world_consistency",
+    "composition_lighting_design",
+    "color_texture_refinement",
+    "visual_hierarchy_readability",
+]
+
+SYSTEM_PROMPT = """You are a strict cinematic/VFX aesthetic rater.
+You are doing pointwise standalone aesthetic scoring: you see sampled frames
+from the edited video, but you do not see the source video. Use the editing
+instruction only as weak context for the intended visual direction. Do not judge
+whether the edit accurately followed the instruction, because the source video is
+not provided.
+
+Scoring scale for every dimension:
+4 = excellent / strongly successful
+3 = good with minor issues
+2 = weak with clear issues
+1 = failed or harms the aesthetic goal
+
+Rules:
+- Score each dimension independently.
+- There is no neutral middle score. Choose 2 or 3 when uncertain between weak and good.
+- If a video matches multiple descriptions, assign the lowest applicable score.
+- For object removal, cleanup, denoising, de-watermarking, or other utility edits,
+  a seamless and visually natural result can be aesthetically successful even if
+  it is not dramatic or cinematic.
+- Do not penalize a candidate because the requested edit removes an interesting
+  object or makes the scene simpler.
+- Do not give high artistic scores just because the image is sharp or expensive-looking.
+- Do not give high color scores just because colors are saturated.
+- Penalize visible inpainting seams, visual clutter, incoherent style mixing,
+  cheap texture/filter look, and unclear focal hierarchy when they are visible in
+  the edited frames.
+- Return valid JSON only, with no markdown.
+"""
+
+USER_TEMPLATE = """Editing instruction / intended effect:
+{instruction}
+
+Inferred task type:
+{task_type}
+
+Important: you do not see the source video. Do not evaluate whether the edit was
+completed relative to the source. Evaluate the final edited video as a standalone
+visual result. For removal or cleanup tasks, invisible/seamless blending is a
+positive aesthetic outcome.
+
+Evaluate the edited video frames on these five dimensions:
+1. narrative_emotional_fit: whether the final edited result naturally integrates with the scene mood, emotional tone, and visual context without artificial or distracting anomalies.
+2. style_world_consistency: whether the final visual style fits the world, era, genre, and style language such as classical, wuxia, sci-fi, realistic, fantasy, or cinematic.
+3. composition_lighting_design: composition, contrast, lighting hierarchy, lens/cinematic design, and shot-level visual arrangement.
+4. color_texture_refinement: color harmony, saturation control, material/texture/filter refinement, and whether it avoids cheap or generic looks.
+5. visual_hierarchy_readability: whether the main visual intent is clear, focal hierarchy is readable, and important content is not obscured.
+
+"overall_aesthetic_score" should be a holistic assessment of final visual
+quality from 1.0 to 4.0, not a simple mathematical average of the five
+dimensions.
+
+Return this exact JSON schema:
+{{
+  "scores": {{
+    "narrative_emotional_fit": 1,
+    "style_world_consistency": 1,
+    "composition_lighting_design": 1,
+    "color_texture_refinement": 1,
+    "visual_hierarchy_readability": 1
+  }},
+  "overall_aesthetic_score": 1.0,
+  "uncertain": false,
+  "reason": "one concise sentence"
+}}
+"""
+
+
+def infer_task_type(instruction: str) -> str:
+    text = instruction.lower()
+    if any(word in text for word in ["remove", "erase", "delete", "hide", "clean up", "de-watermark", "watermark", "logo"]):
+        return "removal_or_cleanup"
+    if any(word in text for word in ["add", "insert", "place", "put ", "introduce", "include"]):
+        return "addition_or_insertion"
+    if any(word in text for word in ["replace", "swap", "change into", "turn into", "transform", "convert"]):
+        return "replacement_or_transformation"
+    if any(word in text for word in ["style", "aesthetic", "cinematic", "film", "color", "lighting", "tone", "grain", "texture"]):
+        return "style_or_look_change"
+    if any(word in text for word in ["enhance", "restore", "sharpen", "denoise", "improve", "refine"]):
+        return "quality_refinement"
+    return "general_edit"
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            text = line.strip()
+            if text:
+                rows.append(json.loads(text))
+    return rows
+
+
+def append_jsonl(path: Path, row: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def load_done_ids(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    done: set[str] = set()
+    for row in read_jsonl(path):
+        if row.get("candidate_id") and not row.get("api_error"):
+            done.add(str(row["candidate_id"]))
+    return done
+
+
+def sample_video_frames(video_path: Path, max_frames: int, resize: int) -> list[bytes]:
+    try:
+        import imageio.v3 as iio
+        from PIL import Image
+    except Exception as exc:
+        raise RuntimeError("Please install imageio, imageio-ffmpeg, and pillow") from exc
+
+    frames = [Image.fromarray(frame).convert("RGB") for frame in iio.imiter(str(video_path))]
+    if not frames:
+        raise RuntimeError(f"no frames decoded from {video_path}")
+    if max_frames < len(frames):
+        if max_frames > 1:
+            indices = [round(i * (len(frames) - 1) / (max_frames - 1)) for i in range(max_frames)]
+        else:
+            indices = [len(frames) // 2]
+        frames = [frames[i] for i in indices]
+
+    output: list[bytes] = []
+    for frame in frames:
+        if resize:
+            frame.thumbnail((resize, resize))
+        import io
+
+        buf = io.BytesIO()
+        frame.save(buf, format="JPEG", quality=85)
+        output.append(buf.getvalue())
+    return output
+
+
+def build_messages(instruction: str, frames: list[bytes]) -> list[dict[str, Any]]:
+    content: list[dict[str, Any]] = [
+        {"type": "text", "text": USER_TEMPLATE.format(instruction=instruction, task_type=infer_task_type(instruction))}
+    ]
+    for frame in frames:
+        encoded = base64.b64encode(frame).decode("ascii")
+        content.append({"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{encoded}"}})
+    return [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": content}]
+
+
+def parse_json_response(text: str) -> dict[str, Any]:
+    text = text.strip()
+    if text.startswith("```"):
+        text = text.strip("`")
+        if text.startswith("json"):
+            text = text[4:].strip()
+    if not text.startswith("{"):
+        start = text.find("{")
+        end = text.rfind("}")
+        if start >= 0 and end > start:
+            text = text[start : end + 1]
+    data = json.loads(text)
+    scores = data.get("scores", {})
+    for dim in DIMENSIONS:
+        value = int(scores[dim])
+        if value < 1 or value > 4:
+            raise ValueError(f"{dim} score out of range: {value}")
+        scores[dim] = value
+    data["scores"] = scores
+    data["overall_aesthetic_score"] = float(data.get("overall_aesthetic_score", sum(scores.values()) / len(scores)))
+    data["uncertain"] = bool(data.get("uncertain", False))
+    data["reason"] = str(data.get("reason", ""))[:500]
+    return data
+
+
+def estimate_cost(usage: Any, input_per_1m: float, output_per_1m: float) -> dict[str, Any]:
+    prompt_tokens = int(getattr(usage, "prompt_tokens", 0) or 0) if usage else 0
+    completion_tokens = int(getattr(usage, "completion_tokens", 0) or 0) if usage else 0
+    total_tokens = int(getattr(usage, "total_tokens", 0) or prompt_tokens + completion_tokens) if usage else 0
+    cost = prompt_tokens / 1_000_000 * input_per_1m + completion_tokens / 1_000_000 * output_per_1m
+    return {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": total_tokens,
+        "estimated_cost_usd": round(cost, 6),
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Standalone Gemini/OpenAI-compatible aesthetic scorer.")
+    parser.add_argument("--input", type=Path, default=Path("aesthetic_api_input.jsonl"))
+    parser.add_argument("--output", type=Path, default=Path("aesthetic_scores_gemini_pro.jsonl"))
+    parser.add_argument("--base-url", default="http://35.220.164.252:3888/v1")
+    parser.add_argument("--api-key-env", default="AESTHETIC_RM_API_KEY")
+    parser.add_argument("--model", default="gemini-3.1-pro-preview-thinking")
+    parser.add_argument("--request-timeout", type=float, default=180.0)
+    parser.add_argument("--max-retries", type=int, default=3)
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--max-frames", type=int, default=4)
+    parser.add_argument("--resize", type=int, default=512)
+    parser.add_argument("--input-cost-per-1m", type=float, default=3.0)
+    parser.add_argument("--output-cost-per-1m", type=float, default=15.0)
+    args = parser.parse_args()
+
+    api_key = os.environ.get(args.api_key_env)
+    if not api_key:
+        raise RuntimeError(f"Set {args.api_key_env} before calling the API")
+
+    from openai import OpenAI
+
+    client = OpenAI(api_key=api_key, base_url=args.base_url, timeout=args.request_timeout, max_retries=args.max_retries)
+
+    rows = read_jsonl(args.input)
+    if args.limit:
+        rows = rows[: args.limit]
+    done = load_done_ids(args.output)
+    pending = [row for row in rows if str(row.get("candidate_id", "")) not in done]
+
+    processed = 0
+    total_prompt_tokens = 0
+    total_completion_tokens = 0
+    total_tokens = 0
+    total_cost = 0.0
+
+    for row in pending:
+        try:
+            frames = sample_video_frames(Path(str(row["edited_video"])), args.max_frames, args.resize)
+            response = client.chat.completions.create(
+                model=args.model,
+                messages=build_messages(str(row["instruction"]), frames),
+                temperature=0,
+                response_format={"type": "json_object"},
+            )
+            text = response.choices[0].message.content or "{}"
+            usage_cost = estimate_cost(response.usage, args.input_cost_per_1m, args.output_cost_per_1m)
+            parsed = parse_json_response(text)
+            result = {**row, **parsed, "api_model": args.model, "backend": "api", **usage_cost, "api_error": ""}
+        except Exception as exc:
+            result = {**row, "api_model": args.model, "backend": "api", "api_error": f"{type(exc).__name__}: {exc}"}
+
+        append_jsonl(args.output, result)
+        processed += 1
+        total_prompt_tokens += int(result.get("prompt_tokens", 0) or 0)
+        total_completion_tokens += int(result.get("completion_tokens", 0) or 0)
+        total_tokens += int(result.get("total_tokens", 0) or 0)
+        total_cost += float(result.get("estimated_cost_usd", 0.0) or 0.0)
+        print(
+            f"processed={processed} candidate={row.get('candidate_id')} "
+            f"error={bool(result.get('api_error'))} cost=${float(result.get('estimated_cost_usd', 0.0) or 0.0):.6f}",
+            flush=True,
+        )
+
+    print(json.dumps({"processed": processed, "prompt_tokens": total_prompt_tokens, "completion_tokens": total_completion_tokens, "total_tokens": total_tokens, "estimated_cost_usd": round(total_cost, 6), "output": str(args.output)}, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

top5000_clipframe_dino_clipt_dedup/run_gemini_pro_label.sh

@@ -2,7 +2,6 @@
 set -euo pipefail
 
 BASE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$BASE_DIR/../../.." && pwd)"
 
 MODEL="${MODEL:-gemini-3.1-pro-preview-thinking}"
 BASE_URL="${BASE_URL:-http://35.220.164.252:3888/v1}"
@@ -11,15 +10,15 @@ RESIZE="${RESIZE:-512}"
 LIMIT="${LIMIT:-0}"
 OUTPUT="${OUTPUT:-$BASE_DIR/aesthetic_scores_gemini_pro.jsonl}"
 
-cd "$REPO_ROOT"
+cd "$BASE_DIR"
 
-python3 "$BASE_DIR/prepare_aesthetic_api_input.py" \
+python3 prepare_aesthetic_api_input.py \
   --base-dir "$BASE_DIR" \
   --input "$BASE_DIR/prompt.jsonl" \
   --output "$BASE_DIR/aesthetic_api_input.jsonl"
 
 cmd=(
-  python3 reference/benchmarks/critic/aesthetic_rm/label_aesthetic_api.py
+  python3 label_aesthetic_standalone.py
   --input "$BASE_DIR/aesthetic_api_input.jsonl"
   --output "$OUTPUT"
   --base-url "$BASE_URL"