#!/usr/bin/env python3 """ Generate SFT grounding data with negative samples for improved precision and rejection ability. Produces: - data/sft/grounding/sft_grounding.jsonl - 70% positive samples with full CoT thinking template - 30% negative samples (object not in image -> empty response) Usage: python scripts/generate_sft_grounding_data.py \ --coco_jsonl data/pretrain/grounding.jsonl \ --image_root data/coco/val \ --output data/sft/grounding/sft_grounding.jsonl \ --neg_ratio 0.30 """ import os import sys import json import random import argparse from pathlib import Path from collections import defaultdict PROJECT_ROOT = Path(__file__).resolve().parent.parent sys.path.insert(0, str(PROJECT_ROOT)) from utils.coco_categories import COCO_CATS random.seed(42) IRREGULAR_PLURALS = { "person": "people", "mouse": "mice", "sheep": "sheep", "knife": "knives", "child": "children", } def pluralize(word: str) -> str: low = word.lower() if low in IRREGULAR_PLURALS: return IRREGULAR_PLURALS[low] if " " in word: parts = word.rsplit(" ", 1) return parts[0] + " " + pluralize(parts[1]) if word.endswith(("s", "sh", "ch", "x", "z")): return word + "es" if word.endswith("y") and word[-2] not in "aeiou": return word[:-1] + "ies" return word + "s" GROUNDING_TEMPLATES = [ "Locate the {category} in the image.", "Locate the {category} in this image.", "Find the {category} in the image.", "Where is the {category} in the image?", "Where is the {category}?", "Show me the {category} in the image.", "Point out the {category}.", "Locate the {plural} in the image.", ] def format_box_token(boxes): """Format boxes into <|box|>[[x1,y1,x2,y2],...]<|/box|>.""" if not boxes: return "" inner = ",".join(f"[{x1},{y1},{x2},{y2}]" for x1, y1, x2, y2 in boxes) return f"<|box|>[{inner}]<|/box|>" def build_positive_thinking(category, boxes): """Build CoT thinking for positive sample.""" refs = "\n".join( f"I see a <|ref|>{category}<|/ref|><|box|>[[{b[0]},{b[1]},{b[2]},{b[3]}]]<|/box|>." for b in (boxes if boxes else []) ) if not refs: refs = f"I see a <|ref|>{category}<|/ref|><|box|>[]<|/box|>." return ( f"1. **Analyzing the request**\n" f"The user asks me to locate the {category} in this image.\n" f"2. **Object grounding**\n" f"{refs}\n" f"3. **Conclusion**\n" f"The {category} is located at the specified coordinates." ) def build_positive_answer(category, boxes): if not boxes: return f"The {category} is not visible in the image." box_str = ",".join(f"[{x1},{y1},{x2},{y2}]" for x1, y1, x2, y2 in boxes) return f"The {category} is located at [{box_str}]." def build_negative_thinking(category): return ( f"1. **Analyzing the request**\n" f"The user asks me to locate the {category} in this image.\n" f"2. **Object grounding**\n" f"After carefully scanning the entire image, I do not see any {category} present.\n" f"3. **Conclusion**\n" f"There is no {category} in this image." ) def build_negative_answer(category): return f"There is no {category} in the image." def main(): parser = argparse.ArgumentParser() parser.add_argument("--coco_jsonl", type=str, default="data/pretrain/grounding.jsonl") parser.add_argument("--image_root", type=str, default="data/coco/val") parser.add_argument("--output", type=str, default="data/sft/grounding/sft_grounding.jsonl") parser.add_argument("--neg_ratio", type=float, default=0.30) parser.add_argument("--max_samples", type=int, default=10000) args = parser.parse_args() out_path = Path(args.output) out_path.parent.mkdir(parents=True, exist_ok=True) # Load all positive samples print("Loading COCO grounding data...") all_samples = [] with open(args.coco_jsonl, "r", encoding="utf-8") as f: for line in f: item = json.loads(line.strip()) img_rel = item.get("image", "") label_raw = item.get("label", 0) try: label_id = int(label_raw) category = COCO_CATS.get(label_id, f"object_{label_id}") except (ValueError, TypeError): # label is already a string (category name) category = str(label_raw) boxes = [tuple(b) for b in item.get("boxes", [])] all_samples.append({ "image": img_rel, "category": category, "label_id": label_id, "boxes": boxes, }) # Group by image for negative sampling img_to_labels = defaultdict(set) for s in all_samples: img_to_labels[s["image"]].add(s["label_id"]) # Build positive SFT samples # Cap boxes at 8 per sample to keep sequence length manageable for 12G VRAM MAX_BOXES_PER_SAMPLE = 8 positive_samples = [] for s in all_samples: if not s["boxes"]: continue boxes = s["boxes"][:MAX_BOXES_PER_SAMPLE] cat = s["category"] plural = pluralize(cat) question = random.choice(GROUNDING_TEMPLATES).format(category=cat, plural=plural) positive_samples.append({ "image": s["image"], "question": question, "thinking": build_positive_thinking(cat, boxes), "answer": build_positive_answer(cat, boxes), "boxes": boxes, "points": [], }) # Build negative SFT samples all_label_ids = list(COCO_CATS.keys()) img_list = list(img_to_labels.keys()) negative_samples = [] for img_rel in img_list: present = img_to_labels[img_rel] absent = [lid for lid in all_label_ids if lid not in present] if absent: # Sample 1-2 negative categories per image n_neg = min(2, len(absent)) for neg_label in random.sample(absent, n_neg): category = COCO_CATS[neg_label] plural = pluralize(category) question = random.choice(GROUNDING_TEMPLATES).format(category=category, plural=plural) negative_samples.append({ "image": img_rel, "question": question, "thinking": build_negative_thinking(category), "answer": build_negative_answer(category), "boxes": [], "points": [], }) # Shuffle and sample random.shuffle(positive_samples) random.shuffle(negative_samples) # Determine counts based on neg_ratio n_pos_target = int(args.max_samples * (1 - args.neg_ratio)) n_neg_target = int(args.max_samples * args.neg_ratio) pos_selected = positive_samples[:n_pos_target] neg_selected = negative_samples[:n_neg_target] # Combine and shuffle combined = pos_selected + neg_selected random.shuffle(combined) # Write output with open(out_path, "w", encoding="utf-8") as f: for item in combined: f.write(json.dumps(item, ensure_ascii=False) + "\n") print(f"Generated {len(combined)} SFT samples:") print(f" Positive: {len(pos_selected)}") print(f" Negative: {len(neg_selected)}") print(f" Saved to: {out_path}") if __name__ == "__main__": main()