Sybilhhhhh commited on
Commit
6bbd2f0
Β·
verified Β·
1 Parent(s): 6b198d4

Upload compute_motion_score.py with huggingface_hub

Browse files
Files changed (1) hide show
  1. compute_motion_score.py +445 -0
compute_motion_score.py ADDED
@@ -0,0 +1,445 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #!/usr/bin/env python3
2
+ """
3
+ Estimate per-video motion scores using torchvision RAFT (Small) optical flow.
4
+
5
+ v2 β€” Cross-video mega-batching architecture:
6
+ - All frames resize to a FIXED resolution so frame-pairs from different
7
+ videos can be stacked into one large GPU batch.
8
+ - Multi-threaded decord decoding feeds a global pair queue.
9
+ - GPU pulls mega-batches (default 256 pairs) for maximum utilisation.
10
+ - Per-video scores are accumulated and flushed as each video completes.
11
+
12
+ Usage:
13
+ # Single GPU:
14
+ python compute_motion_score.py
15
+
16
+ # 8-way sharding across GPUs:
17
+ CUDA_VISIBLE_DEVICES=0 python compute_motion_score.py --num_shards 8 --shard_id 0
18
+ CUDA_VISIBLE_DEVICES=1 python compute_motion_score.py --num_shards 8 --shard_id 1
19
+ ...
20
+
21
+ Output:
22
+ One .duckdb per shard under --output_dir, table ``motion_scores``.
23
+ """
24
+
25
+ import argparse
26
+ import logging
27
+ import os
28
+ import time
29
+ import warnings
30
+ from queue import Queue
31
+ from threading import Thread
32
+
33
+ # Avoid CPU over-subscription: keep math backends single-threaded.
34
+ os.environ.setdefault("OMP_NUM_THREADS", "1")
35
+ os.environ.setdefault("MKL_NUM_THREADS", "1")
36
+ os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
37
+ os.environ.setdefault("NUMEXPR_NUM_THREADS", "1")
38
+ os.environ.setdefault("VECLIB_MAXIMUM_THREADS", "1")
39
+ os.environ.setdefault("BLIS_NUM_THREADS", "1")
40
+ os.environ.setdefault("TORCH_NUM_THREADS", "1")
41
+
42
+ import numpy as np
43
+ import torch
44
+ import torchvision.transforms.functional as TF
45
+ from torchvision.models.optical_flow import Raft_Small_Weights, raft_small
46
+
47
+ import duckdb
48
+ from decord import VideoReader
49
+ from decord import cpu as decord_cpu
50
+
51
+ warnings.filterwarnings("ignore", category=FutureWarning)
52
+
53
+ # ── paths ──────────────────────────────────────────────────────────────────
54
+ SOURCE_DB = "/opt/huawei/explorer-env/dataset/Vidgen_data_hyy/0327_bench/input_video_meta.duckdb"
55
+ OUTPUT_DIR = "/opt/huawei/explorer-env/dataset/Vidgen_data_hyy/0327_bench/motion_scores"
56
+ VIDEO_PREFIX = "/opt/huawei/explorer-env/"
57
+ RAFT_SMALL_CKPT = "/opt/huawei/explorer-env/dataset/Vidgen_data_hyy/models/raft_small_C_T_V2-01064c6d.pth"
58
+
59
+ # ── fixed resize target (β‰ˆ16:9, both divisible by 8) ──────────────────────
60
+ FIXED_H = 128
61
+ FIXED_W = 224
62
+
63
+
64
+ # ═══════════════════════════════════════════════════════════════════════════
65
+ # CLI
66
+ # ═══════════════════════════════════════════════════════════════════════════
67
+
68
+ def parse_args():
69
+ p = argparse.ArgumentParser(
70
+ description="Compute video motion scores via RAFT optical flow (mega-batch)"
71
+ )
72
+ # Sharding
73
+ p.add_argument("--num_shards", type=int, default=1)
74
+ p.add_argument("--shard_id", type=int, default=0)
75
+ # GPU
76
+ p.add_argument("--gpu_id", type=int, default=0)
77
+ # Sampling
78
+ p.add_argument("--sample_fps", type=float, default=2.0,
79
+ help="Temporal sampling rate (frames per second)")
80
+ p.add_argument("--max_duration", type=float, default=10.0,
81
+ help="Only use the first N seconds of each video")
82
+ # Resize
83
+ p.add_argument("--resize_h", type=int, default=FIXED_H)
84
+ p.add_argument("--resize_w", type=int, default=FIXED_W)
85
+ # Mega-batch (auto-capped based on resize dims to avoid cuDNN grid_sample limit)
86
+ p.add_argument("--mega_batch", type=int, default=0,
87
+ help="Frame-pairs per GPU forward (0 = auto-max based on resize dims)")
88
+ # Torch compile
89
+ p.add_argument("--compile", action="store_true",
90
+ help="torch.compile the model (adds ~30s startup, faster steady-state)")
91
+ # I/O parallelism
92
+ p.add_argument("--decode_workers", type=int, default=20,
93
+ help="Threads for video decoding")
94
+ p.add_argument("--prefetch", type=int, default=32,
95
+ help="Max decoded-video items buffered before GPU")
96
+ # Persistence
97
+ p.add_argument("--save_interval", type=int, default=500,
98
+ help="Flush results to DuckDB every N completed videos")
99
+ p.add_argument("--source_db", type=str, default=SOURCE_DB)
100
+ p.add_argument("--output_dir", type=str, default=OUTPUT_DIR)
101
+ p.add_argument("--video_prefix", type=str, default=VIDEO_PREFIX)
102
+ # Debug
103
+ p.add_argument("--max_videos", type=int, default=0,
104
+ help="Process at most N videos (0 = all)")
105
+ args = p.parse_args()
106
+
107
+ # Auto-compute mega_batch ceiling from cuDNN grid_sample limit.
108
+ # RAFT builds a correlation volume at 1/8 resolution; cuDNN's grid_sample
109
+ # requires B Γ— H_feat Γ— W_feat ≀ ~262144.
110
+ h_feat = args.resize_h // 8
111
+ w_feat = args.resize_w // 8
112
+ cudnn_safe_max = 262144 // (h_feat * w_feat)
113
+ if args.mega_batch <= 0:
114
+ args.mega_batch = cudnn_safe_max
115
+ elif args.mega_batch > cudnn_safe_max:
116
+ args.mega_batch = cudnn_safe_max
117
+
118
+ return args
119
+
120
+
121
+ # ═══════════════════════════════════════════════════════════════════════════
122
+ # DuckDB helpers
123
+ # ═══════════════════════════════════════════════════════════════════════════
124
+
125
+ def get_video_list(source_db: str, num_shards: int, shard_id: int) -> list:
126
+ con = duckdb.connect(source_db, read_only=True)
127
+ rows = con.execute(
128
+ "SELECT video_path FROM videos WHERE video_path IS NOT NULL ORDER BY video_path"
129
+ ).fetchall()
130
+ con.close()
131
+ return [r[0] for r in rows][shard_id::num_shards]
132
+
133
+
134
+ def get_processed_set(db_path: str) -> set:
135
+ if not os.path.exists(db_path):
136
+ return set()
137
+ con = duckdb.connect(db_path, read_only=True)
138
+ try:
139
+ rows = con.execute("SELECT video_path FROM motion_scores").fetchall()
140
+ except duckdb.CatalogException:
141
+ rows = []
142
+ con.close()
143
+ return {r[0] for r in rows}
144
+
145
+
146
+ def ensure_output_table(db_path: str):
147
+ con = duckdb.connect(db_path)
148
+ con.execute("""
149
+ CREATE TABLE IF NOT EXISTS motion_scores (
150
+ video_path VARCHAR PRIMARY KEY,
151
+ motion_score DOUBLE,
152
+ status VARCHAR,
153
+ num_frames_sampled INTEGER
154
+ )
155
+ """)
156
+ con.close()
157
+
158
+
159
+ def flush_results(db_path: str, results: list):
160
+ con = duckdb.connect(db_path)
161
+ con.executemany(
162
+ "INSERT OR REPLACE INTO motion_scores VALUES (?, ?, ?, ?)", results
163
+ )
164
+ con.close()
165
+
166
+
167
+ # ═══════════════════════════════════════════════════════════════════════════
168
+ # Video decoding (worker threads)
169
+ # ═══════════════════════════════════════════════════════════════════════════
170
+
171
+ def _decode_video(video_path: str, sample_fps: float,
172
+ max_duration: float, resize_h: int, resize_w: int):
173
+ """Decode β†’ sample β†’ fixed resize β†’ return (img1, img2) pair stacks.
174
+
175
+ Returns
176
+ -------
177
+ img1 : (P, 3, H, W) uint8 – first frames of each pair
178
+ img2 : (P, 3, H, W) uint8 – second frames of each pair
179
+ Or ``(None, None)`` when the video has fewer than 2 usable frames.
180
+ """
181
+ vr = VideoReader(video_path, ctx=decord_cpu(0), num_threads=1)
182
+ total = len(vr)
183
+ if total < 2:
184
+ return None, None
185
+
186
+ fps = vr.get_avg_fps()
187
+ max_frame = min(total, int(min(total / fps, max_duration) * fps))
188
+ step = max(1, round(fps / sample_fps))
189
+ indices = list(range(0, max_frame, step))
190
+ if len(indices) < 2:
191
+ indices = [0, min(max_frame - 1, total - 1)]
192
+
193
+ frames = vr.get_batch(indices)
194
+ frames = torch.as_tensor(frames.asnumpy()) # (N, H, W, C)
195
+ frames = frames.permute(0, 3, 1, 2) # (N, C, H, W)
196
+ frames = TF.resize(frames, [resize_h, resize_w], antialias=True)
197
+
198
+ return frames[:-1].contiguous(), frames[1:].contiguous()
199
+
200
+
201
+ _SENTINEL = "__SENTINEL__"
202
+
203
+
204
+ def _decoder_worker(task_q: Queue, result_q: Queue, video_prefix: str,
205
+ sample_fps: float, max_duration: float,
206
+ resize_h: int, resize_w: int):
207
+ while True:
208
+ vp = task_q.get()
209
+ if vp is None:
210
+ result_q.put(_SENTINEL)
211
+ break
212
+ full = os.path.join(video_prefix, vp)
213
+ try:
214
+ i1, i2 = _decode_video(full, sample_fps, max_duration,
215
+ resize_h, resize_w)
216
+ if i1 is None:
217
+ result_q.put((vp, None, None, "too_short"))
218
+ else:
219
+ result_q.put((vp, i1, i2, None))
220
+ except Exception as e:
221
+ result_q.put((vp, None, None, str(e)[:300]))
222
+
223
+
224
+ # ═══════════════════════════════════════════════════════════════════════════
225
+ # GPU mega-batch inference loop
226
+ # ═══════════════════════════════════════════════════════════════════════════
227
+
228
+ @torch.no_grad()
229
+ def gpu_loop(result_q: Queue, model, transforms, device: torch.device,
230
+ mega_batch: int, n_workers: int,
231
+ out_db: str, save_interval: int, log, total_todo: int):
232
+
233
+ # ── pair buffer (cross-video) ──
234
+ buf_vp: list[str] = []
235
+ buf_i1: list[torch.Tensor] = []
236
+ buf_i2: list[torch.Tensor] = []
237
+
238
+ # ── per-video accumulator: vp β†’ [sum_mag, count, expected, n_frames] ──
239
+ acc: dict[str, list] = {}
240
+
241
+ finished: list[tuple] = []
242
+ n_ok = n_err = n_short = 0
243
+ videos_received = 0
244
+ videos_done = 0
245
+ sentinels = 0
246
+ t0 = time.time()
247
+
248
+ # ------------------------------------------------------------------
249
+ def _forward_batch(vps, i1_list, i2_list):
250
+ """Stack, transfer, infer, accumulate."""
251
+ nonlocal n_ok, videos_done
252
+
253
+ i1 = torch.stack(i1_list)
254
+ i2 = torch.stack(i2_list)
255
+ i1, i2 = transforms(i1, i2)
256
+ i1 = i1.pin_memory().to(device, non_blocking=True)
257
+ i2 = i2.pin_memory().to(device, non_blocking=True)
258
+
259
+ flow = model(i1, i2)[-1] # (B, 2, H, W)
260
+
261
+ mags = flow.norm(dim=1).mean(dim=(1, 2)) # (B,)
262
+ mags_cpu = mags.cpu()
263
+
264
+ for j, vp in enumerate(vps):
265
+ a = acc[vp]
266
+ a[0] += mags_cpu[j].item()
267
+ a[1] += 1
268
+ if a[1] == a[2]:
269
+ score = a[0] / a[2]
270
+ finished.append((vp, round(score, 4), "ok", a[3]))
271
+ del acc[vp]
272
+ n_ok += 1
273
+ videos_done += 1
274
+
275
+ def _drain_buffer():
276
+ """Process all full mega-batches sitting in the buffer."""
277
+ nonlocal buf_vp, buf_i1, buf_i2
278
+ while len(buf_vp) >= mega_batch:
279
+ _forward_batch(buf_vp[:mega_batch],
280
+ buf_i1[:mega_batch],
281
+ buf_i2[:mega_batch])
282
+ buf_vp = buf_vp[mega_batch:]
283
+ buf_i1 = buf_i1[mega_batch:]
284
+ buf_i2 = buf_i2[mega_batch:]
285
+
286
+ def _log_progress():
287
+ elapsed = time.time() - t0
288
+ speed = videos_done / elapsed if elapsed > 0 else 0
289
+ eta_h = (total_todo - videos_done) / speed / 3600 if speed > 0 else float("inf")
290
+ log.info(
291
+ f"Progress {videos_done}/{total_todo} ({100*videos_done/total_todo:.1f}%) | "
292
+ f"ok={n_ok} err={n_err} short={n_short} | "
293
+ f"{speed:.1f} vid/s | ETA {eta_h:.1f}h | "
294
+ f"buf={len(buf_vp)} pending_videos={len(acc)}"
295
+ )
296
+
297
+ # ── main consumer loop ────────────────────────────────────────────
298
+ while sentinels < n_workers:
299
+ item = result_q.get()
300
+
301
+ # sentinel ---
302
+ if item is _SENTINEL:
303
+ sentinels += 1
304
+ continue
305
+
306
+ vp, i1, i2, err = item
307
+ videos_received += 1
308
+
309
+ if err is not None:
310
+ if err == "too_short":
311
+ finished.append((vp, 0.0, "too_short", 0))
312
+ n_short += 1
313
+ else:
314
+ finished.append((vp, -1.0, f"error:{err}", 0))
315
+ n_err += 1
316
+ videos_done += 1
317
+ else:
318
+ n_pairs = i1.shape[0]
319
+ n_frames = n_pairs + 1
320
+ acc[vp] = [0.0, 0, n_pairs, n_frames]
321
+ for k in range(n_pairs):
322
+ buf_vp.append(vp)
323
+ buf_i1.append(i1[k])
324
+ buf_i2.append(i2[k])
325
+ _drain_buffer()
326
+
327
+ # periodic flush & log
328
+ if len(finished) >= save_interval:
329
+ flush_results(out_db, finished)
330
+ finished.clear()
331
+ _log_progress()
332
+
333
+ # ── tail: flush remaining pairs in buffer ─────────────────────────
334
+ if buf_vp:
335
+ _forward_batch(buf_vp, buf_i1, buf_i2)
336
+ buf_vp, buf_i1, buf_i2 = [], [], []
337
+
338
+ if finished:
339
+ flush_results(out_db, finished)
340
+ finished.clear()
341
+
342
+ elapsed = time.time() - t0
343
+ speed = videos_done / elapsed if elapsed > 0 else 0
344
+ log.info(
345
+ f"Finished: {videos_done} videos in {elapsed/3600:.2f}h | "
346
+ f"ok={n_ok} err={n_err} short={n_short} | {speed:.1f} vid/s"
347
+ )
348
+
349
+
350
+ # ═══════════════════════════════════════════════════════════════════════════
351
+ # Main
352
+ # ═══════════════════════════════════════════════════════════════════════════
353
+
354
+ def main():
355
+ args = parse_args()
356
+ torch.set_num_threads(1)
357
+ torch.set_num_interop_threads(1)
358
+
359
+ log = logging.getLogger(f"shard-{args.shard_id}")
360
+ log.setLevel(logging.INFO)
361
+ h = logging.StreamHandler()
362
+ h.setFormatter(logging.Formatter(
363
+ f"%(asctime)s [shard {args.shard_id}/{args.num_shards}] %(levelname)s: %(message)s",
364
+ datefmt="%Y-%m-%d %H:%M:%S",
365
+ ))
366
+ log.addHandler(h)
367
+ log.propagate = False
368
+
369
+ os.makedirs(args.output_dir, exist_ok=True)
370
+ out_db = os.path.join(
371
+ args.output_dir, f"motion_scores_shard{args.shard_id:04d}.duckdb"
372
+ )
373
+
374
+ # 1. Video list & resume ------------------------------------------------
375
+ log.info("Loading video list …")
376
+ shard_videos = get_video_list(args.source_db, args.num_shards, args.shard_id)
377
+ log.info(f"Videos in shard: {len(shard_videos)}")
378
+
379
+ ensure_output_table(out_db)
380
+ done = get_processed_set(out_db)
381
+ todo = [v for v in shard_videos if v not in done]
382
+ if args.max_videos > 0:
383
+ todo = todo[: args.max_videos]
384
+ log.info(f"Already done: {len(done)}, remaining: {len(todo)}")
385
+ if not todo:
386
+ log.info("Nothing to process – exiting.")
387
+ return
388
+
389
+ # 2. Model --------------------------------------------------------------
390
+ device = torch.device(f"cuda:{args.gpu_id}")
391
+ weights = Raft_Small_Weights.DEFAULT
392
+ model = raft_small(weights=None)
393
+ model.load_state_dict(
394
+ torch.load(RAFT_SMALL_CKPT, map_location="cpu", weights_only=True)
395
+ )
396
+ model = model.to(device).eval()
397
+ if args.compile:
398
+ log.info("torch.compile … (one-time, may take ~30 s)")
399
+ model = torch.compile(model, mode="reduce-overhead")
400
+ transforms = weights.transforms()
401
+ log.info(
402
+ f"RAFT-Small on {device} | mega_batch={args.mega_batch} | "
403
+ f"resize={args.resize_h}Γ—{args.resize_w} | compile={args.compile}"
404
+ )
405
+
406
+ # 3. Decoder threads ----------------------------------------------------
407
+ task_q: Queue = Queue(maxsize=args.prefetch * 2)
408
+ result_q: Queue = Queue(maxsize=args.prefetch)
409
+
410
+ workers = []
411
+ for _ in range(args.decode_workers):
412
+ t = Thread(
413
+ target=_decoder_worker, daemon=True,
414
+ args=(task_q, result_q, args.video_prefix,
415
+ args.sample_fps, args.max_duration,
416
+ args.resize_h, args.resize_w),
417
+ )
418
+ t.start()
419
+ workers.append(t)
420
+
421
+ def _feeder():
422
+ for vp in todo:
423
+ task_q.put(vp)
424
+ for _ in range(args.decode_workers):
425
+ task_q.put(None)
426
+
427
+ Thread(target=_feeder, daemon=True).start()
428
+
429
+ # 4. GPU mega-batch loop ------------------------------------------------
430
+ gpu_loop(
431
+ result_q, model, transforms, device,
432
+ mega_batch=args.mega_batch,
433
+ n_workers=args.decode_workers,
434
+ out_db=out_db,
435
+ save_interval=args.save_interval,
436
+ log=log,
437
+ total_todo=len(todo),
438
+ )
439
+
440
+ for t in workers:
441
+ t.join(timeout=5)
442
+
443
+
444
+ if __name__ == "__main__":
445
+ main()