| |
| """Full-parameter Qwen3-VL SFT for the existing four-round HanDyVQA JSONL. |
| |
| No model or GPU is needed for --check-data. See --help and the SFT section |
| in README.md. Optional dependencies are imported only when needed. |
| """ |
| import argparse |
| from collections import Counter, OrderedDict |
| import hashlib |
| import json |
| import math |
| from pathlib import Path |
|
|
|
|
| STAGES = ("recog", "caption", "track", "answer") |
|
|
|
|
| def read_data(filename, video_root=None): |
| source = Path(filename).resolve() |
| root = Path(video_root).resolve() if video_root else source.parent |
| rows, seen = [], set() |
| for line_no, line in enumerate(source.read_text(encoding="utf-8").splitlines(), 1): |
| if not line.strip(): |
| continue |
| try: |
| row = json.loads(line) |
| for key in ("system", "instruction", "input", "output"): |
| if not isinstance(row.get(key), str) or not row[key].strip(): |
| raise ValueError(f"{key} must be a nonempty string") |
| history = row.get("history") |
| if not isinstance(history, list) or len(history) not in range(4): |
| raise ValueError("history must contain 0 to 3 pairs") |
| for pair in history: |
| if (not isinstance(pair, list) or len(pair) != 2 |
| or any(not isinstance(s, str) or not s.strip() for s in pair)): |
| raise ValueError("history entries must be two nonempty strings") |
| stage = STAGES[len(history)] |
| if stage == "answer": |
| target = tagged_json(row["output"], "answer") |
| if (type(target.get("answer")) is not int or target["answer"] < 0 |
| or not isinstance(target.get("report"), str) |
| or type(target.get("confidence")) not in (int, float) |
| or not 0 <= target["confidence"] <= 1): |
| raise ValueError("Invalid accepted answer target") |
| else: |
| target = tagged_json(row["output"], "tool") |
| if target.get("name") != stage or not isinstance(target.get("arguments"), dict): |
| raise ValueError(f"Expected a {stage} tool target") |
| path = Path(row["input"]) |
| path = (root / path).resolve() if not path.is_absolute() else path.resolve() |
| if not path.exists(): |
| raise ValueError(f"Missing visual input: {path}") |
| row["input"] = str(path) |
| identity = (row["input"], row["system"], row["instruction"], len(history)) |
| if identity in seen: |
| raise ValueError("Duplicate question/round") |
| seen.add(identity) |
| row["_stage"] = stage |
| row["_source"] = f"{source}:{line_no}" |
| rows.append(row) |
| except (ValueError, TypeError, KeyError, AttributeError) as exc: |
| raise ValueError(f"{source}:{line_no}: {exc}") from exc |
| if not rows: |
| raise ValueError(f"Empty dataset: {source}") |
| return rows |
|
|
|
|
| def tagged_json(text, tag): |
| start, end = f"<{tag}>", f"</{tag}>" |
| if text.count(start) != 1 or text.count(end) != 1: |
| raise ValueError(f"Expected exactly one {tag} block") |
| value = json.loads(text.split(start, 1)[1].split(end, 1)[0]) |
| if not isinstance(value, dict): |
| raise ValueError(f"{tag} must contain a JSON object") |
| return value |
|
|
|
|
| def audit(rows): |
| groups = {} |
| for row in rows: |
| key = (row["input"], row["system"], row["instruction"]) |
| groups.setdefault(key, {})[len(row["history"])] = row |
| for group in groups.values(): |
| if set(group) != set(range(4)): |
| raise ValueError("Each question must have all four rounds in the same split") |
| for index in range(1, 4): |
| previous, current = group[index - 1], group[index] |
| if (current["history"][:-1] != previous["history"] |
| or current["history"][-1][0] != previous["output"]): |
| raise ValueError(f"Inconsistent trajectory at {current['_source']}") |
| return {"rows": len(rows), "questions": len(groups), |
| "visual_inputs": len({r["input"] for r in rows}), |
| "stages": dict(Counter(r["_stage"] for r in rows))} |
|
|
|
|
| def check_split_overlap(train, validation): |
| for key in ("input", "question_id", "video_id", "narration_uid"): |
| left = {r[key] for r in train if r.get(key) is not None} |
| right = {r[key] for r in validation if r.get(key) is not None} |
| if left & right: |
| raise ValueError(f"Training/validation overlap in {key}") |
|
|
|
|
| def frame_indices(count, source_fps, sample_fps, max_frames): |
| if count < 1 or not math.isfinite(source_fps) or source_fps <= 0: |
| raise ValueError("Cannot sample input with unknown frame count or FPS") |
| |
| wanted = min(count, max_frames, max(2, math.ceil((count - 1) / source_fps * sample_fps) + 1)) |
| if wanted == 1: |
| return [0] |
| return sorted({round(i * (count - 1) / (wanted - 1)) for i in range(wanted)}) |
|
|
|
|
| class FrameLoader: |
| def __init__(self, fps=2.0, max_frames=16, max_pixels=262144, cache_size=2, directory_fps=None): |
| self.fps, self.max_frames, self.max_pixels = fps, max_frames, max_pixels |
| self.cache_size, self.directory_fps = cache_size, directory_fps |
| self.cache = OrderedDict() |
|
|
| def __call__(self, filename): |
| from PIL import Image |
| if filename in self.cache: |
| self.cache.move_to_end(filename) |
| return self.cache[filename] |
| path = Path(filename) |
| frames = [] |
|
|
| def bounded(image): |
| image = image.convert("RGB") |
| scale = min(1.0, math.sqrt(self.max_pixels / (image.width * image.height))) |
| if scale < 1: |
| image = image.resize((max(1, int(image.width * scale)), |
| max(1, int(image.height * scale))), Image.Resampling.LANCZOS) |
| return image |
|
|
| if path.is_dir(): |
| import re |
| if not self.directory_fps: |
| raise ValueError("Frame directories require --directory-fps") |
| files = sorted((p for p in path.iterdir() if p.suffix.lower() in |
| {".jpg", ".jpeg", ".png", ".bmp"}), |
| key=lambda p: [int(s) if s.isdigit() else s.lower() |
| for s in re.split(r"(\d+)", p.name)]) |
| indices = frame_indices(len(files), self.directory_fps, self.fps, self.max_frames) |
| for index in indices: |
| with Image.open(files[index]) as image: |
| frames.append(bounded(image)) |
| else: |
| import cv2 |
| cap = cv2.VideoCapture(str(path)) |
| try: |
| if not cap.isOpened(): |
| raise ValueError(f"Cannot open video: {path}") |
| indices = frame_indices(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), |
| cap.get(cv2.CAP_PROP_FPS), self.fps, self.max_frames) |
| for index in indices: |
| cap.set(cv2.CAP_PROP_POS_FRAMES, index) |
| ok, frame = cap.read() |
| if not ok: |
| raise ValueError(f"Cannot decode frame {index}: {path}") |
| frames.append(bounded(Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)))) |
| finally: |
| cap.release() |
| if self.cache_size: |
| self.cache[filename] = frames |
| while len(self.cache) > self.cache_size: |
| self.cache.popitem(last=False) |
| return frames |
|
|
|
|
| def messages_for(row, frames): |
| messages = [{"role": "system", "content": [{"type": "text", "text": row["system"]}]}, |
| {"role": "user", "content": [{"type": "image", "image": frame} for frame in frames] |
| + [{"type": "text", "text": row["instruction"]}]}] |
| for assistant, observation in row["history"]: |
| messages.extend([{"role": "assistant", "content": [{"type": "text", "text": assistant}]}, |
| {"role": "user", "content": [{"type": "text", "text": observation}]}]) |
| return messages |
|
|
|
|
| def output_labels(full, prefix): |
| """Use attention masks, not pad token IDs: EOS can share the pad ID.""" |
| import torch |
| labels = torch.full_like(full["input_ids"], -100) |
| for i in range(len(labels)): |
| positions = full["attention_mask"][i].bool().nonzero(as_tuple=True)[0] |
| full_ids = full["input_ids"][i, positions] |
| prefix_ids = prefix["input_ids"][i, prefix["attention_mask"][i].bool()] |
| size = len(prefix_ids) |
| if size >= len(full_ids) or not torch.equal(full_ids[:size], prefix_ids): |
| raise ValueError("Chat template prefix mismatch or empty target; refusing incorrect loss masking") |
| labels[i, positions[size:]] = full_ids[size:] |
| return labels |
|
|
|
|
| class HandyVQACollator: |
| def __init__(self, processor, loader, max_length=8192): |
| self.processor, self.loader, self.max_length = processor, loader, max_length |
|
|
| def __call__(self, features): |
| full_texts, prefix_texts, images = [], [], [] |
| for row in features: |
| frames = self.loader(row["input"]) |
| if not frames: |
| raise ValueError(f"No images for {row['_source']}") |
| messages = messages_for(row, frames) |
| prefix_texts.append(self.processor.apply_chat_template( |
| messages, tokenize=False, add_generation_prompt=True)) |
| messages = messages + [{"role": "assistant", "content": [{"type": "text", "text": row["output"]}]}] |
| full_texts.append(self.processor.apply_chat_template( |
| messages, tokenize=False, add_generation_prompt=False)) |
| images.extend(frames) |
| |
| |
| full = self.processor(text=full_texts, images=images, padding=True, |
| truncation=False, return_tensors="pt") |
| lengths = full["attention_mask"].sum(dim=1).tolist() |
| for row, length in zip(features, lengths): |
| if length > self.max_length: |
| raise ValueError(f"{row['_source']}: {length} tokens > {self.max_length}; " |
| "reduce --max-frames/--max-pixels or use shorter evidence") |
| prefix = self.processor(text=prefix_texts, images=images, padding=True, |
| truncation=False, return_tensors="pt") |
| full["labels"] = output_labels(full, prefix) |
| return full |
|
|
|
|
| def parse_args(): |
| p = argparse.ArgumentParser(description=__doc__) |
| p.add_argument("--train-data", required=True) |
| p.add_argument("--eval-data", help="Separate, four-round distilled validation JSONL") |
| p.add_argument("--video-root", help="Base for relative input paths; default: each JSONL directory") |
| p.add_argument("--model", help="Local Qwen3-VL model path or HF model ID; fill before training") |
| p.add_argument("--output-dir", help="New local training directory; fill before training") |
| p.add_argument("--check-data", action="store_true", help="Validate data only; no ML dependencies") |
| p.add_argument("--dry-run", action="store_true", help="Check all batches with processor; no model weights") |
| p.add_argument("--local-files-only", action="store_true") |
| p.add_argument("--sample-fps", type=float, default=2.0) |
| p.add_argument("--max-frames", type=int, default=16) |
| p.add_argument("--min-pixels", type=int, default=4096) |
| p.add_argument("--max-pixels", type=int, default=262144) |
| p.add_argument("--max-length", type=int, default=8192) |
| p.add_argument("--directory-fps", type=float, help="FPS of pre-extracted frame directories") |
| p.add_argument("--frame-cache-size", type=int, default=2, help="Videos cached per worker/rank") |
| p.add_argument("--batch-size", type=int, default=1) |
| p.add_argument("--grad-accum", type=int, default=8) |
| p.add_argument("--epochs", type=float, default=1.0) |
| p.add_argument("--learning-rate", type=float, default=5e-6) |
| p.add_argument("--warmup-ratio", type=float, default=0.03) |
| p.add_argument("--weight-decay", type=float, default=0.01) |
| p.add_argument("--precision", choices=("bf16", "fp16", "fp32"), default="bf16") |
| p.add_argument("--attention", choices=("sdpa", "eager", "flash_attention_2"), default="sdpa") |
| p.add_argument("--workers", type=int, default=0) |
| p.add_argument("--save-steps", type=int, default=100) |
| p.add_argument("--eval-steps", type=int, default=100) |
| p.add_argument("--logging-steps", type=int, default=10) |
| p.add_argument("--save-total-limit", type=int, default=2) |
| p.add_argument("--seed", type=int, default=42) |
| p.add_argument("--resume-from-checkpoint", help="Explicit Trainer checkpoint directory") |
| p.add_argument("--deepspeed", help="Optional DeepSpeed config JSON; select for your GPUs") |
| args = p.parse_args() |
| for name in ("sample_fps", "max_frames", "min_pixels", "max_pixels", "max_length", "batch_size", |
| "grad_accum", "epochs", "learning_rate", "save_steps", "eval_steps", "logging_steps", "save_total_limit"): |
| if not math.isfinite(getattr(args, name)) or getattr(args, name) <= 0: |
| p.error(f"--{name.replace('_', '-')} must be positive and finite") |
| if (args.min_pixels > args.max_pixels or args.frame_cache_size < 0 or args.workers < 0 |
| or not 0 <= args.warmup_ratio <= 1 or not math.isfinite(args.weight_decay) or args.weight_decay < 0): |
| p.error("Invalid pixel limits, cache size, workers, warmup ratio, or weight decay") |
| if args.directory_fps is not None and (not math.isfinite(args.directory_fps) or args.directory_fps <= 0): |
| p.error("--directory-fps must be positive and finite") |
| if not args.check_data and not args.model: |
| p.error("Supply --model for dry-run or training") |
| if not args.check_data and not args.dry_run and not args.output_dir: |
| p.error("Supply --output-dir for training") |
| return args |
|
|
|
|
| def main(): |
| args = parse_args() |
| train = read_data(args.train_data, args.video_root) |
| evaluation = read_data(args.eval_data, args.video_root) if args.eval_data else [] |
| summaries = {"train": audit(train)} |
| if evaluation: |
| summaries["validation"] = audit(evaluation) |
| check_split_overlap(train, evaluation) |
| print(json.dumps(summaries, indent=2), flush=True) |
| if args.check_data: |
| return |
| manifest = {"arguments": vars(args), "data": summaries, |
| "sha256": {name: hashlib.sha256(Path(name).read_bytes()).hexdigest() |
| for name in (args.train_data, args.eval_data) if name}} |
| if not args.dry_run: |
| output = Path(args.output_dir) |
| if output.exists() and any(output.iterdir()) and not args.resume_from_checkpoint: |
| raise ValueError("Output directory is not empty; select a new directory or explicitly resume") |
| if args.resume_from_checkpoint: |
| checkpoint = Path(args.resume_from_checkpoint).resolve() |
| if checkpoint.parent != output.resolve() or not (checkpoint / "trainer_state.json").is_file(): |
| raise ValueError("Resume requires a Trainer checkpoint inside the original output directory") |
| manifest_path = output / "sft_run.json" |
| if not manifest_path.exists(): |
| raise ValueError("Missing original sft_run.json") |
| original = json.loads(manifest_path.read_text()) |
| if original["sha256"] != manifest["sha256"]: |
| raise ValueError("Resume requires the same dataset snapshot") |
| for key in ("model", "sample_fps", "max_frames", "min_pixels", "max_pixels", "max_length", |
| "directory_fps", "video_root", "precision", "batch_size", "grad_accum", "seed"): |
| if original["arguments"][key] != vars(args)[key]: |
| raise ValueError(f"Resume configuration changed: {key}") |
| from transformers import AutoProcessor |
| processor = AutoProcessor.from_pretrained(args.model, local_files_only=args.local_files_only, |
| min_pixels=args.min_pixels, max_pixels=args.max_pixels) |
| processor.tokenizer.padding_side = "right" |
| if processor.tokenizer.pad_token_id is None: |
| raise ValueError("The model tokenizer must define a pad token") |
| loader = FrameLoader(args.sample_fps, args.max_frames, args.max_pixels, |
| args.frame_cache_size, args.directory_fps) |
| collator = HandyVQACollator(processor, loader, args.max_length) |
| if args.dry_run: |
| for split, rows in (("train", train), ("validation", evaluation)): |
| lengths, targets = [], [] |
| for start in range(0, len(rows), args.batch_size): |
| batch = collator(rows[start:start + args.batch_size]) |
| lengths.extend(batch["attention_mask"].sum(dim=1).tolist()) |
| targets.extend((batch["labels"] != -100).sum(dim=1).tolist()) |
| if lengths: |
| print(json.dumps({"split": split, "checked": len(lengths), "max_tokens": max(lengths), |
| "min_target_tokens": min(targets), "max_target_tokens": max(targets)}), flush=True) |
| return |
|
|
| import torch |
| from transformers import Qwen3VLForConditionalGeneration, Trainer, TrainerCallback, TrainingArguments, set_seed |
|
|
| class SaveLastStep(TrainerCallback): |
| def on_step_end(self, args, state, control, **kwargs): |
| if state.global_step >= state.max_steps: |
| control.should_save = True |
| return control |
|
|
| set_seed(args.seed) |
| |
| training_args = TrainingArguments( |
| output_dir=str(output), num_train_epochs=args.epochs, |
| per_device_train_batch_size=args.batch_size, per_device_eval_batch_size=args.batch_size, |
| gradient_accumulation_steps=args.grad_accum, learning_rate=args.learning_rate, |
| warmup_ratio=args.warmup_ratio, weight_decay=args.weight_decay, lr_scheduler_type="cosine", |
| bf16=args.precision == "bf16", fp16=args.precision == "fp16", |
| gradient_checkpointing=True, gradient_checkpointing_kwargs={"use_reentrant": False}, |
| remove_unused_columns=False, dataloader_num_workers=args.workers, |
| save_strategy="steps", save_steps=args.save_steps, save_total_limit=args.save_total_limit, |
| eval_strategy="steps" if evaluation else "no", eval_steps=args.eval_steps, |
| logging_steps=args.logging_steps, report_to="none", push_to_hub=False, |
| prediction_loss_only=True, seed=args.seed, data_seed=args.seed, |
| ddp_find_unused_parameters=False, deepspeed=args.deepspeed, |
| ) |
| model = Qwen3VLForConditionalGeneration.from_pretrained( |
| args.model, torch_dtype=torch.bfloat16 if args.precision == "bf16" else torch.float32, |
| attn_implementation=args.attention, local_files_only=args.local_files_only) |
| model.config.use_cache = False |
| eval_sets = {stage: [r for r in evaluation if r["_stage"] == stage] for stage in STAGES} if evaluation else None |
| trainer = Trainer(model=model, args=training_args, train_dataset=train, |
| eval_dataset=eval_sets, data_collator=collator, processing_class=processor, |
| callbacks=[SaveLastStep()]) |
| if trainer.is_world_process_zero(): |
| output.mkdir(parents=True, exist_ok=True) |
| manifest_path = output / "sft_run.json" |
| if not args.resume_from_checkpoint: |
| manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8") |
| result = trainer.train(resume_from_checkpoint=args.resume_from_checkpoint) |
| trainer.save_state() |
| trainer.save_metrics("train", result.metrics) |
| if evaluation: |
| trainer.save_metrics("eval", trainer.evaluate()) |
| model.config.use_cache = True |
| trainer.save_model(str(output / "final")) |
| if trainer.is_world_process_zero(): |
| processor.save_pretrained(output / "final") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
