martinctl/how2sign-asl-landmarks

How2Sign ASL Landmarks

Sentence-level MediaPipe landmark cache for the How2Sign ASL translation dataset. This dataset stores preprocessed landmark arrays only, not MP4 clips.

The rows come from the local How2Sign realigned CSV files and front-view raw videos. Each successful row is one sentence segment sampled at a 25 FPS cap and stored in compressed NPZ shards.

Why This Dataset Exists

The public How2Sign data has known alignment/completeness issues: some text rows do not correspond to usable front-view video data, and some timestamps extend beyond the available local video duration. Instead of silently dropping those rows, this dataset records every expected row as either:

• a successful landmark sample in metadata.parquet
• a documented failure in failures.parquet

This makes training splits reproducible and makes missing source data explicit.

Contents

Expected rows from the realigned CSVs: 35,263

Successful landmark rows:

split	rows
train	31,088
val	1,739
test	2,349
total	35,176

Recorded failures:

split	rows
train	77
val	2
test	8
total	87

Failure classes:

class	rows	meaning
start_after_video_end	74	CSV timestamp starts after the local video ends
in_video_range_decode_failed	13	timestamp is inside the reported duration, but OpenCV/FFmpeg cannot decode that region

The 13 decode failures come from one locally corrupted/truncated raw video region. Re-downloading only that one MP4 was not possible from the available archive layout, so the failures are kept and documented.

Files

• metadata.parquet: one row per successful sentence segment.
• failures.parquet: one row per expected segment that could not be generated.
• audit_report.json: integrity summary for the generated dataset.
• preprocessing_config.json: extraction settings and landmark schema.
• feature_names.json: names of the geometric feature columns.
• shards/*.npz: compressed landmark arrays.
• viewer/*.parquet: small split-specific index files used by the Hugging Face Dataset Viewer.

The viewer/*.parquet files duplicate only the metadata rows so the Hub can display train, validation, and test splits. The actual landmark arrays remain in shards/*.npz.

Metadata Columns

Important columns in metadata.parquet:

• split
• sentence_id
• sentence_name
• video_id
• video_name
• start
• end
• duration
• sentence
• sample_key
• n_frames
• source_fps
• frame_width
• frame_height
• schema_version
• shard_file

sentence_name is the stable unique identifier used with split. SENTENCE_ID alone is not unique enough for this preprocessed dataset.

Array Schema

Each metadata row points to one NPZ shard and one sample_key. Arrays are named:

<sample_key>__landmarks_image
<sample_key>__landmarks_world
<sample_key>__features_geometric
<sample_key>__valid_mask
<sample_key>__timestamps_ms
<sample_key>__handedness_scores

Shapes:

array	shape	dtype	notes
landmarks_image	(T, 128, 3)	float32	normalized image coordinates
landmarks_world	(T, 128, 3)	float32	world coordinates where MediaPipe provides them
features_geometric	(T, 36)	float32	deterministic geometric features
valid_mask	(T, 128)	bool	landmark detection mask
timestamps_ms	(T,)	float32	source-video timestamps
handedness_scores	(T, 2)	float32	left/right hand confidence scores

Landmark blocks:

block	indices	count
pose	0:33	33
left hand	33:54	21
right hand	54:75	21
ASL face subset	75:128	53

The face subset contains MediaPipe face indices for lips, brows, eyes, and nose. See preprocessing_config.json for the exact index list.

Geometric Features

features_geometric contains 36 deterministic features computed from landmarks_image:

• left/right finger curl
• left/right hand openness
• wrist distances to shoulders, nose, mouth center, and torso center
• two-hand distances between wrists, palms, and fingertips
• elbow angles
• forearm length normalized by shoulder width
• mouth opening, mouth width, and eye distance proxies

The exact column order is stored in feature_names.json.

These features are convenience features. For research experiments, the landmark arrays remain the primary artifact, and features can be recomputed or extended later.

Loading Example

from pathlib import Path
import numpy as np
import pandas as pd

root = Path("data/how2sign_landmarks_hf")
metadata = pd.read_parquet(root / "metadata.parquet")

# Recommended first-pass filter for training stability.
metadata = metadata[metadata["n_frames"] >= 10].reset_index(drop=True)

row = metadata.iloc[0]
with np.load(root / row["shard_file"]) as shard:
    key = row["sample_key"]
    landmarks = shard[f"{key}__landmarks_image"]
    features = shard[f"{key}__features_geometric"]
    valid_mask = shard[f"{key}__valid_mask"]
    timestamps_ms = shard[f"{key}__timestamps_ms"]

print(landmarks.shape, features.shape, valid_mask.shape, timestamps_ms.shape)
print(row["sentence"])

Recommended Training Filters

Some How2Sign timestamps are extremely short. They are preserved for traceability, but they may not be useful for sequence training.

Suggested first baseline:

• train only on rows from metadata.parquet
• exclude rows with n_frames < 10
• use valid_mask for missing landmarks instead of assuming zero means visible
• keep failures.parquet out of training, but use it for split accounting

Short clip counts:

filter	affected rows
n_frames <= 1	8
n_frames <= 3	48
n_frames <= 5	157
n_frames <= 10	494
n_frames <= 25	1,686

Preprocessing

Generated with:

• MediaPipe Pose Landmarker: lite
• MediaPipe Hand Landmarker
• MediaPipe Face Landmarker
• target FPS cap: 25
• processing unit: source video range, then sentence slicing
• landmark schema: how2sign-landmarks-v1

The generation script is resumable and writes metadata.parquet, failures.parquet, and shard files incrementally.

Integrity Check

The final local integrity check passed:

OK
rows checked: 35176
shards touched: 2534
avg frames: 164.7
avg landmark coverage: 0.790

Feature recomputation was checked on 1,000 random clips with 0 mismatches.

Source Notes

This dataset is derived from How2Sign and should be used under the original dataset terms. It does not redistribute video clips; it only contains preprocessed landmarks, metadata, and failure accounting.