Datasets:

clamepending
/

thread-in-a-ropestack

Error code:   DatasetGenerationError
Exception:    CastError
Message:      Couldn't cast
id: string
type: string
answer: struct<seconds: double, intervals: list<item: list<item: string>>, count: int64, choice: string, mom (... 25 chars omitted)
  child 0, seconds: double
  child 1, intervals: list<item: list<item: string>>
      child 0, item: list<item: string>
          child 0, item: string
  child 2, count: int64
  child 3, choice: string
  child 4, moments: list<item: string>
      child 0, item: string
answer_text: string
tolerance: struct<seconds: double, count: int64, choice: string>
  child 0, seconds: double
  child 1, count: int64
  child 2, choice: string
evidence: list<item: struct<t: double, clock: string, what: string, entity: string, cameras: list<item: string (... 183 chars omitted)
  child 0, item: struct<t: double, clock: string, what: string, entity: string, cameras: list<item: string>, best_cam (... 171 chars omitted)
      child 0, t: double
      child 1, clock: string
      child 2, what: string
      child 3, entity: string
      child 4, cameras: list<item: string>
          child 0, item: string
      child 5, best_camera: string
      child 6, box: list<item: double>
          child 0, item: double
      child 7, visible_fraction: double
      child 8, pixel_check: struct<seen: bool, camera: string, t: double, pixels: int64, needed: string>
          child 0, seen: bool
          child 1, camera: string
          child 2, t: double
          child 3, pixels: int64
          child 4, needed: string
      child 9, frame_t: double
regions: list<item: struct<t0: double, t1: double, label: string, entities: list<item: string>>>
  child 0, item: struct<t0: double, t1: double, label: string, entities: list<item: string>>
      child 0, t0: double
      child 1, t1: double
      child 2, label: string
      child 3, entities: list<item: string>
          child 0, item: string
skills: list<item: string>
  child 0, item: string
difficulty: struct<evidence_span_s: double, evidence_moments: int64, cameras_needed: int64, cameras: list<item:  (... 8 chars omitted)
  child 0, evidence_span_s: double
  child 1, evidence_moments: int64
  child 2, cameras_needed: int64
  child 3, cameras: list<item: string>
      child 0, item: string
people: list<item: struct<id: string, pixels: int64, box: list<item: int64>, visible: bool>>
  child 0, item: struct<id: string, pixels: int64, box: list<item: int64>, visible: bool>
      child 0, id: string
      child 1, pixels: int64
      child 2, box: list<item: int64>
          child 0, item: int64
      child 3, visible: bool
t: double
frame: int64
to
{'frame': Value('int64'), 't': Value('float64'), 'people': List({'id': Value('string'), 'pixels': Value('int64'), 'box': List(Value('int64')), 'visible': Value('bool')})}
because column names don't match
Traceback:    Traceback (most recent call last):
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1827, in _prepare_split_single
                  for key, table in generator:
                                    ^^^^^^^^^
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 613, in wrapped
                  for item in generator(*args, **kwargs):
                              ~~~~~~~~~^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 343, in _generate_tables
                  self._cast_table(pa_table, json_field_paths=json_field_paths),
                  ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
                  pa_table = table_cast(pa_table, self.info.features.arrow_schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2378, in table_cast
                  return cast_table_to_schema(table, schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2306, in cast_table_to_schema
                  raise CastError(
                  ...<3 lines>...
                  )
              datasets.table.CastError: Couldn't cast
              id: string
              type: string
              answer: struct<seconds: double, intervals: list<item: list<item: string>>, count: int64, choice: string, mom (... 25 chars omitted)
                child 0, seconds: double
                child 1, intervals: list<item: list<item: string>>
                    child 0, item: list<item: string>
                        child 0, item: string
                child 2, count: int64
                child 3, choice: string
                child 4, moments: list<item: string>
                    child 0, item: string
              answer_text: string
              tolerance: struct<seconds: double, count: int64, choice: string>
                child 0, seconds: double
                child 1, count: int64
                child 2, choice: string
              evidence: list<item: struct<t: double, clock: string, what: string, entity: string, cameras: list<item: string (... 183 chars omitted)
                child 0, item: struct<t: double, clock: string, what: string, entity: string, cameras: list<item: string>, best_cam (... 171 chars omitted)
                    child 0, t: double
                    child 1, clock: string
                    child 2, what: string
                    child 3, entity: string
                    child 4, cameras: list<item: string>
                        child 0, item: string
                    child 5, best_camera: string
                    child 6, box: list<item: double>
                        child 0, item: double
                    child 7, visible_fraction: double
                    child 8, pixel_check: struct<seen: bool, camera: string, t: double, pixels: int64, needed: string>
                        child 0, seen: bool
                        child 1, camera: string
                        child 2, t: double
                        child 3, pixels: int64
                        child 4, needed: string
                    child 9, frame_t: double
              regions: list<item: struct<t0: double, t1: double, label: string, entities: list<item: string>>>
                child 0, item: struct<t0: double, t1: double, label: string, entities: list<item: string>>
                    child 0, t0: double
                    child 1, t1: double
                    child 2, label: string
                    child 3, entities: list<item: string>
                        child 0, item: string
              skills: list<item: string>
                child 0, item: string
              difficulty: struct<evidence_span_s: double, evidence_moments: int64, cameras_needed: int64, cameras: list<item:  (... 8 chars omitted)
                child 0, evidence_span_s: double
                child 1, evidence_moments: int64
                child 2, cameras_needed: int64
                child 3, cameras: list<item: string>
                    child 0, item: string
              people: list<item: struct<id: string, pixels: int64, box: list<item: int64>, visible: bool>>
                child 0, item: struct<id: string, pixels: int64, box: list<item: int64>, visible: bool>
                    child 0, id: string
                    child 1, pixels: int64
                    child 2, box: list<item: int64>
                        child 0, item: int64
                    child 3, visible: bool
              t: double
              frame: int64
              to
              {'frame': Value('int64'), 't': Value('float64'), 'people': List({'id': Value('string'), 'pixels': Value('int64'), 'box': List(Value('int64')), 'visible': Value('bool')})}
              because column names don't match
              
              The above exception was the direct cause of the following exception:
              
              Traceback (most recent call last):
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 1369, in compute_config_parquet_and_info_response
                  parquet_operations, partial, estimated_dataset_info = stream_convert_to_parquet(
                                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~^
                      builder, max_dataset_size_bytes=max_dataset_size_bytes
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  )
                  ^
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 948, in stream_convert_to_parquet
                  builder._prepare_split(split_generator=splits_generators[split], file_format="parquet")
                  ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1694, in _prepare_split
                  for job_id, done, content in self._prepare_split_single(
                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~^
                      gen_kwargs=gen_kwargs, job_id=job_id, **_prepare_split_args
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  ):
                  ^
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1879, in _prepare_split_single
                  raise DatasetGenerationError("An error occurred while generating the dataset") from e
              datasets.exceptions.DatasetGenerationError: An error occurred while generating the dataset

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

frame int64	t float64	people list
0	0	[ { "id": "cashier", "pixels": 2586, "box": [ 146, 101, 1180, 594 ], "visible": true }, { "id": "customer_01", "pixels": 2409, "box": [ 686, 99, 1176, 284 ], "visible": true }, { "id": "customer_02", "pixels": 3429...
1	0.067	[]
2	0.133	[]
3	0.2	[]
4	0.267	[]
5	0.333	[]
6	0.4	[]
7	0.467	[]
8	0.533	[]
9	0.6	[]
10	0.667	[]
11	0.733	[]
12	0.8	[]
13	0.867	[]
14	0.933	[]
15	1	[]
16	1.067	[]
17	1.133	[]
18	1.2	[]
19	1.267	[]
20	1.333	[]
21	1.4	[]
22	1.467	[]
23	1.533	[]
24	1.6	[]
25	1.667	[]
26	1.733	[]
27	1.8	[]
28	1.867	[]
29	1.933	[]
30	2	[]
31	2.067	[]
32	2.133	[]
33	2.2	[]
34	2.267	[]
35	2.333	[]
36	2.4	[]
37	2.467	[]
38	2.533	[]
39	2.6	[]
40	2.667	[]
41	2.733	[]
42	2.8	[]
43	2.867	[]
44	2.933	[]
45	3	[]
46	3.067	[]
47	3.133	[]
48	3.2	[]
49	3.267	[]
50	3.333	[]
51	3.4	[]
52	3.467	[]
53	3.533	[]
54	3.6	[]
55	3.667	[]
56	3.733	[]
57	3.8	[]
58	3.867	[]
59	3.933	[]
60	4	[]
61	4.067	[]
62	4.133	[]
63	4.2	[]
64	4.267	[]
65	4.333	[]
66	4.4	[]
67	4.467	[]
68	4.533	[]
69	4.6	[]
70	4.667	[]
71	4.733	[]
72	4.8	[]
73	4.867	[]
74	4.933	[]
75	5	[]
76	5.067	[]
77	5.133	[]
78	5.2	[]
79	5.267	[]
80	5.333	[]
81	5.4	[]
82	5.467	[]
83	5.533	[]
84	5.6	[]
85	5.667	[]
86	5.733	[]
87	5.8	[]
88	5.867	[]
89	5.933	[]
90	6	[]
91	6.067	[]
92	6.133	[]
93	6.2	[]
94	6.267	[]
95	6.333	[]
96	6.4	[]
97	6.467	[]
98	6.533	[]
99	6.6	[]

End of preview.

Thread in a Ropestack

Long, multi-camera, static-CCTV video from deterministic simulations, with questions generated from the simulation truth. Like needle-in-a-haystack, but the "thread" is information spread over time, cameras and space: how long something lasted, how often something happened, what one person did across several views, what did not happen.

Code, simulator and renderer: https://github.com/Clamepending/thread-in-a-ropestack-eval

Episodes

One short and one long episode per venue, named <venue>_<minutes>min.

episode	venue	minutes	cameras	fps	resolution	questions	no-video guesser
cornerstore_5min	cornerstore	5	6	15	1280x720	40	0.09
cornerstore_30min	cornerstore	30	6	15	1280x720	100	0.12
nightowl_5min	nightowl	5	7	15	1280x720	42	0.08
nightowl_30min	nightowl	30	7	15	1280x720	77	0.13
eastgate_10min	eastgate	10	8	15	1280x720	27	0.13
eastgate_30min	eastgate	30	8	15	1280x720	75	0.07
riverside_10min	riverside	10	10	15	1920x1080	27	0.08
riverside_30min	riverside	30	10	15	1920x1080	80	0.08

Venues

Four venues, deliberately different domains (indoor and outdoor; layout, lighting, textures, camera placement, lens and recorder look). The three indoor venues also have incidents that leave a visible trace for a while: spills until they are mopped up, wet-floor signs, baskets left on the floor, litter bins filling up and being emptied. The outdoor mall has vehicles, a dog and a utility crew instead.

`cornerstore`

A daytime grocery: front door, gondola aisles, two checkouts, a stockroom. A shopper drops a carton of juice (the stocker puts out a wet-floor sign and mops it up) and another leaves their basket in an aisle and walks out.

Example (intervals). During which periods was there a spill on the floor, from the moment it was spilled until it had been cleaned up?

Answer: 15:11:45.8 to 15:13:01.4

Evidence (from key.json): 15:11:47 on checkout: spill on the floor; 15:13:01 on checkout: finishes mopping.

`nightowl`

A late-night city bodega: side door, coolers, wooden islands, register at the back, watched by seven standard colour cameras. Someone spills a can of soda; someone abandons a basket.

Example (choice). Someone put their shopping basket down on the floor and walked out without it. Who?

woman in a blue denim shirt and black cropped trousers
woman in a black hoodie and denim shorts
man in a black T-shirt and light jeans (correct)

Evidence (from key.json): 23:41:13 on back: puts the basket down; 23:41:15 on back: basket on the floor.

`eastgate`

A commuter rail station at rush hour: ticket machines and window, kiosk, fare gates, a platform where trains arrive, open their doors and leave, plus a fisheye dome camera over the concourse. Commuters throw rubbish into three bins that fill up and are emptied by a cleaner, who also mops up spilled drinks. Background people may share outfits; questions only name people whose look is unique in the episode, and otherwise only count them.

Example (choice). Someone spilled something on the floor. Who caused the second spill?

man in a blue and white hoodie and jeans (correct)
man in a denim jacket over a white T-shirt
woman in a light grey sweater and dark denim skirt
woman in a pink shirt and blue jeans

Evidence (from key.json): 07:50:40 on entrance: drops a cup of coffee; 07:50:41 on entrance: spill on the floor.

`riverside`

An open-air strip mall and its parking lot: five shops (bakery, pharmacy, hardware, bookshop, cafe), 54 bays, a bike rack and a street with power lines, watched by ten outdoor cameras. People arrive in cars (every car looks different) or on bikes, visit shops and drive out through the exit; someone leaves their dog waiting outside the cafe; a utility crew parks by a power pole, sets up cones and a ladder, and works on it while their truck screens a car parked behind it from the street side. Questions link people to the vehicles they came in.

Example (choice). Which car did the bald man in a dark grey sweater and jeans arrive in?

the red sports car (correct)
the yellow hatchback
the maroon minivan
the black SUV

Evidence (from key.json): 10:00:48 on lot_west: gets out of the car; 10:00:47 on lot_west: the car they got out of; 10:00:59 on shops_west: seen clearly going into the riverside bakery.

Task

A model watches every stream of an episode (store clock burned into each frame) and then answers the questions in task.json, replying with one JSON object mapping question id to answer.

Each videos/<camera>.mp4 holds exactly the rendered frames at the episode's rate (the fps column above): frame $k$ shows episode time $k/\text{fps}$ s, and task.json's fps and frames are read from the files themselves. From v0.8 cornerstore and nightowl are rendered at 15 fps, a common CCTV recording rate; eastgate and riverside stay at 4 fps (v0.7). Since v0.7 no episode is below 4 fps (v0.6.1 to v0.6.3: 2 fps), so a walking person's box overlaps their box in the next frame and overlap-matching trackers keep their tracks. (Up to v0.6 the MP4s repeated each 2 fps image five times at 10 fps while task.json said 2 fps; always read the timing from the container.) Every question has one of five answer types:

answer type	reply with	scored
count	a whole number	by relative error: $\max(0, 1 - 2e)$
duration	seconds	by relative error: $\max(0, 1 - 2e)$
intervals	`[[start, end], ...]` store-clock times	temporal IoU of the union of periods
moments	`[time, ...]`, `[]` if it never happened	matched Jaccard: times pair one-to-one within 5 s
choice	one of the options	1 if right

key.json holds the answers plus, for every question, the evidence moments (time, entity, cameras that show it) and answer regions; questions are kept only if every person evidence moment is visible in the rendered pixels.

Scoring

Each answer scores $s_i \in [0, 1]$; unanswered or unparseable answers score 0. Times are the clock burned into the footage, converted to seconds. With $\tau$ the question's tolerance (5 s):

count, duration (relative error $e = |\hat y - y| / y$): $s = \max(0,\ 1 - 2e)$, so 1 when exact, 0.8 at 10% off and 0 from 50% off; when the true value is 0 the answer must be exactly 0.

choice: $s = \mathbb{1}[\hat y = y]$ (compared case-insensitively).

intervals (temporal IoU): merge overlapping periods into unions $\hat U$ (answer) and $U$ (truth), then

$s = \frac{|\hat U \cap U|}{|\hat U \cup U|}$

measured in seconds.

moments (matched Jaccard): pair answered times $\hat T$ with true times $T$ one-to-one, a pair only if $|\hat t - t| \le \tau$; with $m$ the size of the largest such matching,

$s = \frac{m}{|\hat T| + |T| - m}$

Extra or missed moments both cost, and answering at the wrong times scores 0.

For both intervals and moments, an empty answer when nothing happened scores 1 ($0/0 := 1$).

Episode score: the mean over its $N$ questions, $S = \frac{1}{N}\sum_i s_i$. Per-answer-type and per-skill means are reported alongside. scores.json gives two reference points: the answer key itself (oracle, always 1.0) and a guesser that never sees the video (always 3, 60 s, no periods, never, and the first option).

Skills

Independently of its answer type, every question is tagged in key.json with the skills it needs, from a fixed vocabulary. Some questions need exactly one skill (single-skill probes, e.g. "who was paying at the checkout at 15:10:20?" needs only identify, since the time and place are given); most combine several (e.g. "how long after going through the gates did the man in a red sweater get on a train?" needs identify, track and localize-in-track). python -m ropestack score reports the mean per skill, and for each skill the mean over its single-skill questions (only) and over composites (with_others): a method that does well on each skill alone but poorly in combination has trouble composing them.

skill	what it takes	questions	single-skill
`find-event`	find when a described event happens (no particular person to follow)	93	14
`identify`	pick out a person from a description of their clothes, or describe who did something	138	8
`track`	follow one person through time and across cameras	288	11
`localize-in-track`	find a particular moment within one person's activity	236
`count`	count distinct people or occurrences without double-counting	54	19
`state-over-time`	tell when, or for how long, something was true	109	6
`snapshot`	describe the scene at one given moment	20
`order`	put events in the order they happened	32
`absence`	notice something that went wrong or did not happen	16
`associate`	keep hold of one person through a look-alike or a stretch out of view (a description match is not enough)	26
`cross-camera`	no single camera shows all the evidence (added automatically)	78

Files

episodes/<id>/task.json            model input: streams + questions (no answers)
episodes/<id>/key.json             answers, tolerances, evidence, regions, skills, difficulty
episodes/<id>/scores.json          oracle (must be 1.0) and no-video guesser references
episodes/<id>/questions.json       all generated questions, including ones dropped as not observable
episodes/<id>/videos/<cam>.mp4     camera streams (clock burned in)
episodes/<id>/annotations/<cam>.jsonl   per frame: time and each visible person's box and pixel count
episodes/<id>/masks/<cam>.tar      per-frame person ID masks (PNG)
episodes/<id>/truth/               events, per-person tracks, shelf stock, intervals, cast, meta
episodes/<id>/scenario.yaml        scenario (intent + seed) the episode was simulated from
episodes/<id>/venue.json           floor plan, fixtures, products, cameras

Scoring code: python -m ropestack score episodes/<id> response.json in the repository.

Provenance and licences

Everything is simulated and rendered (Unreal Engine 5.8); no real people or places. Assets are AI-use-compatible: Microsoft Rocketbox avatars and animations (MIT), CMU motion capture, Poly Haven and ambientCG (CC0), and procedurally generated fictional brands, signs and surfaces.

Versions

Tags mark releases (v0.1, v0.2, ...; from v0.3 one short and one long episode per venue; v0.4 adds the incidents and the station's dome camera; v0.8 renders cornerstore and nightowl at 15 fps, adds anchored questions that name a customer only by one act at a stated time, and scores counts and durations by relative error). Each episode's truth/meta.json names the scenario version it was simulated from and carries a sha256 of the truth, so a re-simulation can be checked against the release.

Downloads last month: 2,439

Total file size:

39.8 GB