Upload 3 files

filter_ci_vid_samples.py

@@ -0,0 +1,250 @@
+import os
+import re
+import json
+import math
+import time
+import subprocess
+import itertools
+import concurrent.futures
+from collections import OrderedDict
+from typing import Optional, List, Dict, Any, Tuple
+
+split = "train"      # train, test
+DATA_ROOT = "/workspace/ci_vid_chunk0"  # 按你的实际路径修改
+IN_JSONL = os.path.join(DATA_ROOT, f"CI-VID_{split}_samples.jsonl")
+OUT_JSONL = os.path.join(DATA_ROOT, f"CI-VID_{split}_samples_SC.jsonl")
+
+MAX_SHOTS = 4
+MIN_AVG_DUR = 0.0   # seconds
+MIN_SHOT_DUR = 3.0  # seconds
+MAX_SHOT_DUR = 7.0  # seconds
+PRINT_EVERY = 500   # 进度打印频率（行）
+MAX_WORKERS = 64    # 并发线程数，推荐为 CPU 核心数的 2-4 倍
+CHUNK_SIZE = 5000   # 每次从文件读取的批次大小，防止大文件 OOM
+
+
+def ffprobe_duration_sec(video_path: str) -> Optional[float]:
+    """Return duration in seconds using ffprobe, or None if failed."""
+    try:
+        p = subprocess.run(
+            [
+                "ffprobe",
+                "-v", "error",
+                "-show_entries", "format=duration",
+                "-of", "default=noprint_wrappers=1:nokey=1",
+                video_path,
+            ],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=False,
+        )
+        if p.returncode != 0:
+            return None
+        s = p.stdout.strip()
+        if not s:
+            return None
+        dur = float(s)
+        if math.isnan(dur) or dur <= 0:
+            return None
+        return dur
+    except Exception:
+        return None
+
+
+def list_mp4s_sorted(video_dir: str) -> List[str]:
+    """List mp4s in a directory, sorted by numeric filename (0.mp4,1.mp4,...) when possible."""
+    if not os.path.isdir(video_dir):
+        return []
+    files = [f for f in os.listdir(video_dir) if f.lower().endswith(".mp4")]
+
+    def key_fn(name: str):
+        m = re.match(r"(\d+)\.mp4$", name)
+        return (0, int(m.group(1))) if m else (1, name)
+
+    files.sort(key=key_fn)
+    return [os.path.join(video_dir, f) for f in files]
+
+
+def count_nonempty_lines(path: str) -> int:
+    n = 0
+    with open(path, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                n += 1
+    return n
+
+
+def reorder_for_output(
+    row: Dict[str, Any],
+    shot_count: int,
+    durs: List[float],
+    avg_dur: float,
+    mp4_count_found: int,
+    video_dir_abs: str,
+) -> OrderedDict:
+    """
+    Output key order:
+    1) video_path
+    2) shot_count, avg_shot_duration_sec, shot_durations_sec, mp4_count_found, video_dir_abs
+    3) other original keys (excluding video_path, individual_captions, joint_captions)
+    4) individual_captions, joint_captions at the end
+    """
+    out = OrderedDict()
+    out["video_path"] = row.get("video_path")
+
+    # new keys right after video_path
+    out["shot_count"] = shot_count
+    out["avg_shot_duration_sec"] = avg_dur
+    out["shot_durations_sec"] = durs
+    out["mp4_count_found"] = mp4_count_found
+    out["video_dir_abs"] = video_dir_abs
+
+    # keep other keys (stable order as they appeared in row)
+    for k, v in row.items():
+        if k in ("video_path", "individual_captions", "joint_captions"):
+            continue
+        out[k] = v
+
+    # captions at the very end
+    if "individual_captions" in row:
+        out["individual_captions"] = row["individual_captions"]
+    if "joint_captions" in row:
+        out["joint_captions"] = row["joint_captions"]
+
+    return out
+
+
+def process_line(line: str) -> Tuple[Optional[OrderedDict], bool, str]:
+    """
+    处理单行 JSONL 数据。
+    返回: (处理后的行字典/None, 是否通过 MAX_SHOTS 检查, 状态标签)
+    """
+    line = line.strip()
+    if not line:
+        return None, False, "empty"
+
+    try:
+        row: Dict[str, Any] = json.loads(line)
+    except json.JSONDecodeError:
+        return None, False, "json_fail"
+
+    indiv = row.get("individual_captions", [])
+    if not isinstance(indiv, list):
+        return None, False, "format_fail"
+
+    shot_count = len(indiv)
+    if shot_count > MAX_SHOTS:
+        return None, False, "len_gt_4"
+    
+    # 只要 shot_count <= MAX_SHOTS，就将其计入 len_le_4
+    is_len_le_4 = True
+
+    video_path = row.get("video_path")
+    if not isinstance(video_path, str):
+        return None, is_len_le_4, "format_fail"
+
+    video_dir = os.path.join(DATA_ROOT, video_path)
+    if not os.path.isdir(video_dir):
+        return None, is_len_le_4, "missing_dir"
+
+    mp4s = list_mp4s_sorted(video_dir)
+    if not mp4s:
+        return None, is_len_le_4, "missing_mp4"
+
+    # mp4数一般应等于 shot_count；稳妥起见取 min
+    n = min(shot_count, len(mp4s))
+    durs: List[float] = []
+    
+    for p in mp4s[:n]:
+        dur = ffprobe_duration_sec(p)
+        if dur is None:
+            return None, is_len_le_4, "duration_fail"
+        durs.append(dur)
+
+    if not durs:
+        return None, is_len_le_4, "duration_fail"
+
+    if any(d <= MIN_SHOT_DUR for d in durs):
+            return None, is_len_le_4, "dur_too_short"
+
+    avg_dur = sum(durs) / len(durs)
+    if avg_dur <= MIN_AVG_DUR:
+        return None, is_len_le_4, "dur_too_short"
+
+    out_row = reorder_for_output(
+        row=row,
+        shot_count=shot_count,
+        durs=durs,
+        avg_dur=avg_dur,
+        mp4_count_found=len(mp4s),
+        video_dir_abs=video_dir,
+    )
+    return out_row, is_len_le_4, "kept"
+
+
+def main():
+    total_lines = count_nonempty_lines(IN_JSONL)
+
+    total = 0
+    len_le_4 = 0
+    kept = 0
+    missing_dir = 0
+    missing_mp4 = 0
+    duration_fail = 0
+    json_fail = 0
+
+    t_start = time.time()
+
+    with open(IN_JSONL, "r", encoding="utf-8") as fin, \
+         open(OUT_JSONL, "w", encoding="utf-8") as fout, \
+         concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        
+        while True:
+            # 分批读取，防止大文件吃光内存
+            lines = list(itertools.islice(fin, CHUNK_SIZE))
+            if not lines:
+                break
+            
+            # map 会保持结果顺序与输入顺序完全一致
+            results = executor.map(process_line, lines)
+            
+            for out_row, is_len_le_4, status in results:
+                if status == "empty":
+                    continue
+                
+                total += 1
+                
+                # 按照你的原始逻辑处理各项计数
+                if is_len_le_4:
+                    len_le_4 += 1
+                
+                if status == "json_fail":
+                    json_fail += 1
+                elif status == "missing_dir":
+                    missing_dir += 1
+                elif status == "missing_mp4":
+                    missing_mp4 += 1
+                elif status == "duration_fail":
+                    duration_fail += 1
+                elif status == "kept":
+                    fout.write(json.dumps(out_row, ensure_ascii=False) + "\n")
+                    kept += 1
+
+                # progress
+                if total == 1 or total % PRINT_EVERY == 0 or total == total_lines:
+                    elapsed = time.time() - t_start
+                    speed = total / elapsed if elapsed > 0 else 0.0
+                    pct = (total / total_lines * 100.0) if total_lines > 0 else 0.0
+                    print(
+                        f"[{total}/{total_lines} | {pct:.1f}%] kept={kept} "
+                        f"len<=4={len_le_4} missing_dir={missing_dir} missing_mp4={missing_mp4} "
+                        f"dur_fail={duration_fail} json_fail={json_fail} speed={speed:.1f} lines/s"
+                    )
+
+    print("Done.")
+    print(f"Output: {OUT_JSONL}")
+
+
+if __name__ == "__main__":
+    main()

move_ci_vid_samples.py

@@ -0,0 +1,109 @@
+import os
+import json
+import shutil
+import time
+import concurrent.futures
+
+split = "train"       # train, test
+# 配置路径
+OLD_ROOT = "/workspace/ci_vid_chunk0"
+NEW_ROOT = f"/workspace/ci_vid_SC_{split}"
+JSONL_FILE = os.path.join(OLD_ROOT, f"CI-VID_{split}_samples_SC.jsonl")
+
+# 线程数（仅做路径和元数据操作，不需要太大）
+MAX_WORKERS = 16
+PRINT_EVERY = 100
+
+def move_video_dir(line: str) -> str:
+    """
+    解析 JSONL 单行，将对应的视频文件夹移动到新目录。
+    返回状态字符串用于统计。
+    """
+    line = line.strip()
+    if not line:
+        return "empty"
+
+    try:
+        row = json.loads(line)
+    except json.JSONDecodeError:
+        return "json_fail"
+
+    video_rel_path = row.get("video_path")
+    if not isinstance(video_rel_path, str):
+        return "format_fail"
+
+    old_dir = os.path.join(OLD_ROOT, video_rel_path)
+    new_dir = os.path.join(NEW_ROOT, video_rel_path)
+
+    # 如果原目录不存在，可能之前已经被移动过，或者数据有误
+    if not os.path.isdir(old_dir):
+        # 顺便检查是不是已经移到了新目录
+        if os.path.isdir(new_dir):
+            return "already_moved"
+        return "missing_old"
+
+    # 确保新目录的父级结构存在 (例如创建 chunk_33/00d2d19dd524c7f7ccaadba657c49263)
+    parent_new_dir = os.path.dirname(new_dir)
+    os.makedirs(parent_new_dir, exist_ok=True)
+
+    try:
+        # 移动整个文件夹
+        # shutil.move(old_dir, new_dir)
+        shutil.copytree(old_dir, new_dir, dirs_exist_ok=True)
+        return "success"
+    except Exception as e:
+        # 捕捉权限不足或其他异常
+        return f"error"
+
+def main():
+    if not os.path.exists(JSONL_FILE):
+        print(f"找不到 JSONL 文件: {JSONL_FILE}")
+        return
+
+    # 统计总行数用于显示进度
+    total_lines = sum(1 for line in open(JSONL_FILE, "r", encoding="utf-8") if line.strip())
+    print(f"共发现 {total_lines} 条待处理记录。开始移动...\n")
+
+    stats = {
+        "success": 0,
+        "already_moved": 0,
+        "missing_old": 0,
+        "error": 0,
+        "json_fail": 0,
+        "format_fail": 0,
+        "empty": 0
+    }
+
+    t_start = time.time()
+    processed = 0
+
+    with open(JSONL_FILE, "r", encoding="utf-8") as fin:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+            # 提交所有任务
+            futures = [executor.submit(move_video_dir, line) for line in fin]
+            
+            # 收集结果
+            for future in concurrent.futures.as_completed(futures):
+                status = future.result()
+                stats[status] += 1
+                processed += 1
+                
+                # 打印进度
+                if processed % PRINT_EVERY == 0 or processed == total_lines:
+                    elapsed = time.time() - t_start
+                    speed = processed / elapsed if elapsed > 0 else 0.0
+                    pct = (processed / total_lines) * 100
+                    print(
+                        f"[{processed}/{total_lines} | {pct:.1f}%] "
+                        f"成功: {stats['success']} | 已移动: {stats['already_moved']} | "
+                        f"缺失: {stats['missing_old']} | 报错: {stats['error']} | "
+                        f"速度: {speed:.1f} 个/秒"
+                    )
+
+    print("\n移动完成！统计结果：")
+    for k, v in stats.items():
+        if v > 0:
+            print(f"- {k}: {v}")
+
+if __name__ == "__main__":
+    main()