Blame for README.md

---
pretty_name: EgoHome
license: cc-by-nc-4.0
task_categories:
- video-classification
- object-detection
language:
- en
tags:
- egocentric
- hands
- temporal-segmentation
- action-recognition
- ego4d
- robotics
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: test
    path: data/test/*
---

# Perceptron EgoHome: A new benchmark for dense, sub-second egocentric understanding

*The first egocentric benchmark to feature four types of annotations per video and segments as short as 100 ms*

EgoHome-2h is 137 human-annotated egocentric clips of household chores (1.99 h, 1920×1080, 30 fps), each with hand boxes, subtasks, hand actions and hand captions. The [blog post](https://www.perceptron.inc/blog/egohome) has the full write-up and videos; the scoring code and prompts are on [GitHub](https://github.com/perceptron-ai-inc/egohome_public_release).

## At a glance

|   | EgoHome (Perceptron) | WGO-Bench |
|---|---|---|
| Total hours | 1.99 h (137 clips from 46 videos) | 1.24 h (100 episodes) |
| Domain | Household chores, egocentric (head-mounted camera) | Robot manipulation (DROID 50, RoboCOIN Galaxea 25) + egocentric HomER (25) |
| Human annotated? | Yes (synthetic seed, human-corrected, reviewed) | Yes |
| Hand box annotations? | Yes: 417,912 boxes, 30 fps, left / right | No |
| Subtask annotations? | Yes: 1,924 segments | Yes: 743 segments |
| Left/right hand actions? | Yes: 5,032 segments, 118 Ego4D verbs | No |
| Left/right hand captions? | Yes: 5,277 segments | No |
| Shortest segment | 0.10 s | 0.19 s |
| Segments < 0.5 s | 773 | 15 |
| Mean subtask length | 3.57 s | 5.77 s |
| Mean segment length, all types | 2.62 s | 5.77 s (subtasks only) |
| Flexible time boundary metric? | Yes: permissible subsegment Jaccard | No: one-to-one matching at IoU ≥ 0.75 |

**Table 1.** EgoHome and WGO-Bench at a glance.

![Cumulative distribution of segment durations on a log scale: EgoHome subtasks, hand actions and hand captions against WGO-Bench](assets/segment_durations.png)

**Figure 1.** Cumulative distribution of segment durations (log scale). EgoHome’s hand actions and captions are much shorter than WGO-Bench’s subtasks: about a third of them last under one second.

## Evaluation metrics

### Hand box metric: centroid hit fraction

To measure hand box prediction accuracy, we simply ask each model to produce timestamped bounding boxes for the hand locations throughout the video. For every frame with a human-annotated hand, we check whether the centroid of the model’s box for that hand falls inside the human box, then divide by the number of annotated hand-frames, plus any boxes the model predicts outside the annotated range.

Models that sample fewer frames per second are still scored on every annotated frame: between two of a model’s boxes, we linearly interpolate its prediction. A model sampled at 1 fps therefore only loses credit where the hand moves off the straight-line path between its samples.

![Centroid hit on one 2 s span: 107 of 120 frame-hands hit, a score of 0.89](assets/hand_box_metric_3d.gif)

**Figure 2.** We stack two seconds of frames in time and check every predicted centroid against the human box.

### Subtask, action, and hand caption metric: permissible subsegment Jaccard

We developed our subtask correctness metric while attempting to find a fair way to calibrate our annotators. We initially used a metric similar to WGO-Bench’s semantic F1, which performs bipartite matching between the target and prediction and then calculating F1 between the predicted and target sets.

Bipartite matching, which is common in object segmentation benchmarks, allows each ground truth segment to be paired with exactly one predicted segment. In other words, during scoring, the mapping between predicted and ground truth is one-to-one.

We’ve found, however, that there are many valid ways to divide up the timeline in a video. Even if you show the same annotator the same video, in one sitting they may break washing the dishes down into a single task or they may break it down into many smaller segments.

Rather than encouraging models to overfit to one particular choice of temporal granularity, we opted to allow the ground truth and predicted segments to match to each other in a many-to-many mapping, and we’ve tailored our LLM as judge prompt to permit predicted tasks to be subtasks of the ground truth or vice versa.

We call our metric **permissible subsegment Jaccard.**

### Worked example: the stairs

Let’s say the ground truth labeled the time span 0 to 5s as one segment, “sweeping the stairs”.

The table below demonstrates how various predictions would be graded under our many-to-many permissible subsegment Jaccard, vs the one-to-one WGO-Bench semantic F1.

| Model output | Permissible subsegment Jaccard | WGO-Bench semantic F1 |
|---|---|---|
| A. 0–5 s: “sweeping the stairs” | (5 + 5) / (5 + 5) = **1.0** | IoU 1.0, labels match: 1 match → **1.0** |
| B. 0–2 s: “sweeping the top stair”; 2–5 s: “sweeping the bottom stair” | both pieces agree: (2 + 3 + 5) / (5 + 5) = **1.0** | IoUs 0.4 and 0.6, both below 0.75: 0 matches of 2 predicted, 1 gold → **0.0** |
| C. 0–3 s: “sweeping the stairs”; 3–5 s: “putting the broom away” | first piece agrees: (3 + 3) / (5 + 5) = **0.6** | IoU 0.6, below 0.75 → **0.0** |
| D. 0–5 s: “carrying the broom” | judge says it’s a different action → **0.0** | timing matches but the label doesn’t → **0.0** |

**Table 2.** Four cases of model output for one human-labeled (ground truth) segment, “sweeping the stairs” from 0 to 5 s, scored by permissible subsegment Jaccard and WGO-Bench semantic F1. The ground-truth track is the human label; the model track is the prediction. Solid segments agree with the ground truth under the judge; dashed segments do not.

While calibrating annotators, we frequently ran into Case B, as illustrated in Table 2: a valid, more detailed breakdown gets a score of zero under one-to-one matching and full credit under ours. Case C shows we still give partial credit for the part the model got right, where a fixed IoU cutoff gives nothing. (WGO-Bench’s semantic F1 pairs segments one-to-one, counts a pair only when its temporal IoU is at least 0.75 and the judge accepts the labels).

We found that this metric adhered much more closely to subjective measures of fairness when evaluating human annotators’ performance during calibration, thus we opted to release it as our official metric for the benchmark.

The formal definitions follow below, and the scoring code is in our [GitHub repository](https://github.com/perceptron-ai-inc/egohome_public_release).

### Metric formulas

#### Centroid hit fraction

Mathematically this can be expressed as

$$
\mathrm{CHF} = \frac{\displaystyle\sum_{(f,h) \in G} \mathbb{1}\left[\mathrm{Centroid}(\hat{p}_{f,h}) \in g_{f,h}\right]}{|G| + |P_{\text{out}}|} \tag{1}
$$

Where $G$ is the set of human-annotated frames at 30 fps and $g_{f,h}$ is the ground truth box for hand $h$ on frame $f$. $\hat{p}_{f,h}$ is the model’s box for hand $h$ at frame $f$: either a box directly emitted for that frame, or the linear interpolation between its two nearest boxes; frames outside the span the model covered count as misses. $P_{\text{out}}$ is the set of frames for which the model has a box but the ground truth doesn’t. The indicator in the numerator is 1 when the centroid of $\hat{p}_{f,h}$ falls inside $g_{f,h}$.

#### Permissible subsegment Jaccard

It can be expressed mathematically as follows:

$$
\mathrm{PSJ}(P, T) = \frac{\displaystyle\sum_{p \in P} m(p, T) + \sum_{t \in T} m(t, P)}{\displaystyle\sum_{p \in P} |I(p)| + \sum_{t \in T} |I(t)|} \tag{2}
$$

$$
m(s, S) = \Bigl|\, I(s) \cap \bigcup_{\substack{s' \in S \\ J(s, s') = 1}} I(s') \,\Bigr| \tag{3}
$$

Let $P$ and $T$ be the predicted and ground-truth segments. Each segment $s$ has a time interval $I(s)$ and a label, and $|\cdot|$ is duration. $J(s, s') \in \{0, 1\}$ is the LLM judge’s verdict on whether two labels are permissible matches: the same action, or one a subtask of the other. $m(s, S)$ is the portion of $s$’s duration that overlaps some segment in $S$ that the judge accepts.

## Results

![Subtask score against subtask cost per video-hour, log scale; the dashed line is the Pareto frontier](assets/subtask_pareto.png)

**Figure 3.** Both Perceptron Egocentric settings sit on the Pareto frontier; nothing we measured beats them on both score and cost.

### EgoHome results

| System | Subtask ↑ | Hand action ↑ | Hand caption ↑ | Hand box ↑ | Subtask $ / video-hour ↓ |
|---|---:|---:|---:|---:|---:|
| Perceptron Egocentric, 4 fps (default) | 0.787 | 0.421 | 0.613 | 0.942 | $9 |
| Perceptron Egocentric, 8 fps (option) | **0.798** | 0.421 | 0.626 | 0.973 | ≈ $15 |
| GPT-6 Astra, 4 fps frames | 0.797 | **0.498** | **0.749** | **0.979** | ≈ $76 |
| GPT-6 Astra, 1 fps frames | 0.775 | 0.479 | 0.724 | 0.865 | ≈ $20 |
| Gemini 3.8 Flash, 4 fps video | 0.663 | 0.405 | 0.558 | 0.454 | **≈ $1.3** |
| Gemini 3.8 Flash, 1 fps video | 0.639 | 0.390 | 0.557 | 0.574 | n/r |
| Glimpse (Elorian), 4 fps video | 0.689 | 0.390 | 0.560 | 0.489 | ≈ $2.8 |
| Glimpse (Elorian), 1 fps video | 0.590 | 0.353 | 0.560 | 0.247 | n/r |
| Argus (Pantheon), GPT-6 Astra | 0.367 | 0.336 | 0.593 | — | $24.17 |
| Argus (Pantheon), Midcentury's settings: GPT-6.1 Sol | 0.315 | 0.327 | 0.590 | — | $7.76 |
| FLORA (NVIDIA) | 0.747 | — | — | — | $35.39 |

**Table 3.** EgoHome-2h results by system. Permissible subsegment Jaccard (subtask, hand action, hand caption) and centroid hit fraction (hand box). Best in bold. — = the system does not produce that annotation. n/r = not reported for that setting. Inputs: GPT-6 Astra as timestamped frames (768 px), Gemini and Glimpse as native video. All scores cover all 137 clips; Perceptron results are averaged across three runs at 4 fps and two runs at 8 fps, and other systems were run once. Gemini stamps its boxes half a sampling interval early, so its hand box scores use timestamps shifted by 0.5 s at 1 fps and 0.125 s at 4 fps. Subtask $ uses Perceptron's customer price, direct API charges, or FLORA's GPU runtime cost; Argus costs also include hand labels, and costs marked ≈ are estimates of the subtask share of a run billed across all tasks.

### Fine-grained results by gold segment length

**Subtask**

| System | All ↑ | < 0.5 s ↑ | 0.5–1 s ↑ | > 1 s ↑ |
|---|---:|---:|---:|---:|
| Perceptron Egocentric, 4 fps (default) | 0.787 | 0.559 | 0.615 | 0.814 |
| Perceptron Egocentric, 8 fps (option) | **0.798** | 0.555 | **0.672** | 0.824 |
| GPT-6 Astra, 4 fps frames | 0.797 | 0.503 | 0.649 | **0.831** |
| GPT-6 Astra, 1 fps frames | 0.775 | **0.595** | 0.500 | 0.807 |
| Gemini 3.8 Flash, 4 fps video | 0.663 | 0.375 | 0.392 | 0.695 |
| Gemini 3.8 Flash, 1 fps video | 0.639 | 0.361 | 0.320 | 0.670 |
| Glimpse (Elorian), 4 fps video | 0.689 | 0.380 | 0.410 | 0.720 |
| Glimpse (Elorian), 1 fps video | 0.590 | 0.328 | 0.279 | 0.616 |
| Argus (Pantheon), GPT-6 Astra | 0.367 | 0.135 | 0.133 | 0.381 |
| Argus (Pantheon), Midcentury's settings: GPT-6.1 Sol | 0.315 | 0.098 | 0.106 | 0.332 |
| FLORA (NVIDIA) | 0.747 | 0.579 | 0.615 | 0.777 |
| *Clips with a step of this length* | 137 | 24 | 60 | 137 |

**Table 4.** Subtask score by the length of the gold segment. Best in bold.

**Hand action**

| System | All ↑ | < 0.5 s ↑ | 0.5–1 s ↑ | > 1 s ↑ |
|---|---:|---:|---:|---:|
| Perceptron Egocentric, 4 fps (default) | 0.421 | 0.298 | 0.286 | 0.461 |
| GPT-6 Astra, 4 fps frames | **0.498** | **0.422** | **0.415** | **0.531** |
| GPT-6 Astra, 1 fps frames | 0.479 | 0.341 | 0.355 | 0.520 |
| Gemini 3.8 Flash, 4 fps video | 0.405 | 0.206 | 0.273 | 0.435 |
| Gemini 3.8 Flash, 1 fps video | 0.390 | 0.191 | 0.252 | 0.436 |
| Glimpse (Elorian), 4 fps video | 0.390 | 0.193 | 0.212 | 0.433 |
| Glimpse (Elorian), 1 fps video | 0.353 | 0.212 | 0.185 | 0.392 |
| Argus (Pantheon), GPT-6 Astra | 0.336 | 0.321 | 0.268 | 0.358 |
| Argus (Pantheon), Midcentury's settings: GPT-6.1 Sol | 0.327 | 0.262 | 0.205 | 0.355 |

**Table 5.** Hand action score by the length of the gold segment. Best in bold.

**Hand caption**

| System | All ↑ | < 0.5 s ↑ | 0.5–1 s ↑ | > 1 s ↑ |
|---|---:|---:|---:|---:|
| Perceptron Egocentric, 4 fps (default) | 0.613 | 0.447 | 0.446 | 0.678 |
| GPT-6 Astra, 4 fps frames | **0.749** | **0.560** | **0.642** | **0.830** |
| GPT-6 Astra, 1 fps frames | 0.724 | 0.415 | 0.575 | 0.800 |
| Gemini 3.8 Flash, 4 fps video | 0.558 | 0.343 | 0.379 | 0.618 |
| Gemini 3.8 Flash, 1 fps video | 0.557 | 0.295 | 0.383 | 0.619 |
| Glimpse (Elorian), 4 fps video | 0.560 | 0.281 | 0.351 | 0.625 |
| Glimpse (Elorian), 1 fps video | 0.560 | 0.264 | 0.337 | 0.631 |
| Argus (Pantheon), GPT-6 Astra | 0.593 | 0.414 | 0.490 | 0.647 |
| Argus (Pantheon), Midcentury's settings: GPT-6.1 Sol | 0.590 | 0.433 | 0.441 | 0.648 |

**Table 6.** Hand caption score by the length of the gold segment. Best in bold.

## Using the dataset

```python
from datasets import load_dataset

ds = load_dataset("PerceptronAI/EgoHome", split="test")
row = ds[0]
row["video"]          # the clip (decoded with torchcodec)
row["subtasks"]       # [{"start": 0.0, "end": 1.74, "label": "..."}, ...]
row["hand_actions"]   # {"left": [...], "right": [...]}, Ego4D verb labels
row["hand_captions"]  # {"left": [...], "right": [...]}
row["hand_boxes"]     # [{"t": 0.0, "left": [x_min, y_min, x_max, y_max] | None, "right": ...}, ...]
```

To get the annotations without the videos, download `data/test/metadata.jsonl`.

There is one row per clip. Times are seconds from the clip start. Boxes are `[x_min, y_min, x_max, y_max]`, normalized to 0–1000 (x over width, y over height).

| Column | Contents |
|---|---|
| `video` / `file_name` | The mp4 |
| `clip_id`, `source_video_id`, `clip_start_sec` | Clip identity (clips are cut from longer source videos) |
| `duration_sec`, `fps`, `width`, `height` | Video properties |
| `hand_boxes` | `[{t, left, right}]`, one entry per annotated frame; a hand is `null` when off screen |
| `subtasks` | `[{start, end, label}]` |
| `hand_actions` | `{left: [{start, end, label}], right: [...]}`; labels are Ego4D FHO verb classes |
| `hand_captions` | `{left: [{start, end, label}], right: [...]}` |

## License

The EgoHome dataset is released under the Creative Commons Attribution-NonCommercial 4.0 license (CC BY-NC 4.0). As an additional permission, anyone, including commercial organizations, may use EgoHome to evaluate models and publish the results. Other commercial uses, such as selling the data or training commercial models on it, are not permitted.

## Citation

```bibtex
@article{perceptron2026egohome,
  author = {PerceptronAI},
  title = {Perceptron EgoHome: A new benchmark for dense, sub-second egocentric understanding},
  journal = {PerceptronAI Research Blog},
  year = {2026},
  note = {https://perceptron.inc/blog/egohome},
}
```