luksamuk/hand-tracking-vlm-dataset

Hand Tracking VLM Dataset

Dataset for VLM fine-tuning of hand bounding box detection. Combines positive samples from HaGRID (palm + fist gestures) with negative samples from COCO (no-person and person-without-visible-wrists). Contains positive samples (hands visible) and negative samples (no hands) in conversation format compatible with Unsloth/TRL vision fine-tuning.

Dataset Composition

Category	Count	Source	License
Positive — 1 hand	8,578	HaGRID (palm + fist)	CC BY-SA 4.0
Positive — 2 hands (oversampled x2)	2,844	HaGRID, duplicated	CC BY-SA 4.0
Negative — HaGRID patches	2,000	Cropped regions without hands	CC BY-SA 4.0
Negative — COCO val2017 (no person)	2,307	Images without any person annotation	CC BY 4.0
Negative — COCO val2017 (person, no wrists)	594	Images with person but wrists not visible	CC BY 4.0
Total	16,323	30% negatives	CC BY-SA 4.0 (overall)

Data Format

Each line is a JSON object with a conversations array:

Positive example (hand visible)

{
  "conversations": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "data/hagrid/hagrid_dataset/palm/abcdef.jpg"},
        {"type": "text", "text": "Detect all hands in the image."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "[{\"label\":\"hand\",\"bbox\":[0.23,0.45,0.67,0.89]}]"}
      ]
    }
  ]
}

Negative example (no hand visible)

{
  "conversations": [
    {
      "role": "user",
      "content": [
        {"type": "image", "image": "data/hagrid/negative_images_coco/coco_bg_0001.jpg"},
        {"type": "text", "text": "Detect all hands in the image."}
      ]
    },
    {
      "role": "assistant",
      "content": [
        {"type": "text", "text": "[]"}
      ]
    }
  ]
}

Coordinates are normalized 0-1 [x1, y1, x2, y2]. Empty array [] when no hands are visible.

How to Reproduce

This dataset requires downloading images from two sources. The JSONL contains paths only, not the images themselves.

Step 1: Download HaGRID annotations + images

# Annotations (33MB)
cd ~/hand-tracking-ft/data/hagrid
wget https://rndml-team-cv.obs.ru-moscow-1.hc.sbercloud.ru/datasets/hagrid/hagrid_dataset_new_554800/annotations.zip
unzip annotations.zip -d annotations_json

# Images: palm + fist gestures (~85GB total)
wget https://rndml-team-cv.obs.ru-moscow-1.hc.sbercloud.ru/datasets/hagrid/hagrid_dataset_new_554800/hagrid_dataset/palm.zip
unzip palm.zip -d hagrid_dataset
wget https://rndml-team-cv.obs.ru-moscow-1.hc.sbercloud.ru/datasets/hagrid/hagrid_dataset_new_554800/hagrid_dataset/fist.zip
unzip fist.zip -d hagrid_dataset

Source: https://github.com/hukenovs/hagrid

Step 2: Generate negative patches from HaGRID

Negative patches are cropped regions of HaGRID images that do not contain hands. Requires the HaGRID images from Step 1.

import json, random
from pathlib import Path
from PIL import Image

HAGRID_DIR = Path("data/hagrid")
ANNOTATIONS_DIR = HAGRID_DIR / "annotations_json" / "train"
IMAGES_DIR = HAGRID_DIR / "hagrid_dataset"
OUTPUT_DIR = HAGRID_DIR / "negative_images"
OUTPUT_DIR.mkdir(parents=True, exist_ok=True)

random.seed(42)
count = 0

for gesture in ["palm", "fist"]:
    with open(ANNOTATIONS_DIR / f"{gesture}.json") as f:
        annotations = json.load(f)
    for image_id, ann in random.sample(list(annotations.items()), len(annotations)):
        if count >= 2000:
            break
        image_path = IMAGES_DIR / gesture / f"{image_id}.jpg"
        if not image_path.exists():
            continue
        img = Image.open(image_path)
        w, h = img.size
        bboxes = ann.get("bboxes", [])
        if not bboxes:
            continue
        # Convert normalized bboxes to pixel coords
        pixel_bboxes = [(int(bx*w), int(by*h), int((bx+bw)*w), int((by+bh)*h))
                        for bx, by, bw, bh in bboxes]
        # Try random patches that don't overlap with any bbox
        for _ in range(20):
            patch_size = random.randint(256, 640)
            if w < patch_size or h < patch_size:
                continue
            px = random.randint(0, w - patch_size)
            py = random.randint(0, h - patch_size)
            patch = (px, py, px + patch_size, py + patch_size)
            if not any(not (patch[2] <= bx1 or patch[0] >= bx2 or
                           patch[3] <= by1 or patch[1] >= by2)
                       for bx1, by1, bx2, by2 in pixel_bboxes):
                img.crop(patch).save(OUTPUT_DIR / f"neg_{count:04d}.jpg", quality=90)
                count += 1
                break

Step 3: Download COCO val2017 negatives

Download COCO 2017 validation images and annotations, then filter to images without any person annotation.

# Download annotations (241MB)
cd ~/hand-tracking-ft/data
mkdir -p coco_tmp && cd coco_tmp
wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip
unzip annotations_trainval2017.zip annotations/instances_val2017.json

# Download val2017 images (1GB)
wget http://images.cocodataset.org/zips/val2017.zip
unzip val2017.zip
cd ../..

# Filter: keep only images without "person" annotation
from pycocotools.coco import COCO
from pathlib import Path
import shutil

coco = COCO("data/coco_tmp/annotations/instances_val2017.json")
person_ids = set()
for cid in coco.getCatIds(catNms=["person"]):
    person_ids.update(coco.getImgIds(catIds=cid))
bg_ids = set(coco.getImgIds()) - person_ids

out = Path("data/hagrid/negative_images_coco")
out.mkdir(parents=True, exist_ok=True)
for i, img_id in enumerate(bg_ids):
    info = coco.loadImgs([img_id])[0]
    src = Path(f"data/coco_tmp/val2017/{info['file_name']}")
    if src.exists():
        shutil.copy(src, out / f"coco_bg_{i:04d}.jpg")

# Cleanup
shutil.rmtree("data/coco_tmp")

Source: https://cocodataset.org/

Step 3b: Download COCO val2017 person-without-hands negatives

Some images contain persons but their wrists are occluded (hands in pockets, behind body, or out of frame). These teach the model that "person in frame" does not guarantee "hand visible".

Uses the same COCO val2017 images from Step 3, but with person_keypoints_val2017.json to filter by wrist visibility.

# The keypoints annotations are in the same ZIP from Step 3
# If already extracted, the file is: data/coco_tmp/annotations/person_keypoints_val2017.json
# If not, re-download:
cd ~/hand-tracking-ft/data
mkdir -p coco_kp && cd coco_kp
wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip
unzip annotations_trainval2017.zip annotations/person_keypoints_val2017.json
cd ../..

# Filter: images with person annotation but wrists NOT visible (keypoint flag != 2)
from pycocotools.coco import COCO
from pathlib import Path
import requests

coco = COCO("data/coco_kp/annotations/person_keypoints_val2017.json")

# COCO keypoints: index 9 = left_wrist, index 10 = right_wrist
# Visibility flag: 0=not labeled, 1=labeled but not visible, 2=visible
LEFT_WRIST = 9
RIGHT_WRIST = 10

person_img_ids = set(coco.getImgIds(catIds=[1]))
person_no_wrists = []

for img_id in person_img_ids:
    ann_ids = coco.getAnnIds(imgIds=[img_id], catIds=[1])
    anns = coco.loadAnns(ann_ids)
    wrists_visible = False
    for ann in anns:
        kps = ann.get("keypoints", [])
        if len(kps) >= 3 * (RIGHT_WRIST + 1):
            if kps[LEFT_WRIST * 3 + 2] == 2 or kps[RIGHT_WRIST * 3 + 2] == 2:
                wrists_visible = True
                break
    if not wrists_visible:
        person_no_wrists.append(img_id)

print(f"Images with person but no visible wrists: {len(person_no_wrists)}")

# Download these images
output_dir = Path("data/hagrid/negative_images_person_no_hands")
output_dir.mkdir(parents=True, exist_ok=True)

count = 0
for img_id in person_no_wrists:
    info = coco.loadImgs([img_id])[0]
    out_path = output_dir / f"person_no_hands_{count:04d}.jpg"
    try:
        r = requests.get(info["coco_url"], timeout=15)
        if r.status_code == 200 and len(r.content) > 100:
            with open(out_path, "wb") as f:
                f.write(r.content)
            count += 1
    except:
        pass  # skip failed downloads

# Verify all images are valid (remove corrupted)
from PIL import Image
for f in output_dir.glob("*.jpg"):
    try:
        Image.open(f).verify()
    except:
        f.unlink()
        print(f"Removed corrupted: {f}")

print(f"Downloaded {len(list(output_dir.glob('*.jpg')))} valid images")

# Cleanup
rm -rf data/coco_kp

Step 4: Run prepare_dataset.py

The prepare_dataset.py script processes HaGRID annotations (palm + fist), oversamples 2-hand examples, and adds both negative sources. See the tutorial repository for the full script.

python prepare_dataset.py

Output: data/dataset.jsonl (16,323 examples)

Step 5: Split into train/val

import json
with open("data/dataset.jsonl") as f:
    examples = [json.loads(line) for line in f]
split = int(len(examples) * 0.9)
with open("data/train.jsonl", "w") as f:
    for ex in examples[:split]:
        f.write(json.dumps(ex, ensure_ascii=False) + "\n")
with open("data/val.jsonl", "w") as f:
    for ex in examples[split:]:
        f.write(json.dumps(ex, ensure_ascii=False) + "\n")

Transformations Applied

1. Bbox conversion: HaGRID [x, y, w, h] normalized 0-1 → [x1, y1, x2, y2] normalized 0-1
2. Label normalization: all detections labeled "hand" (gesture labels discarded)
3. Oversampling: 2-hand examples (2+ bboxes) duplicated to balance 1-hand vs 2-hand ratio
4. Negative samples: 2,000 HaGRID patches + 2,307 COCO images without persons, response []
5. Format conversion: COCO-style annotations → VLM conversation format with typed content items
6. Content order augmentation (CDA): 50% of examples have image/text order swapped to reduce positional bias (seed=3407)

Why Three Negative Sources

The dataset went through four iterations of negative sampling. Each addressed a specific failure mode observed during testing:

1. HaGRID patches (2,000 images) — cropped regions of HaGRID training images outside hand bboxes. Addressed the basic "always detects a hand" bias. Same domain (illumination, resolution) as positives.

2. COCO no-person (2,307 images) — COCO val2017 images with no "person" annotation. Added domain diversity (landscapes, objects, food). Reduced false positives on empty scenes.

3. COCO person-no-wrists (594 images) — COCO val2017 images with person annotation but wrists not visible in keypoints. This was the final piece. Without it, the model associated "person in frame" with "hand must exist", producing false positives whenever a person was on camera without their hands raised.

The combination of all three sources provides complementary coverage: same-domain negatives (HaGRID), diverse scene negatives (COCO no-person), and the critical person-without-hands case (COCO person-no-wrists).

Content Order Augmentation (Positional Bias)

During testing, the Q8_0 quantization showed sensitivity to the order of items in the user content array. With image before text, the model correctly returned [] for empty scenes. With text before image, it produced false positives.

To mitigate this, Counterfactual Data Augmentation (CDA) was applied: each example has a 50% chance of having the image/text order swapped. The augmentation uses seed 3407 for reproducibility.

This is a rule-of-thumb decision: the technique is established in NLP bias mitigation literature but has not been specifically validated for small VLMs (450M). The cost is zero (same data, same config), and the seed ensures reproducibility.

References:

• AAAI 2024: "Enhance Modality Robustness in Text-Centric Multimodal Alignment with Dynamic Input Order Permutations"
• ACL 2024: "Unveiling Selection Biases: Exploring Order and Token Sensitivity in LLMs"
• arXiv 2404.01430: "Position-Aware Parameter Efficient Fine-Tuning Approach for Reducing Positional Bias in LLMs"
• AWS bias-mitigation-for-llms: Counterfactual Data Augmentation (CDA) technique

License

CC BY-SA 4.0 — inherited from HaGRID (the most restrictive source).

• HaGRID: CC BY-SA 4.0 (Share-Alike requires derivatives to use same license)
• COCO: CC BY 4.0 (compatible with CC BY-SA 4.0 — can be relicensed under more restrictive terms)

Attribution

• HaGRID: Kapitanov, A., Kvanchiani, K., Nagaev, A., Kraynov, R., Makhliarchuk, A. "HaGRID -- HAnd Gesture Recognition Image Dataset." WACV 2024. https://github.com/hukenovs/hagrid
• COCO: Lin, T.-Y., et al. "Microsoft COCO: Common Objects in Context." ECCV 2014. https://cocodataset.org
• COCO keypoints: Same COCO dataset, person keypoints used to filter images where wrists are not visible

Citation

If you use this dataset, please cite both sources:

@InProceedings{Kapitanov_2024_WACV,
    author    = {Kapitanov, Alexander and Kvanchiani, Karina and Nagaev, Alexander and Kraynov, Roman and Makhliarchuk, Andrei},
    title     = {HaGRID -- HAnd Gesture Recognition Image Dataset},
    booktitle = {Proceedings of the IEEE/CVF Winter Conference on Applications of Computer Vision (WACV)},
    month     = {January},
    year      = {2024},
    pages     = {4572-4581}
}

@InProceedings{lin2014coco,
    author    = {Lin, Tsung-Yi and Maire, Michael and Belongie, Serge and Hays, James and Perona, Pietro and Ramanan, Deva and Doll{\'a}r, Piotr and Zitnick, C. Lawrence},
    title     = {Microsoft COCO: Common Objects in Context},
    booktitle = {European Conference on Computer Vision (ECCV)},
    year      = {2014}
}