hkust-aaron's picture
Add annotated sample pack: quality, timeline, clip captions, keyframe masks (v1/v2), SAM 3.1 dense tracks
07f5340 verified
Raw History Blame Contribute Delete
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)