#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Inference script for Qwen2.5-VL with token selection + insertion for PVSG/VIDOR data. Key behaviors per user spec: - Videos to evaluate are the ones that have a folder under `structured_json_root/{video_name}/`. - Mask file per video: `{mask_root}/{video_name}_rle.json` (List[List[RLE]]). - Only select objects that have a corresponding `{structured_json_root}/{video_name}/object_{id}.json`. - Randomly sample up to `--max_objects` (default 20) objects from the above eligible set (with fixed seed). - Record which object ids were sampled for each video. - Build obj_masks (O, N, H_rz, W_rz) and run `select_tokens_fast` to get indices. - Insert selected tokens with `rearrange_token` and run generation. - Save outputs per video: the decoded text and a sidecar JSON recording sampled objects + metadata. This script intentionally avoids reading each object_{id}.json contents; it only checks their existence. """ import os import re import json import math import argparse import random from dataclasses import dataclass from typing import List, Tuple, Optional, Dict, Any import glob import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from transformers import AutoProcessor, AutoTokenizer from transformers.modeling_outputs import ModelOutput from transformers.processing_utils import Unpack from transformers.models.qwen2_5_vl.configuration_qwen2_5_vl import ( Qwen2_5_VLConfig, Qwen2_5_VLTextConfig, Qwen2_5_VLVisionConfig ) from transformers.models.qwen2_5_vl.modeling_qwen2_5_vl import ( Qwen2_5_VLForConditionalGeneration, Qwen2_5_VLModel ) from transformers.models.idefics2.modeling_idefics2 import Idefics2PerceiverResampler from transformers.models.idefics2.configuration_idefics2 import Idefics2PerceiverConfig from qwen_vl_vsg_utils.src.qwen_vl_utils import process_vision_info from resampler_utils.token_selection import select_tokens from resampler_utils.token_arrangement import rearrange_token from pycocotools import mask as maskUtils def find_video_path(video_root, video_name): pattern = os.path.join(video_root, f"{video_name}.[mM][pP]4") matches = glob.glob(pattern) if not matches: raise FileNotFoundError(f"No MP4 file found for {video_name} in {video_root}") return matches[0] # ----------------------------- # Model wrapper with rope_deltas passthrough (as provided) # ----------------------------- @dataclass class TRASEROutput(ModelOutput): loss: Optional[torch.FloatTensor] = None logits: Optional[torch.FloatTensor] = None past_key_values: Optional[List[torch.FloatTensor]] = None hidden_states: Optional[Tuple[torch.FloatTensor]] = None attentions: Optional[Tuple[torch.FloatTensor]] = None rope_deltas: Optional[torch.LongTensor] = None class TRASER(Qwen2_5_VLForConditionalGeneration): def __init__(self, config: Qwen2_5_VLConfig, **kwargs): super().__init__(config) for k, v in kwargs.items(): print(f"Keyword arg: {k} = {v}") if not hasattr(config, k): print(f" - Adding attribute {k} to config with value {v}") setattr(config, k, v) self.config = config self._build_perceiver(dtype=config.torch_dtype, attn_impl=config._attn_implementation) self.post_init() def _build_perceiver(self, dtype: torch.dtype, attn_impl: str) -> None: h = int(getattr(self.config, "hidden_size", 2048)) n_latents = int(getattr(self.config, "temporal_resampler_n_latents", 64)) depth = int(getattr(self.config, "resampler_depth", 3)) perceiver_cfg = Idefics2PerceiverConfig( hidden_size=h, resampler_n_latents=n_latents, resampler_depth=depth, _attn_implementation=attn_impl, torch_dtype=dtype, ) self.perceiver_resampler = Idefics2PerceiverResampler(perceiver_cfg) if getattr(self.config, "object_resampler", True): second_n_latents = int(getattr(self.config, "object_resampler_n_latents", 32)) second_perceiver_cfg = Idefics2PerceiverConfig( hidden_size=h, resampler_n_latents=second_n_latents, resampler_depth=depth, _attn_implementation=attn_impl, torch_dtype=dtype, ) self.second_perceiver_resampler = Idefics2PerceiverResampler(second_perceiver_cfg) def prepare_inputs_for_generation( self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, cache_position=None, position_ids=None, use_cache=True, pixel_values=None, pixel_values_videos=None, image_grid_thw=None, video_grid_thw=None, second_per_grid_ts=None, **kwargs, ): model_inputs = super().prepare_inputs_for_generation( input_ids, past_key_values=past_key_values, attention_mask=attention_mask, inputs_embeds=inputs_embeds, cache_position=cache_position, position_ids=position_ids, pixel_values=pixel_values, pixel_values_videos=pixel_values_videos, image_grid_thw=image_grid_thw, video_grid_thw=video_grid_thw, second_per_grid_ts=second_per_grid_ts, use_cache=use_cache, **kwargs, ) model_inputs["position_ids"] = position_ids if cache_position is not None and cache_position[0] != 0: model_inputs["pixel_values"] = None model_inputs["pixel_values_videos"] = None model_inputs["position_ids"] = None return model_inputs def forward( self, input_ids: Optional[torch.LongTensor] = None, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, past_key_values: Optional[List[torch.FloatTensor]] = None, inputs_embeds: Optional[torch.FloatTensor] = None, labels: Optional[torch.LongTensor] = None, use_cache: Optional[bool] = None, output_attentions: Optional[bool] = None, output_hidden_states: Optional[bool] = None, cache_position: Optional[torch.LongTensor] = None, rope_deltas: Optional[torch.LongTensor] = None, **kwargs: Unpack[Any], ) -> TRASEROutput: output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states if rope_deltas is not None: self.model.rope_deltas = rope_deltas is_prefill = (inputs_embeds is not None) and ( past_key_values is None or (hasattr(past_key_values, "get_seq_length") and past_key_values.get_seq_length() == 0) ) if is_prefill: outputs = self.model.language_model( input_ids=None, inputs_embeds=inputs_embeds, position_ids=position_ids, attention_mask=attention_mask, past_key_values=past_key_values, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, cache_position=cache_position, return_dict=True, ) else: inputs_embeds = self.model.get_input_embeddings()(input_ids) batch_size, seq_length, _ = inputs_embeds.shape delta = ( (cache_position[0] + self.model.rope_deltas).to(inputs_embeds.device) if cache_position is not None else 0 ) pos = torch.arange(seq_length, device=inputs_embeds.device).view(1, -1).expand(batch_size, -1) if cache_position is not None: delta = delta.repeat_interleave(max(1, batch_size // delta.shape[0]), dim=0) pos = pos.add(delta).unsqueeze(0).expand(3, -1, -1) outputs = self.model.language_model( input_ids=None, position_ids=pos, attention_mask=attention_mask, past_key_values=past_key_values, inputs_embeds=inputs_embeds, use_cache=use_cache, output_attentions=output_attentions, output_hidden_states=output_hidden_states, cache_position=cache_position, **kwargs, ) hidden_states = outputs.last_hidden_state logits = self.lm_head(hidden_states) loss = None if labels is not None: loss = self.loss_function(logits=logits, labels=labels, vocab_size=self.config.vocab_size) return TRASEROutput( loss=loss, logits=logits, past_key_values=outputs.past_key_values, hidden_states=outputs.hidden_states, attentions=outputs.attentions, rope_deltas=self.model.rope_deltas, ) def set_seed(seed: int): random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) def list_video_names(structured_json_root: str, dataset_subset: str = "vidor", meta_data : str = None, eval: bool = False) -> List[str]: """List directory names under structured_json_root as video names.""" if not os.path.isdir(structured_json_root): raise FileNotFoundError(f"structured_json_root not found: {structured_json_root}") names = [d for d in os.listdir(structured_json_root) if os.path.isdir(os.path.join(structured_json_root, d))] if dataset_subset.lower() == "vidor": # Filter to only those that look like VIDOR video ids, looks like 0001_xxxxxx....x.json names = [n for n in names if re.match(r"^\d{4}_[a-z0-9]+$", n)] if eval: with open(meta_data, "r") as f: meta = json.load(f) eval_list = meta['split']['vidor']['val'] names = [n for n in names if n in eval_list] elif dataset_subset.lower() == 'epic_kitchen': names = [n for n in names if re.match(r"^P\d{2}_\d{2}$", n)] if eval: with open(meta_data, "r") as f: meta = json.load(f) eval_list = meta['split']['epic_kitchen']['val'] names = [n for n in names if n in eval_list] elif dataset_subset.lower() == "ego4d": pattern = re.compile(r"^[0-9a-f\-]+(?:_\d+)?$", re.IGNORECASE) names = [n for n in names if pattern.match(n)] if eval: with open(meta_data, "r") as f: meta = json.load(f) eval_list = meta['split']['ego4d']['val'] names = [n for n in names if n in eval_list] elif dataset_subset.lower() == "all": if eval: with open(meta_data, "r") as f: meta = json.load(f) eval_list = [] for ds in ['vidor', 'epic_kitchen', 'ego4d']: eval_list.extend(meta['split'][ds]['val']) names = [n for n in names if n in eval_list] else: raise NotImplementedError("Other dataset support is not implemented.") names.sort() return names def available_object_ids(video_struct_dir: str) -> List[int]: """Return object ids that have object_{id}.json in the given dir.""" ids = [] if not os.path.isdir(video_struct_dir): return ids for fn in os.listdir(video_struct_dir): m = re.match(r"object_(\d+)\.json$", fn) if m: ids.append(int(m.group(1))) ids.sort() return ids def load_mask_data(mask_json_path: str): """Load mask data: expected to be List[List[Optional[RLE]]].""" if not os.path.isfile(mask_json_path): raise FileNotFoundError(mask_json_path) with open(mask_json_path, "r") as f: data = json.load(f) return data def has_any_mask(mask_data, obj_id: int) -> bool: """Check if any frame has a non-empty RLE for this object index.""" for frame in mask_data: if not frame: continue if obj_id < 0 or obj_id >= len(frame): continue rle = frame[obj_id] if rle: # A minimal sanity: counts present and non-empty if isinstance(rle, dict) and rle.get("counts"): return True return False def build_obj_masks_tensor( mask_data, obj_ids: List[int], sampled_idx: List[int], H_rz: int, W_rz: int, device: torch.device, ) -> Tuple[torch.Tensor, List[int]]: O = len(obj_ids) N = len(sampled_idx) obj_masks = torch.zeros((O, N, H_rz, W_rz), dtype=torch.float32, device=device) for o_i, oid in enumerate(obj_ids): for n_idx, fidx in enumerate(sampled_idx): if fidx < 0 or fidx >= len(mask_data): continue frame_objs = mask_data[fidx] if frame_objs is None or oid < 0 or oid >= len(frame_objs): continue rle = frame_objs[oid] if not rle: continue m = maskUtils.decode({"size": rle["size"], "counts": rle["counts"]}) if m.ndim == 3: m = m[:, :, 0] m_t = torch.from_numpy(m.astype(np.uint8)).unsqueeze(0).unsqueeze(0).float().to(device) m_rz = F.interpolate(m_t, size=(H_rz, W_rz), mode="nearest")[0, 0] obj_masks[o_i, n_idx] = (m_rz > 0.5).to(torch.float32) keep_idx = (obj_masks.view(O, -1).sum(dim=1) > 0).nonzero(as_tuple=False).squeeze(1).tolist() if len(keep_idx) == 0: raise RuntimeError("All objects have empty masks after aligning to sampled frames.") if len(keep_idx) < O: obj_masks = obj_masks[keep_idx] return obj_masks, keep_idx # ----------------------------- # Inference core # ----------------------------- def run_single_video( model, processor, video_path: str, mask_path: str, video_struct_dir: str, out_dir: str, device: torch.device, *, max_objects: int = 40, rng: random.Random = random.Random(42), spatial_merge_size: int = 2, temporal_patch_size: int = 2, coverage_thresh: float = 0.7, obj_traj_start_id: Optional[int] = None, obj_traj_end_id: Optional[int] = None, do_sample: bool = False, temperature: float = 0.7, top_p: float = 0.9, max_new_tokens: int = 512, repetition_penalty: float = 1.05, system_prompt: Optional[str] = None, messages_text: Optional[List[Dict]] = None, temporal_window_length: float = 4.0, training_fps: float = 1.0, ) -> Dict: """ Process a single video and return a dict of results. Also writes artifacts to disk. """ os.makedirs(out_dir, exist_ok=True) # 0) Check resources if not os.path.isfile(video_path): raise FileNotFoundError(f"Video file not found: {video_path}") if not os.path.isfile(mask_path): raise FileNotFoundError(f"Mask json not found: {mask_path}") if not os.path.isdir(video_struct_dir): raise FileNotFoundError(f"struct json dir not found: {video_struct_dir}") # 1) Determine eligible object ids (existence + has any mask), then sample up to max_objects mask_data = load_mask_data(mask_path) all_ids = available_object_ids(video_struct_dir) eligible = [oid for oid in all_ids if has_any_mask(mask_data, oid)] if len(eligible) == 0: raise RuntimeError(f"No eligible objects with masks for video dir: {video_struct_dir}") if len(eligible) > max_objects: rng.shuffle(eligible) selected_obj_ids = sorted(eligible[:max_objects]) else: selected_obj_ids = sorted(eligible) # 2) Prepare processor inputs # Build messages and prompt if system_prompt is None: system_prompt = ( "You are a helpful assistant." ) messages = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": [{"type": "video", "video": video_path}]}, ] if messages_text is None else [ {"role": "system", "content": system_prompt}, {"role": "user", "content":[ {"type": "text", "text": messages_text}, {"type": "video", "video": video_path} ]} ] print("Messages:", messages) prompt_text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) image_inputs, video_inputs, selected_frame_fps, selected_frame_idx = process_vision_info(messages, return_video_kwargs = True) print("selected_frame_fps:", selected_frame_fps) proc_inputs = processor( text=[prompt_text], images=image_inputs, videos=video_inputs, padding=True, return_tensors="pt", fps=1, ).to(model.device) # proc_inputs = processor(text=[prompt_text], videos=[video_path], return_tensors="pt") # Move to device input_ids = proc_inputs["input_ids"].to(device) attention_mask = proc_inputs["attention_mask"].to(device) pixel_values_videos = proc_inputs.get("pixel_values_videos", None) # if pixel_values_videos is not None: # pixel_values_videos = pixel_values_videos.to(device, dtype=model.dtype) video_grid_thw = proc_inputs.get("video_grid_thw", None) if video_grid_thw is None: raise RuntimeError("processor did not return 'video_grid_thw'") # Normalize to tensor of shape [B, 3] or [3] if isinstance(video_grid_thw, (list, tuple)): video_grid_thw = [torch.as_tensor(v, device=device) for v in video_grid_thw] video_grid_thw = torch.stack(video_grid_thw, dim=0) else: video_grid_thw = video_grid_thw.to(device) # For single video we expect shape [1, 3] if video_grid_thw.dim() == 1: video_grid = video_grid_thw else: video_grid = video_grid_thw[0] T, H_patch, W_patch = int(video_grid[0].item()), int(video_grid[1].item()), int(video_grid[2].item()) sec_per_window = torch.arange(0, T) * ((1 / int(training_fps) * 2)) per_timestamp_idx_batch = [[v.item() for v in sec_per_window]] patch_size = getattr(getattr(processor, "video_processor", None), "patch_size", 14) H_rz, W_rz = H_patch * patch_size, W_patch * patch_size # 3) Build obj_masks for selected objects sampled_idx = selected_frame_idx[0] if isinstance(selected_frame_idx, list) and len(selected_frame_idx) > 0 and isinstance(selected_frame_idx[0], list) else selected_frame_idx obj_masks, keep_idx= build_obj_masks_tensor(mask_data, selected_obj_ids, sampled_idx, H_rz, W_rz, device=device) selected_obj_ids = [selected_obj_ids[j] for j in keep_idx] # 4) Select tokens for these objects per_union_idx, per_obj_idx, _per_obj_cover = select_tokens( obj_masks=obj_masks, grid_thw=(T, H_patch, W_patch), patch_size=patch_size, spatial_merge_size=spatial_merge_size, temporal_patch_size=temporal_patch_size, coverage_thresh=coverage_thresh, device=device, ) # 5) Prepare insertion (we only need per_obj_idx for this sample) per_obj_idx_batch = [per_obj_idx] # B=1 list of list-of-tensors text_token_ids_per_sample = None label_template = "Object {i}: " text_token_ids_per_sample = [] max_len = 0 for per_obj_idx in per_obj_idx_batch: O = len(per_obj_idx) additional_texts = [label_template.format(i=(k + 1)) for k in range(O)] if len(additional_texts) == 0: text_token_ids_per_sample.append([]) continue enc = processor.tokenizer( additional_texts, add_special_tokens=False, return_attention_mask=False, return_token_type_ids=False, )["input_ids"] # per_sample_ids = [torch.tensor(x, dtype=torch.long, device=input_ids.device) for x in enc] per_sample_ids = [torch.tensor(x, dtype=torch.long) for x in enc] text_token_ids_per_sample.append(per_sample_ids) grids_per_temporal_window = int(temporal_window_length / (1.0 / training_fps)) / 2 # e.g., 4s window @ 1fps / merge_size → 2 grids timestamp_token_ids_per_batch = [] grids_per_temporal_window_per_batch = [] assert processor.tokenizer is not None for per_timestamp_idx in per_timestamp_idx_batch: temporal_window_num = math.ceil(len(per_timestamp_idx) / grids_per_temporal_window) temporal_text_list = [] for w_id in range(temporal_window_num): start_time = w_id * temporal_window_length end_time = start_time + temporal_window_length temporal_text_list.append(f"<{int(start_time)} - {int(end_time)} sec>") enc = processor.tokenizer( temporal_text_list, add_special_tokens=False, return_attention_mask=False, return_token_type_ids=False, )["input_ids"] timestamp_token_ids_per_batch.append([torch.tensor(x) for x in enc]) grids_per_temporal_window_per_batch.append(int(grids_per_temporal_window)) with torch.no_grad(): new_emb, new_pid, new_mask, rope_deltas, cache_pos, new_input_ids, new_labels = rearrange_token( model=model, input_ids=input_ids, attention_mask=attention_mask, pixel_values_videos=pixel_values_videos, video_grid_thw=video_grid_thw, image_grid_thw=None, pixel_values=None, second_per_grid_ts=None, obj_token_indices_per_sample=per_obj_idx_batch, obj_traj_start_id=obj_traj_start_id, obj_traj_end_id=obj_traj_end_id, use_resampler=True, text_token_ids_per_sample=text_token_ids_per_sample, timestamp_token_ids_per_batch=timestamp_token_ids_per_batch, grids_per_temporal_window_per_batch=grids_per_temporal_window_per_batch, labels=None, ) new_mask=new_mask.to(torch.long) # 6) Generate gen_out = model.generate( inputs_embeds=new_emb, position_ids=new_pid, attention_mask=new_mask, rope_deltas=rope_deltas, max_new_tokens=max_new_tokens, do_sample=do_sample, use_cache=True, temperature=temperature if do_sample else None, top_p=top_p if do_sample else None, repetition_penalty=repetition_penalty, return_dict_in_generate=True, ) sequences = gen_out.sequences # [1, L_in + L_gen] # Only decode generated part in_len = new_emb.shape[1] gen_tokens = sequences[0] decoded = processor.tokenizer.decode(gen_tokens, skip_special_tokens=True) # 7) Write artifacts video_name = os.path.splitext(os.path.basename(video_path))[0] out_txt = os.path.join(out_dir, f"{video_name}_gen.txt") out_meta = os.path.join(out_dir, f"{video_name}_meta.json") with open(out_txt, "w", encoding="utf-8") as f: f.write(decoded.strip()) meta = { "video_name": video_name, "video_path": video_path, "mask_path": mask_path, "structured_json_dir": video_struct_dir, "selected_object_ids": selected_obj_ids, "T_H_W": [T, H_patch, W_patch], "patch_size": patch_size, "spatial_merge_size": spatial_merge_size, "temporal_patch_size": temporal_patch_size, "coverage_thresh": coverage_thresh, "do_sample": do_sample, "max_new_tokens": max_new_tokens, "per_obj_idx_len": [int(x.numel()) for x in per_obj_idx] } with open(out_meta, "w", encoding="utf-8") as f: json.dump(meta, f, ensure_ascii=False, indent=2) return { "decoded": decoded, "meta": meta, "out_txt": out_txt, "out_meta": out_meta, "per_obj_idx_len": [int(x.numel()) for x in per_obj_idx], } # ----------------------------- # CLI # ----------------------------- def main(): parser = argparse.ArgumentParser(description="Inference for PVSG/VIDOR with token selection & insertion.") parser.add_argument("--model_path", type=str, required=True, help="Path to finetuned Qwen2.5-VL checkpoint.") parser.add_argument("--structured_json_root", type=str, required=False, help="Root dir of structured_json/{video_name}/",default="/weka-train/royg/pvsg/object_descriptions") parser.add_argument("--mask_root", type=str, required=False, help="Root dir of masks, with {video}_rle.json files.", default = "/weka-train/royg/pvsg/pvsg_rle_json") parser.add_argument("--video_root", type=str, required=False, help="Root dir of raw videos, {video}.mp4",default = "/weka-train/jamesp/data/PVSG_dataset/vidor/videos") parser.add_argument("--meta_data", type=str, required=False, help="Path of meta data,", default="/weka-train/jamesp/data/PVSG_dataset/pvsg.json") parser.add_argument("--eval", type=bool, required=False, help="Whether to run evaluation splits.", default=True) parser.add_argument("--out_dir", type=str, required=False, help="Output directory to save generations + metadata.", default="/weka/royg/vsg_train/Qwen2.5-VL/pvsg_resampler_output") parser.add_argument("--dataset_subset", type=str, default="vidor", help="Dataset subset to evaluate.") parser.add_argument("--temporal_window_length", type=float, default=4.0, help="Temporal window length in seconds for timestamp text anchors.") parser.add_argument("--training_fps", type=float, default=1.0, help="Frames per second for training.") parser.add_argument("--max_objects", type=int, default=40, help="Max objects to sample per video (<=40).") parser.add_argument("--seed", type=int, default=42, help="Random seed for sampling.") parser.add_argument("--dtype", type=str, default="bfloat16", choices=["float16", "bfloat16", "float32"], help="Model dtype.") parser.add_argument("--device", type=str, default="cuda", help="Device like 'cuda' or 'cuda:0' or 'cpu'.") parser.add_argument("--limit_videos", type=int, default=None, help="Optional limit on number of videos.") parser.add_argument("--start_from", type=int, default=0, help="Start index offset for listing videos.") parser.add_argument("--coverage_thresh", type=float, default=0.5) parser.add_argument("--spatial_merge_size", type=int, default=2) parser.add_argument("--temporal_patch_size", type=int, default=2) parser.add_argument("--obj_traj_start_id", type=int, default=151665) parser.add_argument("--obj_traj_end_id", type=int, default=151666) parser.add_argument("--max_new_tokens", type=int, default=16384) parser.add_argument("--do_sample", action="store_true", default=True) parser.add_argument("--temperature", type=float, default=1e-6) parser.add_argument("--top_p", type=float, default=0.9) parser.add_argument("--repetition_penalty", type=float, default=1.05) args = parser.parse_args() # Device & dtype device = torch.device(args.device if torch.cuda.is_available() or args.device == "cpu" else "cpu") dtype_map = {"float16": torch.float16, "bfloat16": torch.bfloat16, "float32": torch.float32} dt = dtype_map[args.dtype] # Enumerate videos by folders under structured_json_root if "," in args.dataset_subset: dataset_subsets = args.dataset_subset.split(",") video_names = [] for ds in dataset_subsets: video_names += list_video_names(args.structured_json_root, dataset_subset=ds, meta_data=args.meta_data, eval=args.eval) video_names = sorted(list(set(video_names))) else: video_names = list_video_names(args.structured_json_root, dataset_subset=args.dataset_subset, meta_data=args.meta_data, eval=args.eval) print(f"Total videos: {len(video_names)}") if args.start_from > 0: video_names = video_names[args.start_from:] if args.limit_videos is not None: video_names = video_names[: args.limit_videos] set_seed(args.seed) processor = AutoProcessor.from_pretrained("Qwen/Qwen2.5-VL-3B-Instruct") model = TRASER.from_pretrained( args.model_path, torch_dtype=dt, device_map=None ).to(device) tokenizer = AutoTokenizer.from_pretrained(args.model_path) processor.tokenizer = tokenizer rng = random.Random(args.seed) os.makedirs(args.out_dir, exist_ok=True) args.out_dir = os.path.join(args.out_dir, os.path.basename(os.path.dirname(args.model_path)), os.path.basename(args.model_path)) os.makedirs(args.out_dir, exist_ok=True) messages_text = "Output the video Scene Graph from the video and object trajectories:\n" index_path = os.path.join(args.out_dir, "index.jsonl") with open(index_path, "a", encoding="utf-8") as index_f: print(">>> writing index to:", index_path) for vi, video_name in enumerate(video_names): # try: if os.path.exists(os.path.join(args.out_dir, f"{video_name}_gen.txt")): print(f"[SKIP] {video_name}: already processed") continue video_struct_dir = os.path.join(args.structured_json_root, video_name) mask_path = os.path.join(args.mask_root, f"{video_name}_rle.json") # video file could be nested; user said direct: {video_root}/{video_name}.mp4 video_path = find_video_path(args.video_root, video_name) result = run_single_video( model=model, processor=processor, video_path=video_path, mask_path=mask_path, video_struct_dir=video_struct_dir, out_dir=args.out_dir, device=device, max_objects=args.max_objects, rng=rng, spatial_merge_size=args.spatial_merge_size, temporal_patch_size=args.temporal_patch_size, coverage_thresh=args.coverage_thresh, obj_traj_start_id=args.obj_traj_start_id, obj_traj_end_id=args.obj_traj_end_id, do_sample=args.do_sample, temperature=args.temperature, top_p=args.top_p, max_new_tokens=args.max_new_tokens, repetition_penalty=args.repetition_penalty, messages_text=messages_text, temporal_window_length=args.temporal_window_length, training_fps=args.training_fps, ) # Append to index rec = { "video_name": video_name, "out_txt": result["out_txt"], "out_meta": result["out_meta"], "selected_object_count": len(result["meta"]["selected_object_ids"]), "per_obj_selected_token_counts": result["per_obj_idx_len"], } index_f.write(json.dumps(rec, ensure_ascii=False) + "\n") index_f.flush() print(f"[{vi+1}/{len(video_names)}] done: {video_name} -> {result['out_txt']}") if __name__ == "__main__": main()