added transformer_benchmark

.gitignore

@@ -7,3 +7,7 @@
 object_detector_benchmark/yolo_benchmark/*
 !object_detector_benchmark/yolo_benchmark/
 !object_detector_benchmark/yolo_benchmark/*.yaml
+object_detector_benchmark/8_calves_arrow/
+object_detector_benchmark/8_calves_coco/
+object_detector_benchmark/transformer_benchmark/runs
+object_detector_benchmark/transformer_benchmark/__pycache__

README.md

@@ -110,7 +110,15 @@ T = [
 ```
 
 Step 4:
-run the yolo detectors following ultralytic's documentations.
+run the yolo detectors following the following steps:
+
+```
+cd yolo_benchmark
+
+Model_Name=yolov9t
+
+yolo cfg=experiment.yaml model=$Model_Name.yaml name=$Model_Name
+```
 
 
 ### Identity Classification

object_detector_benchmark/data_wrangling.py

@@ -0,0 +1,70 @@
+import json
+import os
+from datasets import Dataset, DatasetDict, Image, Features, Value, Sequence
+
+def create_split_dataset(coco_dir, split):
+    """Create a dataset for a single split with exact annotation format"""
+    with open(os.path.join(coco_dir, f"{split}.json")) as f:
+        coco_data = json.load(f)
+
+    # Create annotation map with full COCO fields
+    ann_map = {img['id']: [] for img in coco_data['images']}
+    for ann in coco_data['annotations']:
+        ann_map[ann['image_id']].append({
+            'id': ann['id'],
+            'category_id': 0,
+            'bbox': [float(x) for x in ann['bbox']],  # Ensure float values
+            'area': float(ann['area']),
+            'iscrowd': int(ann.get('iscrowd', 0))
+        })
+
+    # Build dataset entries with exact format
+    dataset = []
+    for img in coco_data['images']:
+        dataset.append({
+            'image_id': int(img['id']),
+            'image': {'path': os.path.join(coco_dir, img['file_name'])},
+            'annotations': ann_map[img['id']]  # List of annotation dicts
+        })
+
+    # Define features schema
+    features = Features({
+        'image_id': Value('int64'),
+        'image': Image(),
+        'annotations': [{
+            'id': Value('int64'),
+            'category_id': Value('int64'),
+            'bbox': [Value('float32')],  # List of floats for bbox
+            'area': Value('float32'),
+            'iscrowd': Value('int64')
+        }]
+    })
+    
+    return Dataset.from_list(dataset, features=features)
+
+# Configuration
+coco_dir = "8_calves_coco"
+debug_limits = {"train": 50, "val": 20, "test": 10}
+seed = 42
+
+# Initialize containers
+full_dataset = DatasetDict()
+debug_dataset = DatasetDict()
+
+# Process splits
+for split in ["train", "val", "test"]:
+    # Create full split dataset
+    full_split = create_split_dataset(coco_dir, split)
+    full_dataset[split] = full_split
+    
+    # Create debug version with random samples
+    debug_split = full_split.shuffle(seed=seed).select(range(debug_limits[split]))
+    debug_dataset[split] = debug_split
+
+# Save debug first
+# debug_dataset.save_to_disk("cache_debug")
+# print(f"✅ Debug cache saved with {sum(len(d) for d in debug_dataset.values())} samples")
+
+# Save full dataset
+full_dataset.save_to_disk("8_calves_arrow")
+print(f"✅ Full cache saved with {sum(len(d) for d in full_dataset.values())} samples")

object_detector_benchmark/transformer_benchmark/Configs/conditional_detr.yaml

@@ -0,0 +1,49 @@
+dataset_path: "../8_calves_arrow"
+save_directory: "runs"
+
+model_name: "microsoft/conditional-detr-resnet-50"
+
+# Training Hyperparameters
+num_train_epochs: 100
+
+# Learning Rates
+learning_rates:
+  model: 1e-5
+  class_labels_classifier: 1e-4
+  bbox_predictor: 1e-4
+
+# Scheduler Type
+
+lr_scheduler_type: "constant_with_warmup"
+
+# Weight Decay
+weight_decay: 1e-4 # or just set 0
+
+# Batch Sizes
+train_batch_size: 5
+eval_batch_size: 25
+dataloader_num_workers: 8
+
+# Gradient Clipping
+max_grad_norm: 0.1
+
+# Warm up
+warmup_steps: 0
+
+# Augmentation Probabilities
+rotate90: 1.0
+horizontal_flip: 0.5
+brightness_contrast: 0.4
+
+# Elastic Transform Parameters
+elastic_transform: 0.5
+elastic_alpha: 100.0
+elastic_sigma: 5.0
+
+# Evaluation & Saving
+eval_strategy: "epoch"  # Options: no, steps, epoch
+save_strategy: "epoch"  # Options: no, steps, epoch
+
+# Early Stopping
+early_stopping_patience: 10
+

object_detector_benchmark/transformer_benchmark/Configs/facebook_detr.yaml

@@ -0,0 +1,49 @@
+dataset_path: "../8_calves_arrow"
+save_directory: "runs"
+
+model_name: "facebook/detr-resnet-50"
+
+# Training Hyperparameters
+num_train_epochs: 100
+
+# Learning Rates
+learning_rates:
+  model: 1e-5
+  class_labels_classifier: 1e-4
+  bbox_predictor: 1e-4
+
+# Scheduler Type
+
+lr_scheduler_type: "constant_with_warmup"
+
+# Weight Decay
+weight_decay: 1e-4 # or just set 0
+
+# Batch Sizes
+train_batch_size: 5
+eval_batch_size: 25
+dataloader_num_workers: 8
+
+# Gradient Clipping
+max_grad_norm: 0.1
+
+# Warm up
+warmup_steps: 0
+
+# Augmentation Probabilities
+rotate90: 1.0
+horizontal_flip: 0.5
+brightness_contrast: 0.4
+
+# Elastic Transform Parameters
+elastic_transform: 0.5
+elastic_alpha: 100.0
+elastic_sigma: 5.0
+
+# Evaluation & Saving
+eval_strategy: "epoch"  # Options: no, steps, epoch
+save_strategy: "epoch"  # Options: no, steps, epoch
+
+# Early Stopping
+early_stopping_patience: 10
+

object_detector_benchmark/transformer_benchmark/Configs/yolos.yaml

@@ -0,0 +1,49 @@
+dataset_path: "../8_calves_arrow"
+save_directory: "runs"
+
+model_name: "hustvl/yolos-small"
+
+# Training Hyperparameters
+num_train_epochs: 100
+
+# Learning Rates
+learning_rates:
+  vit: 2.5e-5
+  class_labels_classifier: 2.5e-5
+  bbox_predictor: 2.5e-5
+
+# Scheduler Type
+
+lr_scheduler_type: "cosine"
+
+# Weight Decay
+weight_decay: 1e-4 # or just set 0
+
+# Batch Sizes
+train_batch_size: 5
+eval_batch_size: 25
+dataloader_num_workers: 8
+
+# Gradient Clipping
+max_grad_norm: 0.0
+
+# Warm up
+warmup_steps: 0
+
+# Augmentation Probabilities
+rotate90: 1.0
+horizontal_flip: 0.5
+brightness_contrast: 0.4
+
+# Elastic Transform Parameters
+elastic_transform: 0.5
+elastic_alpha: 100.0
+elastic_sigma: 5.0
+
+# Evaluation & Saving
+eval_strategy: "epoch"  # Options: no, steps, epoch
+save_strategy: "epoch"  # Options: no, steps, epoch
+
+# Early Stopping
+early_stopping_patience: 10
+

object_detector_benchmark/transformer_benchmark/augmentations.py

@@ -0,0 +1,117 @@
+from datasets import load_from_disk
+import albumentations as A
+import numpy as np
+from collections import defaultdict
+import os
+from PIL import Image, ImageDraw
+from functools import partial
+from custom_parser import parse_args
+
+
+# augmentation probabilities need to be hyperparameters
+def augment_data_point(batch, args):
+    assert len(batch["image_id"]) == len(batch["image"]) == len(batch["annotations"])
+    transform = A.Compose([
+        A.RandomRotate90(p=args.rotate90),
+        A.HorizontalFlip(p=args.horizontal_flip),
+        A.RandomBrightnessContrast(p=args.brightness_contrast),
+        A.ElasticTransform(
+            alpha=args.elastic_alpha, 
+            sigma=args.elastic_sigma, 
+            p=args.elastic_transform
+        ),
+        A.Resize(640, 640)
+    ], bbox_params=A.BboxParams(
+        format="coco",
+        label_fields=["category_ids"],
+    ))
+    
+    new_batch = defaultdict(list)
+    for id, image, annotations in zip(batch["image_id"], batch["image"], batch["annotations"]):
+        image_np = np.array(image)
+        bboxes = [ann["bbox"] for ann in annotations]
+        category_ids = [ann["category_id"] for ann in annotations]
+    
+        transformed = transform(image=image_np, bboxes=bboxes, category_ids=category_ids)
+        transformed_image = Image.fromarray(transformed["image"])
+    
+        transformed_annotations = []
+        for ann, new_bbox in zip(annotations, transformed["bboxes"]):
+            new_ann = ann.copy()
+            new_ann["bbox"] = new_bbox
+            transformed_annotations.append(new_ann)
+        new_batch["image_id"].append(id)
+        new_batch["image"].append(transformed_image)
+        new_batch["annotations"].append(transformed_annotations)
+    
+    return new_batch
+
+
+
+def validation_transform(batch):
+    assert len(batch["image_id"]) == len(batch["image"]) == len(batch["annotations"])
+    transform = A.Compose([
+        A.Resize(640, 640)
+    ], bbox_params=A.BboxParams(
+        format="coco",
+        label_fields=["category_ids"],
+    ))
+    
+    new_batch = defaultdict(list)
+    for id, image, annotations in zip(batch["image_id"], batch["image"], batch["annotations"]):
+        image_np = np.array(image)
+        bboxes = [ann["bbox"] for ann in annotations]
+        category_ids = [ann["category_id"] for ann in annotations]
+    
+        transformed = transform(image=image_np, bboxes=bboxes, category_ids=category_ids)
+        transformed_image = Image.fromarray(transformed["image"])
+    
+        transformed_annotations = []
+        for ann, new_bbox in zip(annotations, transformed["bboxes"]):
+            new_ann = ann.copy()
+            new_ann["bbox"] = new_bbox
+            transformed_annotations.append(new_ann)
+        new_batch["image_id"].append(id)
+        new_batch["image"].append(transformed_image)
+        new_batch["annotations"].append(transformed_annotations)
+    
+    return new_batch
+
+
+def save_sample(dataset, idx, filename, save_dir="augmented_samples"):
+    os.makedirs(save_dir, exist_ok=True)
+    sample = dataset[idx]  # Fetch sample (augmented or original)
+    image = sample["image"]
+    bboxes = [ann["bbox"] for ann in sample["annotations"]]
+
+    # Convert image to RGB (if not already)
+    image = image.convert("RGB")
+
+    # Draw bounding boxes
+    draw = ImageDraw.Draw(image)
+    for bbox in bboxes:
+        x, y, w, h = bbox
+        draw.rectangle([x, y, x + w, y + h], outline="red", width=3)
+
+    # Save the image
+    image_path = os.path.join(save_dir, filename)
+    image.save(image_path)
+
+
+
+def main():
+    args = parse_args()
+    dataset = load_from_disk(args.dataset_path)
+
+    train_dataset = dataset["train"]
+    augmented_train_dataset = train_dataset.with_transform(lambda batch: augment_data_point(batch, args))
+    valid_dataset = dataset["val"].with_transform(validation_transform)
+    # print(train_dataset[0])
+    for i in range(5):  # Adjust index as needed
+        save_sample(augmented_train_dataset, i, f"augmented_sample_{i}.png")
+        save_sample(train_dataset, i, f"original_sample_{i}.png")
+        save_sample(valid_dataset, i, f"validation_image_{i}.png")
+
+
+if __name__ == "__main__":
+    main()

object_detector_benchmark/transformer_benchmark/custom_parser.py

@@ -0,0 +1,37 @@
+import yaml
+import argparse
+from argparse import Namespace
+from ultralytics.utils import IterableSimpleNamespace
+
+
+# Function to Load Configurations from YAML
+def load_config(config_path):
+    with open(config_path, "r") as file:
+        config_dict = yaml.safe_load(file)
+        
+    # Convert specific keys to float/int to prevent type errors
+    config_dict["weight_decay"] = float(config_dict["weight_decay"])
+    config_dict["warmup_steps"] = int(config_dict["warmup_steps"])
+    
+    config_dict["rotate90"] = float(config_dict["rotate90"])
+    config_dict["horizontal_flip"] = float(config_dict["horizontal_flip"])
+    config_dict["brightness_contrast"] = float(config_dict["brightness_contrast"])
+    config_dict["elastic_transform"] = float(config_dict["elastic_transform"])
+    config_dict["elastic_alpha"] = float(config_dict["elastic_alpha"])
+    config_dict["elastic_sigma"] = float(config_dict["elastic_sigma"])
+    return IterableSimpleNamespace(**config_dict)
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Custom Hugging Face Training with config file")
+
+    parser.add_argument("--config", type=str, required=True, help="Path to YAML config file")
+
+    args = parser.parse_args()
+    
+    # Load settings from the YAML file
+    config = load_config(args.config)
+    return config
+    
+
+if __name__ == "__main__":
+    main()

object_detector_benchmark/transformer_benchmark/train.py

@@ -0,0 +1,229 @@
+from datasets import load_from_disk
+from transformers import (
+    AutoModelForObjectDetection, 
+    AutoImageProcessor, 
+    Trainer, 
+    TrainingArguments, 
+    EarlyStoppingCallback, 
+)
+import torch
+import numpy as np
+from torchmetrics.detection.mean_ap import MeanAveragePrecision
+from functools import partial
+from augmentations import augment_data_point, validation_transform
+from pprint import pprint
+from custom_parser import parse_args
+from torch.optim import AdamW
+import os
+import torchvision.transforms as transforms
+from copy import deepcopy
+import time
+# from ultralytics.utils.plotting import Annotator
+from PIL import Image, ImageDraw
+
+# this is still bugged!!!
+# I guess time to parallelise this and see if there are more bugs, currently seems fine
+# just dropping the last incomplete batch
+# check how many bounding boxes there are for each image, if they all equal to 8,
+# can just add assertions
+@torch.no_grad()
+def compute_metrics(results):
+    assert len(results.predictions) == len(results.label_ids)
+    # pack up predictions
+    prediction_list = []
+    for batch in results.predictions:
+        logits = batch[1] # shape: (number of samples, number of predictions for each sample, number of classes)
+        scores = torch.softmax(torch.tensor(logits), dim=-1)
+        confidences, labels = scores.max(dim=-1)
+        boxes = batch[2]
+        
+        for boxes_per_image, confidences_per_image, labels_per_image in zip(boxes, confidences, labels):
+            boxes_tensor = torch.tensor(boxes_per_image)
+            sorted_indices = torch.argsort(confidences_per_image, descending=True)
+            keep = sorted_indices[:100]
+            boxes_top = boxes_tensor[keep]
+            scores_top = confidences_per_image[keep]
+            labels_top = labels_per_image[keep]
+            prediction_list.append({
+                'boxes': boxes_top,
+                'scores': scores_top,
+                'labels': labels_top,
+            })
+    # pack up targets
+    target_list = []
+    for batch in results.label_ids:
+        for target in batch:
+            target_list.append(
+                {
+                    'labels' : torch.tensor(target['class_labels']),
+                    'boxes' : torch.tensor(target['boxes']),
+                    'area' : torch.tensor(target['area']),
+                    'iscrowd' : torch.tensor(target['iscrowd']),
+                }
+            )
+    
+    assert len(prediction_list) == len(target_list)
+    for target in target_list:
+        assert len(target['boxes']) == len(target['labels']) == len(target['area']) == len(target['iscrowd']) > 2
+
+
+    # compute metrics
+    metric = MeanAveragePrecision(box_format='cxcywh')
+    metric.update(prediction_list, target_list)
+    metrics = metric.compute()
+    # for key in metrics.keys():
+    #     print(key, type(metrics[key]))
+    # print("map_small", type(metric["map_small"]), print(metric["map_small"]))
+    return {
+                "map" : metrics["map"].item(),
+                "map_50" : metrics["map_50"].item(),
+                "map_75" : metrics["map_75"].item(),
+            }
+    
+
+# Do not delete the plots!!! Need to do it for every detector!!!
+def collate_fn(batch, image_processor):
+    images = [sample["image"] for sample in batch]
+    # for image in images:
+    #     image.save(f"original_{time.time()}.jpg")
+    image_ids = [sample["image_id"] for sample in batch]
+    formatted_annotations = [{"image_id": sample["image_id"], "annotations": sample["annotations"]} for sample in batch]
+
+    inputs = image_processor(images=images, annotations=formatted_annotations, return_tensors="pt")
+    # mean = [0.485, 0.456, 0.406]  # Example: ImageNet Mean
+    # std = [0.229, 0.224, 0.225]   # Example: ImageNet Std
+    # transform = transforms.Compose([
+    #     # transforms.Normalize(mean=[-m/s for m, s in zip(mean, std)], std=[1/s for s in std]),  # Undo standardization
+    #     transforms.ToPILImage()
+    # ])
+    # for pixel_values, labels in zip(inputs.pixel_values, inputs.labels):
+    #     img_width, img_height = labels['size'].tolist()
+    #     print(pixel_values.size(), labels['size'])
+    #     bboxes = labels['boxes']
+    #     image_cpy = deepcopy(pixel_values)
+    #     image_cpy = transform(image_cpy)
+    #     draw = ImageDraw.Draw(image_cpy)
+
+    #     for box in bboxes:
+    #         x_center, y_center, width, height = box.tolist()
+    #         x0 = (x_center - width/2) * img_width
+    #         y0 = (y_center - height/2) * img_height
+    #         x1 = (x_center + width/2) * img_width
+    #         y1 = (y_center + height/2) * img_height
+    #         draw.rectangle([x0, y0, x1, y1], outline="green", width=1)
+    #     image_cpy.save(f"{time.time()}.jpg")
+    return inputs
+
+def get_param_groups(model, args):
+    model_modules = dict(model.named_children())
+    invalid_keys = [key for key in args.learning_rates if key not in model_modules]
+    if invalid_keys:
+        raise ValueError(f"Invalid keys in learning_rates: {invalid_keys}. "
+                         f"These are not valid model components. Valid options: {list(model_modules.keys())}")
+    param_groups = []
+    for name, lr in args.learning_rates.items():
+        if args.model_name == "PekingU/rtdetr_v2_r50vd" and name == "model":
+            param_groups.append(
+                {
+                    "params": model_modules[name].backbone.parameters(), 
+                    "lr": float(lr)
+                }
+            )
+        else:
+            param_groups.append(
+                {
+                    "params": model_modules[name].parameters(), 
+                    "lr": float(lr)
+                }
+            )
+    return param_groups
+
+# pick out the hyperparameters and have a save directory
+def main():
+    args = parse_args()
+    print(args)
+    dataset = load_from_disk(args.dataset_path)
+    train_subset = dataset['train'].with_transform(lambda batch: augment_data_point(batch, args))
+    val_subset = dataset['val'].with_transform(validation_transform)
+    test_subset = dataset['test'].with_transform(validation_transform)
+    dataset = {
+        "train": train_subset,
+        "validation": val_subset,
+        "test" : test_subset
+    }
+
+    if args.model_name in ["SenseTime/deformable-detr", "PekingU/rtdetr_v2_r50vd", "microsoft/conditional-detr-resnet-50"]:
+        num_labels = 2
+    else:
+        num_labels = 1
+    model = AutoModelForObjectDetection.from_pretrained(
+        args.model_name,
+        num_labels=num_labels,
+        ignore_mismatched_sizes=True
+    )
+
+    processor = AutoImageProcessor.from_pretrained(
+        args.model_name,
+        do_normalize=False
+    )
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model.to(device)
+        
+    param_groups = get_param_groups(model, args)
+    optimizer = AdamW(param_groups, weight_decay=args.weight_decay)
+
+    # Training arguments
+    # eventually set these to the same as ultralytics !!!!
+    # evaluation always goes through the entire validation dataset
+    training_args = TrainingArguments(
+        output_dir=f"./{args.save_directory}/{os.environ.get('SLURM_JOB_ID')}",
+        num_train_epochs=args.num_train_epochs,
+        max_grad_norm=args.max_grad_norm,
+        per_device_train_batch_size=args.train_batch_size,
+        per_device_eval_batch_size=args.eval_batch_size,
+        dataloader_num_workers=args.dataloader_num_workers,
+        eval_strategy=args.eval_strategy,
+        save_strategy=args.save_strategy,
+        save_total_limit=2,
+        metric_for_best_model="eval_map",
+        greater_is_better=True,
+        load_best_model_at_end=True,
+        eval_do_concat_batches=False,
+        remove_unused_columns=False,
+        dataloader_drop_last=True,
+        lr_scheduler_type=args.lr_scheduler_type,
+        warmup_steps=args.warmup_steps,
+        eval_accumulation_steps=10
+    )
+    
+    print(training_args)
+    # Trainer
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=dataset["train"],
+        eval_dataset=dataset["validation"],
+        data_collator=partial(collate_fn, image_processor=processor),
+        compute_metrics=compute_metrics,
+        callbacks=[
+            EarlyStoppingCallback(
+                early_stopping_patience=args.early_stopping_patience
+            ),
+        ],
+        optimizers=(optimizer, None)
+    )
+
+    # Train
+    trainer.train()
+    model.save_pretrained(f"./{args.save_directory}/{os.environ.get('SLURM_JOB_ID')}/best_model")
+    processor.save_pretrained(f"./{args.save_directory}/{os.environ.get('SLURM_JOB_ID')}/best_model")
+    metrics = trainer.evaluate()
+    pprint(metrics)
+    print("test results")
+    print(f"test dataset length: {len(dataset['test'])}")
+    metrics = trainer.evaluate(dataset["test"])
+    pprint(metrics)
+
+if __name__ == "__main__":
+    main()

object_detector_benchmark/yolo_to_coco.py

@@ -0,0 +1,144 @@
+import os
+import json
+from PIL import Image
+import multiprocessing
+from tqdm import tqdm
+
+# Configuration
+YOLO_DIR = "8_calves_yolo"
+COCO_DIR = "8_calves_coco"
+CATEGORIES = [{"id": 1, "name": "cow"}]
+NUM_WORKERS = multiprocessing.cpu_count()  # Use all available cores
+
+def process_image(args):
+    image_path, label_path, image_id = args
+    try:
+        with Image.open(image_path) as img:
+            width, height = img.size
+    except Exception as e:
+        print(f"Error opening {image_path}: {e}")
+        return None, []
+
+    image_info = {
+        "id": image_id,
+        "file_name": os.path.relpath(image_path, COCO_DIR),
+        "width": width,
+        "height": height,
+    }
+
+    annotations = []
+    if os.path.exists(label_path):
+        try:
+            with open(label_path, "r") as f:
+                lines = f.readlines()
+        except Exception as e:
+            print(f"Error reading {label_path}: {e}")
+            return image_info, []
+
+        for line in lines:
+            parts = line.strip().split()
+            if len(parts) != 5:
+                continue
+
+            try:
+                class_id = int(parts[0])
+                x_center, y_center = float(parts[1]), float(parts[2])
+                w, h = float(parts[3]), float(parts[4])
+            except:
+                print(f"Error parsing line in {label_path}: {line}")
+                continue
+
+            if class_id != 0:
+                continue
+
+            # Convert YOLO to COCO bbox with boundary checks
+            w_abs = w * width
+            h_abs = h * height
+            x_min = max(0, (x_center * width) - w_abs/2)
+            y_min = max(0, (y_center * height) - h_abs/2)
+            w_abs = min(width - x_min, w_abs)
+            h_abs = min(height - y_min, h_abs)
+
+            annotations.append({
+                "image_id": image_id,
+                "category_id": 1,
+                "bbox": [x_min, y_min, w_abs, h_abs],
+                "area": w_abs * h_abs,
+                "iscrowd": 0,
+            })
+
+    return image_info, annotations
+
+def process_split(split):
+    split_dir = os.path.join(YOLO_DIR, split)
+    image_dir = os.path.join(split_dir, "images")
+    label_dir = os.path.join(split_dir, "labels")
+
+    if not os.path.exists(image_dir):
+        print(f"Skipping {split} - no image directory")
+        return
+
+    # Get sorted list of image files
+    image_files = sorted([
+        f for f in os.listdir(image_dir) 
+        if f.lower().endswith(".png")
+    ])
+
+    # Prepare arguments for parallel processing
+    tasks = []
+    for idx, image_file in enumerate(image_files, 1):
+        image_path = os.path.join(image_dir, image_file)
+        label_path = os.path.join(label_dir, os.path.splitext(image_file)[0] + ".txt")
+        tasks.append((image_path, label_path, idx))
+
+    # Process images in parallel
+    results = []
+    with multiprocessing.Pool(processes=NUM_WORKERS) as pool:
+        for result in tqdm(pool.imap(process_image, tasks), 
+                         total=len(tasks), 
+                         desc=f"Processing {split}"):
+            results.append(result)
+
+    # Collect results
+    images = []
+    annotations = []
+    annotation_id = 1
+    
+    for image_info, image_anns in results:
+        if image_info is None:
+            continue
+            
+        images.append(image_info)
+        for ann in image_anns:
+            ann["id"] = annotation_id
+            annotations.append(ann)
+            annotation_id += 1
+
+    # Create COCO format
+    coco_data = {
+        "info": {
+            "description": "COCO Dataset converted from YOLO format",
+            "version": "1.0",
+            "year": 2023,
+            "contributor": "",
+        },
+        "licenses": [],
+        "categories": CATEGORIES,
+        "images": images,
+        "annotations": annotations,
+    }
+
+    # Save to JSON
+    output_path = os.path.join(COCO_DIR, f"{split}.json")
+    with open(output_path, "w") as f:
+        json.dump(coco_data, f, indent=2)
+
+    print(f"Saved {split} with {len(images)} images and {len(annotations)} annotations")
+
+def main():
+    os.makedirs(COCO_DIR, exist_ok=True)
+    for split in ["train", "val", "test"]:
+        process_split(split)
+
+if __name__ == "__main__":
+    main()