Upload folder using huggingface_hub

low_high_cost/RUNBOOK.md

@@ -0,0 +1,207 @@
+# low_high_cost 继续训练数据流水线
+
+目标：把 `datas/low_high_cost/extracted/final_output/prompt.jsonl` 转成现有
+`scripts/training/edit-model/train.py` 已经支持的 `shared_records` 格式。
+
+当前推荐方向是 `low_to_high`：
+
+- `vace_video/control` = `low_cost_video`
+- `video/target` = `high_cost_video`
+- prompt = low -> high 的增强指令
+
+注意：原始 `high2low_prompt` 是反方向，不能直接当 low -> high prompt 使用。
+
+## 0. 检查原始数据
+
+```bash
+cd /mnt/si002961ale4/default/lgy/shiying/low-high-new
+
+python3 - <<'PY'
+from pathlib import Path
+p = Path("datas/low_high_cost/extracted/final_output/prompt.jsonl")
+print("prompt exists", p.exists())
+print("rows", sum(1 for _ in p.open(encoding="utf-8")) if p.exists() else 0)
+print("high dirs", len(list(Path("datas/low_high_cost/extracted/final_output/high_cost_video").glob("*"))))
+print("low dirs", len(list(Path("datas/low_high_cost/extracted/final_output/low_cost_video").glob("*"))))
+PY
+```
+
+## 1. 不用 API，先用固定 low -> high 模板生成 records
+
+这个版本最快，可以直接 smoke training。
+
+```bash
+python3 datas/low_high_cost/build_low_high_cost_records.py \
+  --repo-root . \
+  --root datas/low_high_cost/extracted/final_output \
+  --output out/edit_model_face_stage1/shared_records.low_high_cost.template_low2high.jsonl \
+  --direction low_to_high \
+  --prompt-source template \
+  --require-files
+```
+
+验证：
+
+```bash
+python3 datas/low_high_cost/validate_records.py \
+  --repo-root . \
+  --records out/edit_model_face_stage1/shared_records.low_high_cost.template_low2high.jsonl \
+  --show 2 \
+  --fail-on-missing
+```
+
+## 2. 可选：用 API 反写 prompt
+
+不要把 key 写进文件。远程运行时用环境变量：
+
+```bash
+export LOW_HIGH_COST_API_KEY="sk-..."
+```
+
+### 2.1 文本反写模式
+
+只使用原始 `high2low_prompt`，速度快、成本低，但不会看视频内容。
+
+先 dry-run：
+
+```bash
+python3 datas/low_high_cost/invert_high2low_prompts_api.py \
+  --input datas/low_high_cost/extracted/final_output/prompt.jsonl \
+  --output datas/low_high_cost/outputs/low2high_prompts_api.jsonl \
+  --model gpt-4o \
+  --limit 3 \
+  --dry-run
+```
+
+少量真实调用测试：
+
+```bash
+python3 datas/low_high_cost/invert_high2low_prompts_api.py \
+  --input datas/low_high_cost/extracted/final_output/prompt.jsonl \
+  --output datas/low_high_cost/outputs/low2high_prompts_api.jsonl \
+  --base-url http://35.220.164.252:3888/v1 \
+  --api-key-env LOW_HIGH_COST_API_KEY \
+  --model gpt-4o \
+  --limit 3 \
+  --input-cost-per-1m 0 \
+  --output-cost-per-1m 0
+```
+
+`input-cost-per-1m` 和 `output-cost-per-1m` 可以按模型广场价格填；脚本会在每条和最后 summary 打印 token 与估算费用。
+
+批量跑时去掉 `--limit`。脚本支持 resume：已有成功 `id` 会跳过。
+
+### 2.2 视频感知反写模式
+
+正式 prompt 更推荐这个模式：同时给模型 low/high 视频抽帧和原始 `high2low_prompt`，让 VLM 根据真实视觉差异生成 `low2high_prompt`。
+
+少量 dry-run：
+
+```bash
+python3 datas/low_high_cost/invert_high2low_prompts_api.py \
+  --input datas/low_high_cost/extracted/final_output/prompt.jsonl \
+  --output datas/low_high_cost/outputs/low2high_prompts_video_api.jsonl \
+  --repo-root . \
+  --root datas/low_high_cost/extracted/final_output \
+  --model gpt-4o \
+  --limit 3 \
+  --use-video \
+  --max-frames 3 \
+  --resize 448 \
+  --dry-run
+```
+
+少量真实调用：
+
+```bash
+python3 datas/low_high_cost/invert_high2low_prompts_api.py \
+  --input datas/low_high_cost/extracted/final_output/prompt.jsonl \
+  --output datas/low_high_cost/outputs/low2high_prompts_video_api.jsonl \
+  --repo-root . \
+  --root datas/low_high_cost/extracted/final_output \
+  --base-url http://35.220.164.252:3888/v1 \
+  --api-key-env LOW_HIGH_COST_API_KEY \
+  --model gpt-4o \
+  --limit 3 \
+  --use-video \
+  --max-frames 3 \
+  --resize 448 \
+  --input-cost-per-1m 0 \
+  --output-cost-per-1m 0
+```
+
+本地 VLM 部署时，把 `--base-url` 和 `--model` 换成模型服务对应值即可。对 10 万条全量数据，建议先用 `--max-frames 2` 或 `3` 做成本和速度测试。
+
+### 2.3 不部署服务，直接加载本地 VLM
+
+如果不想启动 vLLM/OpenAI-compatible 服务，可以直接用 `transformers` 加载本地模型。这个方式启动慢一些，但 smoke test 最简单。
+
+```bash
+python3 datas/low_high_cost/invert_high2low_prompts_api.py \
+  --backend local \
+  --input datas/low_high_cost/extracted/final_output/prompt.jsonl \
+  --output datas/low_high_cost/outputs/low2high_prompts_video_qwen3vl32b_local_smoke3.jsonl \
+  --repo-root . \
+  --root datas/low_high_cost/extracted/final_output \
+  --model Qwen3-VL-32B-Instruct \
+  --local-model-dir models/Qwen3-VL-32B-Instruct \
+  --local-dtype bfloat16 \
+  --local-device-map auto \
+  --limit 3 \
+  --use-video \
+  --max-frames 3 \
+  --resize 448 \
+  --max-new-tokens 512
+```
+
+如果显存不够，��把 `--max-frames 3` 改成 `--max-frames 2`。如果本机 `transformers` 版本不支持 Qwen3-VL，需要先升级 transformers/qwen-vl-utils，或者改用 vLLM 服务方式。
+
+## 3. 用 API 反写结果生成 records
+
+```bash
+python3 datas/low_high_cost/build_low_high_cost_records.py \
+  --repo-root . \
+  --root datas/low_high_cost/extracted/final_output \
+  --output out/edit_model_face_stage1/shared_records.low_high_cost.api_low2high.jsonl \
+  --direction low_to_high \
+  --prompt-source auto \
+  --inverted-prompts datas/low_high_cost/outputs/low2high_prompts_api.jsonl \
+  --require-files
+```
+
+`--prompt-source auto` 会优先使用 API 的 `low2high_prompt`；某条没有 API 结果时回退到固定模板。
+
+## 4. 继续训练命令
+
+先用不启动真实训练的方式生成 `metadata.train.csv` 和 `metadata.val.csv`：
+
+```bash
+cd /mnt/si002961ale4/default/lgy/shiying/low-high-new
+
+export PYTHONPATH=src
+
+/opt/conda/bin/python3 scripts/training/edit-model/train.py \
+  --dataset out/edit_model_face_stage1/shared_records.low_high_cost.api_low2high.jsonl \
+  --output-dir out/edit_model_face_stage1/base_sft_low_high_cost_8gpu_full \
+  --stage base_sft \
+  --recipe official_vace14b_continue \
+  --launcher accelerate \
+  --python-executable /opt/conda/bin/python3 \
+  --accelerate-num-processes 8 \
+  --accelerate-config-file scripts/training/edit-model/accelerate_config_8gpu_bf16.yaml \
+  --models-root models \
+  --dataset-num-workers 1 \
+  --save-steps 5000 \
+  --model-init-device cpu
+```
+
+检查：
+
+```bash
+head -5 out/edit_model_face_stage1/base_sft_low_high_cost_8gpu_full/real_train/metadata.train.csv
+head -5 out/edit_model_face_stage1/base_sft_low_high_cost_8gpu_full/real_train/metadata.val.csv
+```
+
+确认无误后加 `--run-real-train`。
+
+latent text / vace hint / vace context 版本只需要沿用原来的训练参数，把 `--dataset` 和 `--output-dir` 换掉。

low_high_cost/build_low_high_cost_records.py

@@ -0,0 +1,210 @@
+#!/usr/bin/env python3
+"""Convert low_high_cost prompt.jsonl into edit-model shared_records JSONL."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+DEFAULT_ROOT = Path("datas/low_high_cost/extracted/final_output")
+DEFAULT_TEMPLATE_PROMPT = (
+    "Transform this low-cost video into its high-cost cinematic version. "
+    "Restore richer production design, refined lighting, color grading, materials, wardrobe, "
+    "environment detail, and cinematic atmosphere while preserving the original layout, identity, "
+    "actions, camera motion, and scene semantics."
+)
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    if not path.exists():
+        raise FileNotFoundError(path)
+    for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc
+    return rows
+
+
+def load_inversions(path: Path | None) -> dict[str, str]:
+    if path is None:
+        return {}
+    out: dict[str, str] = {}
+    for row in read_jsonl(path):
+        sample_id = str(row.get("id", "") or row.get("source_sample_id", "") or "").strip()
+        prompt = str(row.get("low2high_prompt", "") or "").strip()
+        if sample_id and prompt and not row.get("api_error"):
+            out[sample_id] = prompt
+    return out
+
+
+def make_rel(path: Path, repo_root: Path) -> str:
+    try:
+        return path.resolve().relative_to(repo_root.resolve()).as_posix()
+    except ValueError:
+        return path.as_posix()
+
+
+def scene_group(row: dict[str, Any]) -> str:
+    rel = str(row.get("high_cost_path", "") or row.get("low_cost_path", "") or "")
+    if "/" in rel:
+        return rel.split("/")[-2]
+    sample_id = str(row.get("id", "") or "")
+    return sample_id.split("-Scene-")[0] if "-Scene-" in sample_id else sample_id.split("_part")[0]
+
+
+def choose_prompt(
+    row: dict[str, Any],
+    *,
+    direction: str,
+    prompt_source: str,
+    inversions: dict[str, str],
+    template_prompt: str,
+) -> tuple[str, str]:
+    sample_id = str(row.get("id", "") or "").strip()
+    high2low_prompt = str(row.get("high2low_prompt", "") or "").strip()
+
+    if direction == "high_to_low":
+        if prompt_source in {"original", "auto"}:
+            return high2low_prompt, "high2low_prompt"
+        if prompt_source == "template":
+            return (
+                "Transform this high-cost cinematic video into a lower-cost everyday version while "
+                "preserving layout, identity, actions, and camera motion.",
+                "template",
+            )
+        return "", "empty"
+
+    if prompt_source in {"inverted", "auto"} and sample_id in inversions:
+        return inversions[sample_id], "low2high_prompt_api"
+    if prompt_source in {"template", "auto"}:
+        return template_prompt, "template"
+    if prompt_source == "original":
+        return high2low_prompt, "high2low_prompt_wrong_direction"
+    return "", "empty"
+
+
+def build_record(
+    row: dict[str, Any],
+    *,
+    root: Path,
+    repo_root: Path,
+    direction: str,
+    prompt_source: str,
+    inversions: dict[str, str],
+    template_prompt: str,
+) -> dict[str, Any]:
+    sample_id = str(row.get("id", "") or "").strip()
+    high_abs = root / str(row.get("high_cost_path", "") or "")
+    low_abs = root / str(row.get("low_cost_path", "") or "")
+
+    if direction == "low_to_high":
+        low_video_path = make_rel(low_abs, repo_root)
+        high_video_path = make_rel(high_abs, repo_root)
+    else:
+        low_video_path = make_rel(high_abs, repo_root)
+        high_video_path = make_rel(low_abs, repo_root)
+
+    prompt, prompt_source_used = choose_prompt(
+        row,
+        direction=direction,
+        prompt_source=prompt_source,
+        inversions=inversions,
+        template_prompt=template_prompt,
+    )
+
+    group = scene_group(row)
+    return {
+        "sample_id": f"low_high_cost__{direction}__{sample_id}",
+        "source_dataset": "low_high_cost",
+        "source_type": "low_high_cost_pair",
+        "source_sample_id": sample_id,
+        "source_group_id": group,
+        "direction": direction,
+        "low_video_path": low_video_path,
+        "high_video_path": high_video_path,
+        "low_video_exists": (repo_root / low_video_path).exists() if not Path(low_video_path).is_absolute() else Path(low_video_path).exists(),
+        "high_video_exists": (repo_root / high_video_path).exists() if not Path(high_video_path).is_absolute() else Path(high_video_path).exists(),
+        "raw_prompt": prompt,
+        "normalized_prompt": prompt,
+        "compiled_edit_prompt": prompt,
+        "prompt_source": prompt_source_used,
+        "high2low_prompt_original": str(row.get("high2low_prompt", "") or ""),
+        "high_cost_path_original": str(row.get("high_cost_path", "") or ""),
+        "low_cost_path_original": str(row.get("low_cost_path", "") or ""),
+        "reference_image_path": "",
+        "scene_archetype": {"archetype_id": group, "scene_hint": group},
+        "style_family": "low_high_cost",
+    }
+
+
+def write_jsonl(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--repo-root", type=Path, default=Path("."))
+    parser.add_argument("--root", type=Path, default=DEFAULT_ROOT)
+    parser.add_argument("--prompt-jsonl", type=Path, default=None)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--direction", choices=["low_to_high", "high_to_low"], default="low_to_high")
+    parser.add_argument("--prompt-source", choices=["auto", "template", "inverted", "original", "empty"], default="auto")
+    parser.add_argument("--inverted-prompts", type=Path, default=None)
+    parser.add_argument("--template-prompt", default=DEFAULT_TEMPLATE_PROMPT)
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--require-files", action="store_true")
+    args = parser.parse_args()
+
+    prompt_jsonl = args.prompt_jsonl or (args.root / "prompt.jsonl")
+    source_rows = read_jsonl(prompt_jsonl)
+    if args.limit:
+        source_rows = source_rows[: args.limit]
+
+    inversions = load_inversions(args.inverted_prompts)
+    records = [
+        build_record(
+            row,
+            root=args.root,
+            repo_root=args.repo_root,
+            direction=args.direction,
+            prompt_source=args.prompt_source,
+            inversions=inversions,
+            template_prompt=args.template_prompt,
+        )
+        for row in source_rows
+    ]
+    if args.require_files:
+        records = [r for r in records if r["low_video_exists"] and r["high_video_exists"]]
+
+    write_jsonl(args.output, records)
+    summary = {
+        "source": str(prompt_jsonl),
+        "output": str(args.output),
+        "direction": args.direction,
+        "prompt_source": args.prompt_source,
+        "source_rows": len(source_rows),
+        "written_records": len(records),
+        "missing_low": sum(not r["low_video_exists"] for r in records),
+        "missing_high": sum(not r["high_video_exists"] for r in records),
+        "empty_prompt": sum(not str(r.get("raw_prompt", "")).strip() for r in records),
+        "inverted_prompts_loaded": len(inversions),
+    }
+    args.output.with_suffix(args.output.suffix + ".summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

low_high_cost/extracted/final_output/README.md

@@ -0,0 +1,101 @@
+# Low-High Cost Video Dataset
+
+这是一个用于视频生成/转换研究的数据集，包含**高成本(high-cost)**和**低成本(low-cost)**视频的配对数据。
+
+## 数据概述
+
+| 统计项 | 数量 |
+|--------|------|
+| 视频场景组数量 | 447 组 |
+| 视频片段总数 | 102,881 对 |
+| 标注文件 | 1 个 (prompt.jsonl) |
+
+## 目录结构
+
+```
+final_output/
+├── prompt.jsonl          # 标注文件（所有视频对的元数据）
+├── high_cost_video/     # 高成本视频（高质量/高保真版本）
+│   ├── 10-o/
+│   │   ├── 10-Scene-0016_part1.mp4
+│   │   ├── 10-Scene-0019_part1.mp4
+│   │   └── ...
+│   ├── 11-o/
+│   ├── 12-o/
+│   └── ...
+└── low_cost_video/      # 低成本视频（低质量/简化版本）
+    ├── 10-o/
+    │   ├── 10-Scene-0016_part1.mp4
+    │   ├── 10-Scene-0019_part1.mp4
+    │   └── ...
+    ├── 11-o/
+    └── ...
+```
+
+## 文件命名规则
+
+### 目录命名
+- 格式：`{数字}[-序号]-o`
+- 示例：`10-o`, `11-o`, `22_1-o`, `22_2-o`
+- 说明：同一组编号（如 `22_*`）的视频可能来自同一来源的不同片段
+
+### 视频文件命名
+- 格式：`{组编号}-Scene-{场景编号}_part{分段编号}.mp4`
+- 示例：`10-Scene-0016_part1.mp4`
+- 说明：
+  - `part1` / `part2` / `part3` 等表示同一场景的连续分段
+  - 高成本和低成本版本**共享相同的命名**，方便配对
+
+## prompt.jsonl 格式
+
+每行是一个独立的 JSON 对象，表示一对视频的标注信息：
+
+```json
+{
+  "id": "10-Scene-0016_part1",
+  "high_cost_path": "high_cost_video/10-o/10-Scene-0016_part1.mp4",
+  "low_cost_path": "low_cost_video/10-o/10-Scene-0016_part1.mp4",
+  "high2low_prompt": "1. Remove or replace the white hat...\n2. Replace the sparkly headband..."
+}
+```
+
+### 字段说明
+
+| 字段 | 类型 | 描述 |
+|------|------|------|
+| `id` | string | 视频片段的唯一标识符 |
+| `high_cost_path` | string | 高成本视频的相对路径 |
+| `low_cost_path` | string | 低成本视频的相对路径 |
+| `high2low_prompt` | string | 将高质量视频转换为低质量版本的详细指令 |
+
+## 数据用途
+
+此数据集适用于以下研究场景：
+
+1. **视频质量转换**：训练模型学习如何将高保真视频转换为低质量版本
+2. **风格迁移**：学习从精致风格到简约日常风格的转换
+3. **视频增强**：反向工程——从低质量恢复高质量
+4. **对比学习**：研究高/低质量视频对之间的特征差异
+
+## 使用示例
+
+```python
+import json
+
+# 读取标注
+with open("prompt.jsonl", "r") as f:
+    for line in f:
+        data = json.loads(line)
+        print(f"ID: {data['id']}")
+        print(f"High Cost: {data['high_cost_path']}")
+        print(f"Low Cost: {data['low_cost_path']}")
+        print(f"Prompt: {data['high2low_prompt'][:100]}...")
+        break  # 只展示第一条
+```
+
+## 注意事项
+
+- 高成本视频和低成本视频**一一对应**，文件名前缀完全一致
+- `high2low_prompt` 是将高成本视频转换为低成本视频的操作指令列表
+- 视频内容可能涉及人物穿着、场景复杂度、光照效果等多维度的质量差异
+

low_high_cost/invert_high2low_prompts_api.py

@@ -0,0 +1,509 @@
+#!/usr/bin/env python3
+"""Rewrite high->low prompts into low->high prompts with API or a local VLM."""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import io
+import json
+import math
+import os
+import time
+from pathlib import Path
+from typing import Any
+
+
+SYSTEM_PROMPT = """You rewrite video editing instructions.
+The input describes how to turn a high-cost/high-production video into a low-cost/simplified video.
+Rewrite it into the reverse direction: low-cost video -> high-cost cinematic video.
+Return strict JSON only."""
+
+VIDEO_SYSTEM_PROMPT = """You are a video-edit prompt planner for low-cost to high-cost cinematic enhancement.
+You compare sampled frames from a low-cost video and its paired high-cost video, then write a training prompt.
+Return strict JSON only."""
+
+USER_TEMPLATE = """Sample id: {sample_id}
+
+Original high-to-low instruction:
+{high2low_prompt}
+
+Write a concise low-to-high instruction for training a video edit model.
+Requirements:
+- Preserve the original layout, identity, camera motion, timing, and scene semantics.
+- Ask for high-cost cinematic improvement: production design, lighting, color grading, materials, wardrobe, background detail, atmosphere, and visual polish.
+- Do not mention that this is a reverse rewrite.
+- Do not ask to change the story into unrelated content.
+- Output JSON with exactly these keys:
+  - low2high_prompt: string
+  - transformation_tags: array of short strings
+  - confidence: number from 0 to 1
+"""
+
+VIDEO_USER_TEMPLATE = """Sample id: {sample_id}
+
+We have a paired video edit dataset:
+- LOW frames: ordinary / low-cost version used as source/control video.
+- HIGH frames: cinematic / high-cost target video, often with visual effects, unusual appearance, period/fantasy/scifi styling, richer costume, grander setting, better lighting, color grading, materials, atmosphere, and production design.
+
+Original high-to-low instruction used to create the pair:
+{high2low_prompt}
+
+Task:
+Write the corresponding low-to-high edit instruction for training a video edit model.
+
+Requirements:
+- Use both LOW and HIGH frames. Describe the concrete visible transformation from low to high.
+- Reverse each recoverable high-to-low edit when possible.
+- Preserve original layout, identity, action, camera motion, timing, shot scale, and scene semantics.
+- Anchor new cinematic/high-cost details to visible carriers in the LOW video: people, clothing, props, background, architecture, light sources, atmosphere, materials, or scene geometry.
+- Mention high-cost elements only if they are supported by the HIGH frames or original instruction.
+- Avoid generic wording like "make it cinematic" alone; include specific visual changes.
+- Do not invent unrelated story events.
+- Do not mention that this is a reverse rewrite.
+- Output JSON with exactly these keys:
+  - low2high_prompt: string
+  - transformation_tags: array of short strings
+  - confidence: number from 0 to 1
+"""
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc
+    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 f:
+        f.write(json.dumps(row, ensure_ascii=False) + "\n")
+        f.flush()
+
+
+def load_done_ids(path: Path) -> set[str]:
+    if not path.exists():
+        return set()
+    done: set[str] = set()
+    for row in read_jsonl(path):
+        sample_id = str(row.get("id", "") or "").strip()
+        if sample_id and not row.get("api_error"):
+            done.add(sample_id)
+    return done
+
+
+def parse_response(text: str) -> dict[str, Any]:
+    text = text.strip()
+    if text.startswith("```"):
+        text = text.strip("`").strip()
+        if text.startswith("json"):
+            text = text[4:].strip()
+    data = json.loads(text)
+    prompt = str(data.get("low2high_prompt", "") or "").strip()
+    if not prompt:
+        raise ValueError("missing low2high_prompt")
+    tags = data.get("transformation_tags", [])
+    if not isinstance(tags, list):
+        tags = []
+    try:
+        confidence = float(data.get("confidence", 0.0))
+    except (TypeError, ValueError):
+        confidence = 0.0
+    return {
+        "low2high_prompt": prompt,
+        "transformation_tags": [str(x) for x in tags[:20]],
+        "confidence": max(0.0, min(1.0, confidence)),
+    }
+
+
+def sample_video_frames(video_path: Path, max_frames: int, resize: int) -> list[str]:
+    import imageio.v3 as iio
+    from PIL import Image
+
+    if max_frames <= 0:
+        return []
+    try:
+        meta = iio.immeta(video_path)
+    except Exception:
+        meta = {}
+    raw_frame_count = meta.get("nframes") or 0
+    try:
+        frame_count_float = float(raw_frame_count)
+    except (TypeError, ValueError, OverflowError):
+        frame_count_float = 0.0
+    frame_count = int(frame_count_float) if math.isfinite(frame_count_float) and frame_count_float > 0 else 0
+
+    frames = []
+    if frame_count > 0 and frame_count < 1_000_000:
+        if max_frames == 1:
+            indices = [frame_count // 2]
+        else:
+            indices = [round(i * (frame_count - 1) / (max_frames - 1)) for i in range(max_frames)]
+        for idx in indices:
+            try:
+                frames.append(iio.imread(video_path, index=int(idx)))
+            except Exception:
+                continue
+
+    if not frames:
+        try:
+            for idx, frame in enumerate(iio.imiter(video_path)):
+                if idx % 24 == 0:
+                    frames.append(frame)
+                if len(frames) >= max_frames:
+                    break
+        except Exception as exc:
+            raise RuntimeError(f"failed to decode {video_path}: {exc}") from exc
+
+    encoded: list[str] = []
+    for frame in frames[:max_frames]:
+        image = Image.fromarray(frame).convert("RGB")
+        if resize > 0:
+            image.thumbnail((resize, resize))
+        buffer = io.BytesIO()
+        image.save(buffer, format="JPEG", quality=85)
+        encoded.append(base64.b64encode(buffer.getvalue()).decode("ascii"))
+    return encoded
+
+
+def sample_video_pil_frames(video_path: Path, max_frames: int, resize: int) -> list[Any]:
+    import base64 as base64_module
+    from PIL import Image
+
+    frames_b64 = sample_video_frames(video_path, max_frames, resize)
+    images = []
+    for frame_b64 in frames_b64:
+        images.append(Image.open(io.BytesIO(base64_module.b64decode(frame_b64))).convert("RGB"))
+    return images
+
+
+def image_part(label: str, frame_b64: str) -> list[dict[str, Any]]:
+    return [
+        {"type": "text", "text": label},
+        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{frame_b64}"}},
+    ]
+
+
+def resolve_pair_paths(row: dict[str, Any], root: Path, repo_root: Path) -> tuple[Path, Path]:
+    low = root / str(row.get("low_cost_path", "") or "")
+    high = root / str(row.get("high_cost_path", "") or "")
+    if not low.is_absolute():
+        low = repo_root / low
+    if not high.is_absolute():
+        high = repo_root / high
+    return low, high
+
+
+def build_api_messages(
+    *,
+    sample_id: str,
+    high2low_prompt: str,
+    use_video: bool,
+    row: dict[str, Any],
+    repo_root: Path,
+    root: Path,
+    max_frames: int,
+    resize: int,
+) -> list[dict[str, Any]]:
+    if use_video:
+        low_video, high_video = resolve_pair_paths(row, root, repo_root)
+        low_frames = sample_video_frames(low_video, max_frames, resize)
+        high_frames = sample_video_frames(high_video, max_frames, resize)
+        content: list[dict[str, Any]] = [
+            {"type": "text", "text": VIDEO_USER_TEMPLATE.format(sample_id=sample_id, high2low_prompt=high2low_prompt)}
+        ]
+        for idx, frame in enumerate(low_frames):
+            content.extend(image_part(f"LOW frame {idx + 1}", frame))
+        for idx, frame in enumerate(high_frames):
+            content.extend(image_part(f"HIGH frame {idx + 1}", frame))
+        return [
+            {"role": "system", "content": VIDEO_SYSTEM_PROMPT},
+            {"role": "user", "content": content},
+        ]
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": USER_TEMPLATE.format(sample_id=sample_id, high2low_prompt=high2low_prompt)},
+    ]
+
+
+def build_local_messages(
+    *,
+    sample_id: str,
+    high2low_prompt: str,
+    use_video: bool,
+    row: dict[str, Any],
+    repo_root: Path,
+    root: Path,
+    max_frames: int,
+    resize: int,
+) -> list[dict[str, Any]]:
+    if use_video:
+        low_video, high_video = resolve_pair_paths(row, root, repo_root)
+        low_frames = sample_video_pil_frames(low_video, max_frames, resize)
+        high_frames = sample_video_pil_frames(high_video, max_frames, resize)
+        content: list[dict[str, Any]] = [
+            {"type": "text", "text": VIDEO_USER_TEMPLATE.format(sample_id=sample_id, high2low_prompt=high2low_prompt)}
+        ]
+        for idx, image in enumerate(low_frames):
+            content.append({"type": "text", "text": f"LOW frame {idx + 1}"})
+            content.append({"type": "image", "image": image})
+        for idx, image in enumerate(high_frames):
+            content.append({"type": "text", "text": f"HIGH frame {idx + 1}"})
+            content.append({"type": "image", "image": image})
+        return [
+            {"role": "system", "content": VIDEO_SYSTEM_PROMPT},
+            {"role": "user", "content": content},
+        ]
+    return [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": USER_TEMPLATE.format(sample_id=sample_id, high2low_prompt=high2low_prompt)},
+    ]
+
+
+def collect_local_images(messages: list[dict[str, Any]]) -> list[Any]:
+    images = []
+    for message in messages:
+        content = message.get("content")
+        if not isinstance(content, list):
+            continue
+        for part in content:
+            if isinstance(part, dict) and part.get("type") == "image":
+                images.append(part.get("image"))
+    return images
+
+
+def load_local_model(model_dir: Path, dtype: str, device_map: str) -> tuple[Any, Any]:
+    import torch
+    from transformers import AutoProcessor
+
+    try:
+        from transformers import AutoModelForImageTextToText
+        model_cls = AutoModelForImageTextToText
+    except ImportError:
+        from transformers import AutoModelForVision2Seq
+        model_cls = AutoModelForVision2Seq
+
+    dtype_map = {
+        "auto": "auto",
+        "bfloat16": torch.bfloat16,
+        "float16": torch.float16,
+        "float32": torch.float32,
+    }
+    torch_dtype = dtype_map.get(dtype, "auto")
+    processor = AutoProcessor.from_pretrained(str(model_dir), trust_remote_code=True)
+    model = model_cls.from_pretrained(
+        str(model_dir),
+        torch_dtype=torch_dtype,
+        device_map=device_map,
+        trust_remote_code=True,
+    )
+    model.eval()
+    return model, processor
+
+
+def local_generate(
+    *,
+    model: Any,
+    processor: Any,
+    messages: list[dict[str, Any]],
+    max_new_tokens: int,
+) -> tuple[str, dict[str, int]]:
+    import torch
+
+    prompt_text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    images = collect_local_images(messages)
+    kwargs: dict[str, Any] = {"text": [prompt_text], "return_tensors": "pt"}
+    if images:
+        kwargs["images"] = images
+    inputs = processor(**kwargs)
+    model_device = next(model.parameters()).device
+    inputs = {k: v.to(model_device) if hasattr(v, "to") else v for k, v in inputs.items()}
+    input_len = int(inputs["input_ids"].shape[-1])
+    with torch.inference_mode():
+        generated = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)
+    output_ids = generated[:, input_len:]
+    text = processor.batch_decode(output_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+    usage = {
+        "prompt_tokens": input_len,
+        "completion_tokens": int(output_ids.shape[-1]),
+        "total_tokens": int(generated.shape[-1]),
+    }
+    return text, usage
+
+
+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()
+    parser.add_argument("--backend", choices=["api", "local"], default="api")
+    parser.add_argument("--input", type=Path, default=Path("datas/low_high_cost/extracted/final_output/prompt.jsonl"))
+    parser.add_argument("--output", type=Path, default=Path("datas/low_high_cost/outputs/low2high_prompts_api.jsonl"))
+    parser.add_argument("--repo-root", type=Path, default=Path("."))
+    parser.add_argument("--root", type=Path, default=Path("datas/low_high_cost/extracted/final_output"))
+    parser.add_argument("--base-url", default="http://35.220.164.252:3888/v1")
+    parser.add_argument("--api-key-env", default="LOW_HIGH_COST_API_KEY")
+    parser.add_argument("--model", default="gpt-4o")
+    parser.add_argument("--local-model-dir", type=Path, default=None)
+    parser.add_argument("--local-dtype", choices=["auto", "bfloat16", "float16", "float32"], default="bfloat16")
+    parser.add_argument("--local-device-map", default="auto")
+    parser.add_argument("--max-new-tokens", type=int, default=512)
+    parser.add_argument("--limit", type=int, default=0)
+    parser.add_argument("--temperature", type=float, default=0.0)
+    parser.add_argument("--use-video", action="store_true")
+    parser.add_argument("--max-frames", type=int, default=3)
+    parser.add_argument("--resize", type=int, default=448)
+    parser.add_argument("--input-cost-per-1m", type=float, default=0.0)
+    parser.add_argument("--output-cost-per-1m", type=float, default=0.0)
+    parser.add_argument("--sleep", type=float, default=0.0)
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args()
+
+    rows = read_jsonl(args.input)
+    if args.limit:
+        rows = rows[: args.limit]
+    done = load_done_ids(args.output)
+    pending = [r for r in rows if str(r.get("id", "") or "") not in done]
+
+    if args.dry_run:
+        print(f"dry run: rows={len(rows)} done={len(done)} pending={len(pending)}")
+        if pending:
+            sample = pending[0]
+            payload = {"id": sample.get("id"), "high2low_prompt": sample.get("high2low_prompt", "")[:800]}
+            if args.use_video:
+                low, high = resolve_pair_paths(sample, args.root, args.repo_root)
+                payload.update({"low_video": str(low), "high_video": str(high), "max_frames": args.max_frames, "resize": args.resize})
+            print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return
+
+    client = None
+    local_model = None
+    local_processor = None
+    if args.backend == "api":
+        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)
+    else:
+        model_dir = args.local_model_dir or Path(args.model)
+        local_model, local_processor = load_local_model(model_dir, args.local_dtype, args.local_device_map)
+    processed = 0
+    total_prompt_tokens = 0
+    total_completion_tokens = 0
+    total_cost = 0.0
+
+    for row in pending:
+        sample_id = str(row.get("id", "") or "").strip()
+        high2low_prompt = str(row.get("high2low_prompt", "") or "").strip()
+        result: dict[str, Any]
+        try:
+            if args.backend == "api":
+                messages = build_api_messages(
+                    sample_id=sample_id,
+                    high2low_prompt=high2low_prompt,
+                    use_video=args.use_video,
+                    row=row,
+                    repo_root=args.repo_root,
+                    root=args.root,
+                    max_frames=args.max_frames,
+                    resize=args.resize,
+                )
+                response = client.chat.completions.create(
+                    model=args.model,
+                    messages=messages,
+                    temperature=args.temperature,
+                    response_format={"type": "json_object"},
+                )
+                response_text = response.choices[0].message.content or "{}"
+                usage_cost = estimate_cost(response.usage, args.input_cost_per_1m, args.output_cost_per_1m)
+            else:
+                messages = build_local_messages(
+                    sample_id=sample_id,
+                    high2low_prompt=high2low_prompt,
+                    use_video=args.use_video,
+                    row=row,
+                    repo_root=args.repo_root,
+                    root=args.root,
+                    max_frames=args.max_frames,
+                    resize=args.resize,
+                )
+                response_text, local_usage = local_generate(
+                    model=local_model,
+                    processor=local_processor,
+                    messages=messages,
+                    max_new_tokens=args.max_new_tokens,
+                )
+                usage_cost = {**local_usage, "estimated_cost_usd": 0.0}
+            parsed = parse_response(response_text)
+            result = {
+                "id": sample_id,
+                **parsed,
+                "api_model": args.model,
+                "backend": args.backend,
+                "prompt_mode": "video_pair" if args.use_video else "text_only",
+                "max_frames_per_video": args.max_frames if args.use_video else 0,
+                **usage_cost,
+                "api_error": "",
+            }
+        except Exception as exc:
+            result = {
+                "id": sample_id,
+                "low2high_prompt": "",
+                "transformation_tags": [],
+                "confidence": 0.0,
+                "api_model": args.model,
+                "backend": args.backend,
+                "prompt_mode": "video_pair" if args.use_video else "text_only",
+                "max_frames_per_video": args.max_frames if args.use_video else 0,
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0,
+                "estimated_cost_usd": 0.0,
+                "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_cost += float(result.get("estimated_cost_usd", 0.0) or 0.0)
+        print(
+            f"processed={processed} id={sample_id} error={bool(result.get('api_error'))} "
+            f"cost=${float(result.get('estimated_cost_usd', 0.0) or 0.0):.6f}",
+            flush=True,
+        )
+        if args.sleep:
+            time.sleep(args.sleep)
+
+    summary = {
+        "input": str(args.input),
+        "output": str(args.output),
+        "model": args.model,
+        "processed": processed,
+        "prompt_tokens": total_prompt_tokens,
+        "completion_tokens": total_completion_tokens,
+        "estimated_cost_usd": round(total_cost, 6),
+    }
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

low_high_cost/validate_records.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""Validate low_high_cost shared_records before launching training."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+
+REQUIRED_FIELDS = ["sample_id", "low_video_path", "high_video_path", "raw_prompt"]
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"{path}:{line_no}: invalid JSON: {exc}") from exc
+    return rows
+
+
+def exists(path_text: str, repo_root: Path) -> bool:
+    path = Path(path_text)
+    if path.is_absolute():
+        return path.exists()
+    return (repo_root / path).exists()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--records", type=Path, required=True)
+    parser.add_argument("--repo-root", type=Path, default=Path("."))
+    parser.add_argument("--show", type=int, default=5)
+    parser.add_argument("--fail-on-missing", action="store_true")
+    args = parser.parse_args()
+
+    rows = read_jsonl(args.records)
+    sample_ids = [str(r.get("sample_id", "") or "") for r in rows]
+    duplicate_ids = [k for k, v in Counter(sample_ids).items() if k and v > 1]
+
+    missing_fields = {field: 0 for field in REQUIRED_FIELDS}
+    missing_low: list[str] = []
+    missing_high: list[str] = []
+    empty_prompt: list[str] = []
+    prompt_sources = Counter()
+    groups = Counter()
+
+    for row in rows:
+        for field in REQUIRED_FIELDS:
+            if not str(row.get(field, "") or "").strip():
+                missing_fields[field] += 1
+        sample_id = str(row.get("sample_id", "") or "")
+        if not exists(str(row.get("low_video_path", "") or ""), args.repo_root):
+            missing_low.append(sample_id)
+        if not exists(str(row.get("high_video_path", "") or ""), args.repo_root):
+            missing_high.append(sample_id)
+        if not str(row.get("raw_prompt", "") or "").strip():
+            empty_prompt.append(sample_id)
+        prompt_sources[str(row.get("prompt_source", "") or "unknown")] += 1
+        groups[str(row.get("source_group_id", "") or "unknown")] += 1
+
+    summary = {
+        "records": str(args.records),
+        "rows": len(rows),
+        "unique_sample_ids": len(set(sample_ids)),
+        "duplicate_sample_ids": len(duplicate_ids),
+        "missing_fields": missing_fields,
+        "missing_low_video": len(missing_low),
+        "missing_high_video": len(missing_high),
+        "empty_prompt": len(empty_prompt),
+        "num_groups": len(groups),
+        "prompt_sources": dict(prompt_sources),
+        "top_groups": groups.most_common(10),
+        "examples": rows[: args.show],
+        "missing_examples": {
+            "low": missing_low[: args.show],
+            "high": missing_high[: args.show],
+            "empty_prompt": empty_prompt[: args.show],
+            "duplicate_ids": duplicate_ids[: args.show],
+        },
+    }
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+    if args.fail_on_missing and (duplicate_ids or missing_low or missing_high or empty_prompt or any(missing_fields.values())):
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()