Upload videos_zip_two_refiners/scripts/run_video_zip_two_refiners_chunked.py with huggingface_hub

videos_zip_two_refiners/scripts/run_video_zip_two_refiners_chunked.py

@@ -0,0 +1,316 @@
+#!/usr/bin/env python
+"""Run two sequential x2 refiners on videos.zip with temporal chunking."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from ltx_core.loader import LTXV_LORA_COMFY_RENAMING_MAP, LoraPathStrengthAndSDOps
+from ltx_pipelines.utils.helpers import cleanup_memory
+from ltx_pipelines.utils.media_io import get_videostream_metadata
+from ltx_pipelines.utils.types import OffloadMode
+from ltx_pipelines.video_refiner_upscale import (
+    VideoRefinerUpscalePipeline,
+    _parse_quantization,
+    _snap_frames_to_8k1,
+)
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from experiments.ltx2_repro.run_video_zip_two_refiners import (
+    OUTPUTS_DIR,
+    append_manifest,
+    extract_videos,
+    load_config,
+    rel,
+)
+
+
+CHUNKS_DIR = OUTPUTS_DIR / "chunks"
+
+
+def chunk_spans(total_frames: int, chunk_frames: int) -> list[tuple[int, int]]:
+    spans: list[tuple[int, int]] = []
+    start = 0
+    while start < total_frames:
+        remaining = total_frames - start
+        if remaining < 9:
+            break
+        frames = _snap_frames_to_8k1(min(chunk_frames, remaining))
+        if frames < 1:
+            break
+        spans.append((start, frames))
+        start += frames
+    return spans
+
+
+def concat_videos(inputs: list[Path], output_path: Path, fps: float) -> int:
+    cmd = [
+        sys.executable,
+        str(Path(__file__).with_name("concat_video_chunks.py")),
+        "--output",
+        str(output_path),
+        "--fps",
+        str(fps),
+        *(str(p) for p in inputs),
+    ]
+    proc = subprocess.run(cmd, cwd=ROOT, text=True, capture_output=True)
+    if proc.returncode != 0:
+        raise RuntimeError(f"Video chunk concatenation failed: {proc.stderr.strip() or proc.stdout.strip()}")
+    return int(json.loads(proc.stdout.strip().splitlines()[-1])["frames"])
+
+
+def is_valid_video(path: Path) -> bool:
+    if not path.exists() or path.stat().st_size < 1024:
+        return False
+    try:
+        return get_videostream_metadata(str(path)).frames > 0
+    except Exception:
+        return False
+
+
+def build_pipeline(cfg: dict) -> VideoRefinerUpscalePipeline:
+    model_paths = cfg["model_paths"]
+    checkpoint_path = str(ROOT / model_paths["full_checkpoint"])
+    return VideoRefinerUpscalePipeline(
+        checkpoint_path=checkpoint_path,
+        distilled_lora=LoraPathStrengthAndSDOps(
+            path=str(ROOT / model_paths["distilled_lora"]),
+            strength=0.8,
+            sd_ops=LTXV_LORA_COMFY_RENAMING_MAP,
+        ),
+        spatial_upsampler_path=str(ROOT / model_paths["spatial_upsampler"]),
+        gemma_root=str(ROOT / model_paths["gemma_root"]),
+        quantization=_parse_quantization("none", checkpoint_path),
+        offload_mode=OffloadMode.CPU,
+    )
+
+
+def run_refiner_call(
+    *,
+    pipeline: VideoRefinerUpscalePipeline,
+    transformer: object,
+    input_video: Path,
+    output_video: Path,
+    run_id: str,
+    start_frame: int,
+    frames: int,
+    max_batch_size: int,
+) -> dict:
+    os.environ["LTX2_BENCHMARK_RUN_ID"] = run_id
+    t0 = time.perf_counter()
+    try:
+        input_shape, output_shape = pipeline(
+            input_video=str(input_video),
+            output_path=str(output_video),
+            prompt="high quality video, sharp details",
+            seed=10,
+            start_frame=start_frame,
+            max_frames=frames,
+            max_batch_size=max_batch_size,
+            transformer=transformer,
+        )
+        status = "success" if output_video.exists() else "failed"
+        record = {
+            "run_id": run_id,
+            "status": status,
+            "wall_seconds": time.perf_counter() - t0,
+            "input_video": rel(input_video),
+            "output_video": rel(output_video),
+            "start_frame": start_frame,
+            "frames": frames,
+            "input_shape": {
+                "width": input_shape.width,
+                "height": input_shape.height,
+                "frames": input_shape.frames,
+                "fps": input_shape.fps,
+            },
+            "output_shape": {
+                "width": output_shape.width,
+                "height": output_shape.height,
+                "frames": output_shape.frames,
+                "fps": output_shape.fps,
+            },
+        }
+    except Exception as exc:
+        record = {
+            "run_id": run_id,
+            "status": "failed",
+            "wall_seconds": time.perf_counter() - t0,
+            "input_video": rel(input_video),
+            "output_video": rel(output_video),
+            "start_frame": start_frame,
+            "frames": frames,
+            "error": repr(exc),
+        }
+    finally:
+        cleanup_memory()
+    append_manifest(record)
+    return record
+
+
+def process_video(
+    *,
+    index: int,
+    source: Path,
+    cfg: dict,
+    chunk_frames: int,
+    skip_existing: bool,
+) -> None:
+    stem = source.stem
+    pass1_final = OUTPUTS_DIR / "pass1_x2" / f"{stem}_x2.mp4"
+    pass2_final = OUTPUTS_DIR / "pass2_x4" / f"{stem}_x4.mp4"
+    if skip_existing and is_valid_video(pass2_final):
+        append_manifest(
+            {
+                "video_index": index,
+                "source_video": rel(source),
+                "pass1_output": rel(pass1_final),
+                "pass2_output": rel(pass2_final),
+                "status": "skipped_existing",
+                "mode": "chunked",
+            }
+        )
+        return
+
+    metadata = get_videostream_metadata(str(source))
+    spans = chunk_spans(metadata.frames, chunk_frames)
+    if not spans:
+        raise ValueError(f"No usable chunk spans for {source}")
+
+    pass1_dir = CHUNKS_DIR / "pass1_x2" / stem
+    pass2_dir = CHUNKS_DIR / "pass2_x4" / stem
+    pass1_dir.mkdir(parents=True, exist_ok=True)
+    pass2_dir.mkdir(parents=True, exist_ok=True)
+    pass1_chunks = [pass1_dir / f"{stem}_chunk{i:04d}_x2.mp4" for i in range(len(spans))]
+    pass2_chunks = [pass2_dir / f"{stem}_chunk{i:04d}_x4.mp4" for i in range(len(spans))]
+
+    append_manifest(
+        {
+            "video_index": index,
+            "source_video": rel(source),
+            "status": "started",
+            "mode": "chunked",
+            "chunk_frames": chunk_frames,
+            "chunks": len(spans),
+            "source_shape": {
+                "width": metadata.width,
+                "height": metadata.height,
+                "frames": metadata.frames,
+                "fps": metadata.fps,
+            },
+        }
+    )
+
+    needs_refine = not skip_existing or any(not is_valid_video(p) for p in [*pass1_chunks, *pass2_chunks])
+    if needs_refine:
+        os.environ["LTX2_BENCHMARK_PIPELINE"] = "videos_zip_two_refiners_chunked"
+        os.environ["LTX2_BENCHMARK_JSONL"] = str(OUTPUTS_DIR / "metrics" / "dit_metrics_chunked.jsonl")
+        pipeline = build_pipeline(cfg)
+        max_batch_size = int(cfg.get("max_batch_size", 1))
+
+        with pipeline.stage.model_context() as transformer:
+            for chunk_index, (start, frames) in enumerate(spans):
+                pass1_chunk = pass1_chunks[chunk_index]
+                pass2_chunk = pass2_chunks[chunk_index]
+                if not (skip_existing and is_valid_video(pass1_chunk)):
+                    record = run_refiner_call(
+                        pipeline=pipeline,
+                        transformer=transformer,
+                        input_video=source,
+                        output_video=pass1_chunk,
+                        run_id=f"{stem}_chunk{chunk_index:04d}_pass1_x2",
+                        start_frame=start,
+                        frames=frames,
+                        max_batch_size=max_batch_size,
+                    )
+                    if record["status"] != "success":
+                        raise RuntimeError(f"{record['run_id']} failed: {record.get('error')}")
+
+                if not (skip_existing and is_valid_video(pass2_chunk)):
+                    record = run_refiner_call(
+                        pipeline=pipeline,
+                        transformer=transformer,
+                        input_video=pass1_chunk,
+                        output_video=pass2_chunk,
+                        run_id=f"{stem}_chunk{chunk_index:04d}_pass2_x4",
+                        start_frame=0,
+                        frames=frames,
+                        max_batch_size=max_batch_size,
+                    )
+                    if record["status"] != "success":
+                        raise RuntimeError(f"{record['run_id']} failed: {record.get('error')}")
+
+    pass1_count = concat_videos(pass1_chunks, pass1_final, metadata.fps)
+    pass2_count = concat_videos(pass2_chunks, pass2_final, metadata.fps)
+    append_manifest(
+        {
+            "video_index": index,
+            "source_video": rel(source),
+            "pass1_output": rel(pass1_final),
+            "pass2_output": rel(pass2_final),
+            "status": "success",
+            "mode": "chunked",
+            "chunk_frames": chunk_frames,
+            "chunks": len(spans),
+            "pass1_frames": pass1_count,
+            "pass2_frames": pass2_count,
+        }
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--index", type=int, help="Process one extracted video index.")
+    parser.add_argument("--start-index", type=int, default=0)
+    parser.add_argument("--end-index", type=int)
+    parser.add_argument("--chunk-frames", type=int, default=65)
+    parser.add_argument("--skip-existing", action="store_true")
+    parser.add_argument("--continue-on-error", action="store_true")
+    args = parser.parse_args()
+
+    chunk_frames = _snap_frames_to_8k1(args.chunk_frames)
+    if chunk_frames != args.chunk_frames:
+        print(f"Adjusted chunk_frames from {args.chunk_frames} to {chunk_frames}")
+
+    cfg = load_config()
+    videos = extract_videos()
+    if args.index is not None:
+        selected = [(args.index, videos[args.index])]
+    else:
+        end = len(videos) - 1 if args.end_index is None else args.end_index
+        selected = list(enumerate(videos))[args.start_index : end + 1]
+
+    for index, source in selected:
+        try:
+            process_video(
+                index=index,
+                source=source,
+                cfg=cfg,
+                chunk_frames=chunk_frames,
+                skip_existing=args.skip_existing,
+            )
+        except Exception as exc:
+            append_manifest(
+                {
+                    "video_index": index,
+                    "source_video": rel(source),
+                    "status": "failed_or_incomplete",
+                    "mode": "chunked",
+                    "error": repr(exc),
+                }
+            )
+            if not args.continue_on_error:
+                raise
+
+
+if __name__ == "__main__":
+    main()