Upload scripts/prepare_all_data.py with huggingface_hub

scripts/prepare_all_data.py

@@ -0,0 +1,474 @@
+"""
+一站式数据准备脚本。
+
+自动完成：
+  1. 下载 COCO 2017 检测数据（val 子集，约 5K 图，~1GB）
+  2. 生成预训练 grounding 数据（JSONL）
+  3. 生成 Counting 冷启动数据（基于 COCO）
+  4. 生成 Spatial Reasoning 数据（CLEVR 风格，纯程序生成）
+  5. 调用 maze / path 生成脚本
+
+用法:
+  python scripts/prepare_all_data.py --output_dir data --coco_split val
+"""
+
+import os
+import sys
+import json
+import argparse
+import random
+import math
+from pathlib import Path
+from typing import List, Tuple
+from collections import defaultdict
+
+from PIL import Image, ImageDraw, ImageFont
+from tqdm import tqdm
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+
+IRREGULAR_PLURALS = {
+    "person": "people",
+    "mouse": "mice",
+    "sheep": "sheep",
+    "knife": "knives",
+    "child": "children",
+}
+
+
+def pluralize(word: str) -> str:
+    """Simple English pluralization for COCO category names."""
+    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"
+
+from model.special_tokens import normalize_coordinate
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--output_dir", type=str, default="data")
+    parser.add_argument("--coco_split", type=str, default="val", choices=["train", "val"])
+    parser.add_argument("--coco_subset", type=int, default=5000, help="最多使用多少张 COCO 图片")
+    parser.add_argument("--num_counting", type=int, default=2000, help="生成 counting 样本数")
+    parser.add_argument("--num_spatial", type=int, default=2000, help="生成 spatial 样本数")
+    parser.add_argument("--num_maze", type=int, default=5000, help="生成 maze 样本数")
+    parser.add_argument("--num_path", type=int, default=3000, help="生成 path tracing 样本数")
+    parser.add_argument("--seed", type=int, default=42)
+    return parser.parse_args()
+
+
+# ---------------------------------------------------------------------------
+# 1. COCO 下载 & 导出
+# ---------------------------------------------------------------------------
+
+def download_coco(output_dir: Path, split: str = "val", max_images: int = 5000):
+    """使用 datasets 库下载 COCO，导出为图片+标注文件。"""
+    try:
+        from datasets import load_dataset
+    except ImportError:
+        print("请先安装 datasets: pip install datasets")
+        sys.exit(1)
+
+    print(f"正在下载 COCO 2017 {split} ...")
+    ds = load_dataset("detection-datasets/coco", split=split, streaming=True)
+
+    img_dir = output_dir / "coco" / split / "images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+    ann_path = output_dir / "coco" / split / "annotations.json"
+
+    annotations = {"images": [], "annotations": [], "categories": []}
+    category_map = {}
+    cat_counter = 1
+
+    count = 0
+    for sample in tqdm(ds, desc="COCO download"):
+        if count >= max_images:
+            break
+        # sample keys: image, image_id, width, height, objects
+        img = sample["image"]
+        img_id = sample.get("image_id", count)
+        w, h = sample.get("width", img.width), sample.get("height", img.height)
+
+        img_path = img_dir / f"{img_id:012d}.jpg"
+        img.save(img_path)
+
+        annotations["images"].append({
+            "id": img_id,
+            "file_name": img_path.name,
+            "width": w,
+            "height": h,
+        })
+
+        objects = sample.get("objects", {})
+        bboxes = objects.get("bbox", [])
+        labels = objects.get("category", [])
+        for bbox, label in zip(bboxes, labels):
+            if label not in category_map:
+                category_map[label] = cat_counter
+                annotations["categories"].append({
+                    "id": cat_counter,
+                    "name": str(label),
+                })
+                cat_counter += 1
+            annotations["annotations"].append({
+                "id": len(annotations["annotations"]) + 1,
+                "image_id": img_id,
+                "category_id": category_map[label],
+                "bbox": bbox,  # [x1, y1, x2, y2]
+            })
+        count += 1
+
+    with open(ann_path, "w") as f:
+        json.dump(annotations, f)
+    print(f"COCO 导出完成: {img_dir} ({count} 张图), 标注: {ann_path}")
+    return img_dir, ann_path, annotations
+
+
+# ---------------------------------------------------------------------------
+# 2. 预训练 Grounding 数据
+# ---------------------------------------------------------------------------
+
+def generate_pretrain_data(annotations: dict, output_path: Path):
+    """从 COCO 标注生成 grounding JSONL。"""
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    # 按图分组
+    img_anns = defaultdict(list)
+    for ann in annotations["annotations"]:
+        img_anns[ann["image_id"]].append(ann)
+
+    cats = {c["id"]: c["name"] for c in annotations["categories"]}
+
+    records = []
+    for img_info in annotations["images"]:
+        img_id = img_info["id"]
+        W, H = img_info["width"], img_info["height"]
+        anns = img_anns.get(img_id, [])
+        if not anns:
+            continue
+        # 按类别分组
+        by_cat = defaultdict(list)
+        for ann in anns:
+            cat_name = cats[ann["category_id"]]
+            x1, y1, x2, y2 = ann["bbox"]  # HuggingFace COCO: [x1,y1,x2,y2]
+            x1 = max(0.0, min(x1, W))
+            y1 = max(0.0, min(y1, H))
+            x2 = max(0.0, min(x2, W))
+            y2 = max(0.0, min(y2, H))
+            box = (
+                normalize_coordinate(x1, W),
+                normalize_coordinate(y1, H),
+                normalize_coordinate(x2, W),
+                normalize_coordinate(y2, H),
+            )
+            by_cat[cat_name].append(box)
+
+        for cat_name, boxes in by_cat.items():
+            records.append({
+                "image": str(Path("images") / img_info["file_name"]),
+                "label": cat_name,
+                "boxes": boxes,
+                "points": [],
+                "normalized": True,
+            })
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"预训练 grounding 数据: {len(records)} 条 -> {output_path}")
+
+
+# ---------------------------------------------------------------------------
+# 3. Counting 冷启动数据（基于 COCO）
+# ---------------------------------------------------------------------------
+
+def generate_counting_thinking(category: str, boxes: List[Tuple[int, int, int, int]], count: int) -> str:
+    """程序生成 Counting 的 thinking 内容（统一模板：与 grounding 格式一致）。"""
+    lines = []
+    lines.append("1. **Analyzing the request**")
+    lines.append(f"The user asks me to count the {category} in this image.")
+    lines.append("2. **Object grounding**")
+    box_strs = []
+    for x1, y1, x2, y2 in boxes:
+        box_strs.append(f"[{x1},{y1},{x2},{y2}]")
+    lines.append(f"I see {count} instance(s) of <|ref|>{category}<|/ref|><|box|>[{','.join(box_strs)}]<|/box|>.")
+    lines.append("3. **Conclusion**")
+    lines.append(f"There are {count} {category} in this image.")
+    return "\n".join(lines)
+
+
+def generate_counting_data(annotations: dict, output_path: Path, num_samples: int):
+    """从 COCO 生成 counting 数据。"""
+    from utils.coco_categories import COCO_CATS, get_category_name
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    img_anns = defaultdict(list)
+    for ann in annotations["annotations"]:
+        img_anns[ann["image_id"]].append(ann)
+    cats = {c["id"]: c["name"] for c in annotations["categories"]}
+
+    # 筛选出实例数 >=2 的图
+    candidates = []
+    for img_info in annotations["images"]:
+        img_id = img_info["id"]
+        W, H = img_info["width"], img_info["height"]
+        anns = img_anns.get(img_id, [])
+        by_cat = defaultdict(list)
+        for ann in anns:
+            raw_name = cats[ann["category_id"]]
+            cat_name = get_category_name(raw_name)
+            x1, y1, x2, y2 = ann["bbox"]  # HuggingFace COCO: [x1,y1,x2,y2]
+            x1 = max(0.0, min(x1, W))
+            y1 = max(0.0, min(y1, H))
+            x2 = max(0.0, min(x2, W))
+            y2 = max(0.0, min(y2, H))
+            box = (
+                normalize_coordinate(x1, W),
+                normalize_coordinate(y1, H),
+                normalize_coordinate(x2, W),
+                normalize_coordinate(y2, H),
+            )
+            by_cat[cat_name].append(box)
+        for cat_name, boxes in by_cat.items():
+            if len(boxes) >= 2:
+                candidates.append((img_info, cat_name, boxes))
+
+    random.shuffle(candidates)
+    candidates = candidates[:num_samples]
+
+    records = []
+    templates = [
+        "How many {category} are in this image?",
+        "How many {category} are in the image?",
+        "How many {plural} are in this image?",
+        "How many {plural} are in the image?",
+        "Count the number of {category}.",
+        "Count the number of {plural}.",
+        "Count the {plural} in the image.",
+        "Count all {plural} in this image.",
+        "What is the total count of {category}?",
+        "What is the total count of {plural}?",
+        "How many {plural} can you see?",
+        "How many {plural} are there in the image?",
+    ]
+    for img_info, cat_name, boxes in candidates:
+        plural_name = pluralize(cat_name)
+        question = random.choice(templates).format(category=cat_name, plural=plural_name)
+        thinking = generate_counting_thinking(cat_name, boxes, len(boxes))
+        records.append({
+            "image": str(Path("images") / img_info["file_name"]),
+            "question": question,
+            "thinking": thinking,
+            "count": len(boxes),
+            "boxes": boxes,
+        })
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"Counting 数据: {len(records)} 条 -> {output_path}")
+
+
+# ---------------------------------------------------------------------------
+# 4. Spatial Reasoning 数据（CLEVR 风格，程序生成）
+# ---------------------------------------------------------------------------
+
+def generate_clevr_image(size: int = 400) -> Image.Image:
+    """生成一张 CLEVR 风格的简单几何体图片。"""
+    img = Image.new("RGB", (size, size), "lightgray")
+    draw = ImageDraw.Draw(img)
+    colors = ["red", "blue", "green", "yellow", "purple", "cyan", "brown", "gray"]
+    shapes = ["circle", "rectangle", "triangle"]
+    materials = ["metal", "rubber"]
+    objects = []
+
+    num_objs = random.randint(3, 6)
+    for _ in range(num_objs):
+        obj_w = random.randint(30, 80)
+        obj_h = random.randint(30, 80)
+        x = random.randint(10, size - obj_w - 10)
+        y = random.randint(10, size - obj_h - 10)
+        color = random.choice(colors)
+        shape = random.choice(shapes)
+        material = random.choice(materials)
+
+        if shape == "circle":
+            draw.ellipse([x, y, x + obj_w, y + obj_h], fill=color, outline="black")
+        elif shape == "rectangle":
+            draw.rectangle([x, y, x + obj_w, y + obj_h], fill=color, outline="black")
+        else:
+            # triangle
+            draw.polygon([(x + obj_w // 2, y), (x, y + obj_h), (x + obj_w, y + obj_h)], fill=color, outline="black")
+
+        # normalized bbox
+        nx1 = normalize_coordinate(x, size)
+        ny1 = normalize_coordinate(y, size)
+        nx2 = normalize_coordinate(x + obj_w, size)
+        ny2 = normalize_coordinate(y + obj_h, size)
+        objects.append({
+            "shape": shape,
+            "color": color,
+            "material": material,
+            "bbox": [nx1, ny1, nx2, ny2],
+        })
+    return img, objects
+
+
+def generate_spatial_question(objects: List[dict], img_path: Path) -> dict:
+    """基于生成物体生成空间推理问题和答案。"""
+    if len(objects) < 2:
+        return None
+
+    # 简化: 只使用 attribute 问题类型
+    q_type = "attribute"
+
+    # 选一个目标物体
+    target = random.choice(objects)
+    target_color = target["color"]
+    target_shape = target["shape"]
+    target_mat = target["material"]
+
+    question = f"Is there a {target_color} {target_mat} {target_shape}?"
+    answer = "Yes"
+
+    # 构建 thinking
+    lines = []
+    lines.append("1. **Analyzing the request**")
+    lines.append(f"The user asks if there is a {target_color} {target_mat} {target_shape}.")
+    lines.append("2. **Object grounding**")
+    for obj in objects:
+        c = obj["color"]
+        s = obj["shape"]
+        m = obj["material"]
+        b = obj["bbox"]
+        lines.append(f"I see a <|ref|>{c} {m} {s}<|/ref|><|box|>[[{b[0]},{b[1]},{b[2]},{b[3]}]]<|/box|>.")
+    lines.append("3. **Conclusion**")
+    lines.append(f"Since there is a {target_color} {target_mat} {target_shape}, the answer is Yes.")
+    thinking = "\n".join(lines)
+
+    return {
+        "image": str(img_path),
+        "question": question,
+        "thinking": thinking,
+        "answer": answer,
+        "boxes": [target["bbox"]],
+        "points": [],
+    }
+
+
+def generate_spatial_data(output_dir: Path, num_samples: int):
+    output_dir.mkdir(parents=True, exist_ok=True)
+    img_dir = output_dir / "images"
+    img_dir.mkdir(exist_ok=True)
+
+    records = []
+    for i in range(num_samples):
+        img, objects = generate_clevr_image(size=400)
+        img_path = img_dir / f"spatial_{i:06d}.png"
+        img.save(img_path)
+
+        rec = generate_spatial_question(objects, img_path.relative_to(output_dir))
+        if rec:
+            records.append(rec)
+
+    with open(output_dir / "spatial_data.jsonl", "w", encoding="utf-8") as f:
+        for rec in records:
+            f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+    print(f"Spatial 数据: {len(records)} 条 -> {output_dir}")
+
+
+# ---------------------------------------------------------------------------
+# 5. 调用 maze / path 生成
+# ---------------------------------------------------------------------------
+
+def call_maze_generation(output_dir: Path, num_samples: int):
+    import subprocess
+    cmd = [
+        sys.executable, str(PROJECT_ROOT / "scripts" / "generate_maze_data.py"),
+        "--output_dir", str(output_dir),
+        "--num_samples", str(num_samples),
+    ]
+    print(f"运行: {' '.join(cmd)}")
+    subprocess.run(cmd, check=True)
+
+
+def call_path_generation(output_dir: Path, num_samples: int):
+    import subprocess
+    cmd = [
+        sys.executable, str(PROJECT_ROOT / "scripts" / "generate_path_data.py"),
+        "--output_dir", str(output_dir),
+        "--num_samples", str(num_samples),
+    ]
+    print(f"运行: {' '.join(cmd)}")
+    subprocess.run(cmd, check=True)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    args = parse_args()
+    random.seed(args.seed)
+
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # 1. COCO
+    coco_img_dir, coco_ann_path, annotations = download_coco(
+        output_dir / "coco" / args.coco_split,
+        split=args.coco_split,
+        max_images=args.coco_subset,
+    )
+
+    # 2. 预训练 grounding
+    generate_pretrain_data(
+        annotations,
+        output_dir / "pretrain" / "grounding.jsonl",
+    )
+    # 创建符号链接或复制 images
+    pretrain_img_dir = output_dir / "pretrain" / "images"
+    pretrain_img_dir.mkdir(parents=True, exist_ok=True)
+    # 这里直接写入相对路径，训练时 image_root 指向 coco/val/images
+
+    # 3. Counting
+    generate_counting_data(
+        annotations,
+        output_dir / "sft" / "counting" / "counting_data.jsonl",
+        num_samples=args.num_counting,
+    )
+
+    # 4. Spatial
+    generate_spatial_data(
+        output_dir / "sft" / "spatial",
+        num_samples=args.num_spatial,
+    )
+
+    # 5. Maze
+    call_maze_generation(output_dir / "sft" / "maze", args.num_maze)
+
+    # 6. Path
+    call_path_generation(output_dir / "sft" / "path", args.num_path)
+
+    print("\n========================================")
+    print("所有数据准备完成！")
+    print(f"预训练数据: {output_dir / 'pretrain' / 'grounding.jsonl'}")
+    print(f"Counting:   {output_dir / 'sft' / 'counting'}")
+    print(f"Spatial:    {output_dir / 'sft' / 'spatial'}")
+    print(f"Maze:       {output_dir / 'sft' / 'maze'}")
+    print(f"Path:       {output_dir / 'sft' / 'path'}")
+    print("========================================")
+
+
+if __name__ == "__main__":
+    main()