Datasets:
Add annotated sample pack: quality, timeline, clip captions, keyframe masks (v1/v2), SAM 3.1 dense tracks
07f5340 verified Download annotated/scripts/08_sam31_propagate.py from hkust-aaron/laparoscopic-robotic-vision-sample: direct link, hf CLI and curl.
- Browser
- Download file 8.62 kB
-
https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/08_sam31_propagate.py
- Command line
-
hf download hf://datasets/hkust-aaron/laparoscopic-robotic-vision-sample/annotated/scripts/08_sam31_propagate.py
-
curl -L -o 08_sam31_propagate.py https://huggingface.co/datasets/hkust-aaron/laparoscopic-robotic-vision-sample/resolve/main/annotated/scripts/08_sam31_propagate.py
8.62 kB
| """Dense instance tracks for the whole video with SAM 3.1 (runs on a CUDA machine). | |
| Usage: | |
| python 08_sam31_propagate.py extract <video> <frames_root> | |
| python 08_sam31_propagate.py run <frames_root> <instances_coco_v2.json> <checkpoint.pt> <out_dir> <clip_ids> | |
| clip_ids: "all", "3", "0-9" or "0,5,7"; append ":i/n" to take the clips with id % n == i | |
| Each clip (250 source frames; the last has 120) is one SAM 3.1 session, run the | |
| way the official video example does it: | |
| 1. text prompt TEXT on frame 0, then full propagation. The detector+tracker | |
| finds and follows instruments anywhere in the clip ("text" tracks). | |
| 2. the clip's annotated keyframe (its middle frame) gets three positive clicks | |
| per object from instances_coco_v2.json, then propagation in both directions | |
| ("click" tracks). These carry the appearance class and also cover gauze, | |
| which the text prompt does not find. | |
| Click-only prompting returns masks on the keyframe alone, because the pipeline | |
| merges click results into the text pass; hence step 1 always runs first. | |
| Where a click track and a text track cover the same pixels the model keeps the | |
| click track. A text track that lay on a clicked instrument in the keyframe (at | |
| least half of its pixels) is treated as the same object and dropped for the whole | |
| clip; masks under MIN_AREA pixels are dropped. Track ids are local to a clip: | |
| click tracks 101.. (100 + keyframe instance index), text tracks 1.. (model id + 1). | |
| Outputs per clip: masks/clip_XX/<source frame>.png (pixel value = track id, | |
| 0 = background) and tracks/clip_XX.json (per-track class, source, per-frame | |
| area / bbox / score). | |
| """ | |
| import json | |
| import sys | |
| import time | |
| from pathlib import Path | |
| import cv2 | |
| import numpy as np | |
| CLIP, TOTAL, W, H = 250, 17370, 720, 576 | |
| TEXT, MIN_AREA = "metal tool", 150 | |
| mode = sys.argv[1] | |
| if mode == "extract": | |
| video, root = sys.argv[2], Path(sys.argv[3]) | |
| cap = cv2.VideoCapture(video) | |
| i = 0 | |
| while True: | |
| ok, f = cap.read() | |
| if not ok: | |
| break | |
| d = root / f"clip_{i // CLIP:02d}" | |
| if i % CLIP == 0: | |
| d.mkdir(parents=True, exist_ok=True) | |
| cv2.imwrite(str(d / f"{i % CLIP:05d}.jpg"), f, [cv2.IMWRITE_JPEG_QUALITY, 95]) | |
| i += 1 | |
| print("frames written", i) | |
| sys.exit(0 if i == TOTAL else 1) | |
| root, coco_path, ckpt, out_dir, spec = Path(sys.argv[2]), sys.argv[3], sys.argv[4], Path(sys.argv[5]), sys.argv[6] | |
| n_clips = (TOTAL + CLIP - 1) // CLIP | |
| shard = None | |
| if ":" in spec: | |
| spec, sh = spec.split(":") | |
| shard = tuple(int(x) for x in sh.split("/")) | |
| if spec == "all": | |
| clips = list(range(n_clips)) | |
| elif "-" in spec: | |
| a, b = spec.split("-") | |
| clips = list(range(int(a), int(b) + 1)) | |
| else: | |
| clips = [int(x) for x in spec.split(",")] | |
| if shard: | |
| clips = [c for c in clips if c % shard[1] == shard[0]] | |
| coco = json.load(open(coco_path)) | |
| cat = {c["id"]: c["name"] for c in coco["categories"]} | |
| by_frame = {} | |
| for a in coco["annotations"]: | |
| by_frame.setdefault(a["image_id"], []).append(a) | |
| import torch # noqa: E402 | |
| from sam3.model_builder import build_sam3_multiplex_video_predictor # noqa: E402 | |
| predictor = build_sam3_multiplex_video_predictor(checkpoint_path=ckpt, use_fa3=False, async_loading_frames=False) | |
| # Upstream start_session passes a keyword the SAM 3.1 init_state does not accept; drop it. | |
| _init_state = predictor.model.init_state | |
| predictor.model.init_state = lambda **kw: _init_state(**{k: v for k, v in kw.items() if k != "offload_state_to_cpu"}) | |
| (out_dir / "masks").mkdir(parents=True, exist_ok=True) | |
| (out_dir / "tracks").mkdir(parents=True, exist_ok=True) | |
| def propagate(sid, **kw): | |
| frames = {} | |
| for resp in predictor.handle_stream_request(dict(type="propagate_in_video", session_id=sid, **kw)): | |
| o = resp["outputs"] | |
| ids = [int(i) for i in np.asarray(o["out_obj_ids"]).reshape(-1)] | |
| masks = np.asarray(o["out_binary_masks"]) | |
| probs = np.asarray(o["out_probs"]).reshape(-1) | |
| frames[int(resp["frame_index"])] = { | |
| i: (masks[k].reshape(masks.shape[-2], masks.shape[-1]).astype(np.uint8), float(probs[k])) | |
| for k, i in enumerate(ids)} | |
| return frames | |
| for c in clips: | |
| t0 = time.time() | |
| start = c * CLIP | |
| n = min(TOTAL, start + CLIP) - start | |
| key_src = 17310 if c == n_clips - 1 else start + CLIP // 2 | |
| key_local = key_src - start | |
| anns = by_frame.get(key_src, []) | |
| mdir = out_dir / "masks" / f"clip_{c:02d}" | |
| mdir.mkdir(exist_ok=True) | |
| meta = {"clip_id": c, "start_frame": start, "num_frames": n, "keyframe_source_index": key_src, | |
| "model": "SAM 3.1 (sam3.1_multiplex.pt)", "text_prompt": TEXT, "tracks": {}, "status": "ok"} | |
| per_frame, text_key = {}, {} | |
| sid = predictor.handle_request(dict(type="start_session", resource_path=str(root / f"clip_{c:02d}")))["session_id"] | |
| try: | |
| predictor.handle_request(dict(type="add_prompt", session_id=sid, frame_index=0, text=TEXT)) | |
| per_frame = propagate(sid) | |
| text_key = {mid + 1: v[0] for mid, v in per_frame.get(key_local, {}).items()} | |
| if anns: | |
| for a in anns: | |
| tid = 100 + a["instance_index_in_mask_png"] | |
| meta["tracks"][tid] = {"source": "click", "category": cat[a["category_id"]], | |
| "keyframe_confidence": a["confidence"], | |
| "keyframe_needs_review": a["needs_review"], "clicks": a["sam31_clicks"], | |
| "frames": {}} | |
| predictor.handle_request(dict( | |
| type="add_prompt", session_id=sid, frame_index=key_local, obj_id=tid, | |
| points=[[x / W, y / H] for x, y in a["sam31_clicks"]], point_labels=[1] * len(a["sam31_clicks"]))) | |
| per_frame = propagate(sid, propagation_direction="both", start_frame_index=key_local) | |
| except Exception as e: # record and keep going with the other clips | |
| meta["status"] = f"failed: {type(e).__name__}: {str(e)[:200]}" | |
| predictor.handle_request(dict(type="close_session", session_id=sid)) | |
| torch.cuda.empty_cache() | |
| # A text track that sat on a clicked instrument in the keyframe is the same object: drop it. | |
| duplicates = set() | |
| if anns and meta["status"] == "ok": | |
| clicked = np.zeros((H, W), bool) | |
| for mid, (m, _) in per_frame.get(key_local, {}).items(): | |
| if mid >= 100 and meta["tracks"][mid]["category"] != "gauze": | |
| clicked |= m.astype(bool) | |
| for tid, m in text_key.items(): | |
| if m.sum() and (m.astype(bool) & clicked).sum() / m.sum() >= 0.5: | |
| duplicates.add(tid) | |
| meta["text_tracks_dropped_as_duplicates"] = sorted(duplicates) | |
| def order_key(tid): # gauze first, then text tracks, click instruments on top | |
| t = meta["tracks"][tid] | |
| return (t["category"] != "gauze", t["source"] == "click") | |
| for t in range(n): | |
| for mid in per_frame.get(t, {}): | |
| tid = mid if mid >= 100 else mid + 1 | |
| if tid not in meta["tracks"] and tid not in duplicates: | |
| meta["tracks"][tid] = {"source": "text", "category": "instrument_text_detected", "frames": {}} | |
| for t in range(n): | |
| inst = np.zeros((H, W), np.uint8) | |
| got_t = {(mid if mid >= 100 else mid + 1): v for mid, v in per_frame.get(t, {}).items()} | |
| got_t = {k: v for k, v in got_t.items() if k not in duplicates} | |
| for tid in sorted(got_t, key=order_key): | |
| m, score = got_t[tid] | |
| if m.shape != (H, W): | |
| m = cv2.resize(m, (W, H), interpolation=cv2.INTER_NEAREST) | |
| if m.sum() < MIN_AREA: | |
| continue | |
| inst[m == 1] = tid | |
| for tid in np.unique(inst)[1:]: | |
| ys, xs = np.nonzero(inst == tid) | |
| if len(xs) < MIN_AREA: | |
| inst[inst == tid] = 0 | |
| continue | |
| meta["tracks"][int(tid)]["frames"][start + t] = { | |
| "area": int(len(xs)), "score": round(got_t[int(tid)][1], 3), | |
| "bbox": [int(xs.min()), int(ys.min()), int(xs.max() - xs.min() + 1), int(ys.max() - ys.min() + 1)]} | |
| cv2.imwrite(str(mdir / f"{start + t:05d}.png"), inst) | |
| meta["tracks"] = {k: v for k, v in meta["tracks"].items() if v["frames"]} | |
| meta["seconds"] = round(time.time() - t0, 1) | |
| json.dump(meta, open(out_dir / "tracks" / f"clip_{c:02d}.json", "w")) | |
| print(f"clip {c:02d} {meta['status']} keyframe_objs={len(anns)} " | |
| f"tracks={[(k, v['source'][0], len(v['frames'])) for k, v in meta['tracks'].items()]} sec={meta['seconds']}", | |
| flush=True) | |