README.md

---
license: apache-2.0
license_name: mixed-content
language:
- en
- es
- ru
- zh
- pt
- ar
- fr
task_categories:
- video-classification
- visual-question-answering
- text-retrieval
tags:
- video
- audio
- multimodal
- webdataset
- retrieval
- claim-extraction
pretty_name: microvent
size_categories:
- n<1K
configs:
- config_name: videos
  data_files:
  - split: train
    path: videos/shard_*.tar
- config_name: audio
  data_files:
  - split: train
    path: audio/shard_*.tar
- config_name: keyframes_uniform_5s
  data_files:
  - split: train
    path: keyframes/uniform_5s/shard_*.tar
---

# microvent

A compact development set for video retrieval, claim extraction, and report
generation. It uses the same schema as the larger `multivent-raw`, so scripts
that target one transfer straight to the other.

This dataset card covers the **core release**: videos, audio, keyframes, and
the public evaluation annotations. Derived signals (OCR text, ASR transcripts,
visual / audio / video / omni embeddings) live in a companion release,
**microvent-features**, with its own dataset card (`FEATURES_README.md` while
the two are co-located on disk).

A **chunk** is the unit of retrieval here: roughly the video analogue of
a "passage" in text IR, a contiguous slice of one source video short
enough to be a useful retrieval target on its own. Short videos are a
single chunk; long-form sources split into several. Every artifact,
including the annotations, is keyed by `chunk_id`. A `video_id` is just
the prefix of its `chunk_id`s; the mapping (`video_id` → `[chunk_id, ...]`)
is fully recoverable from `videos/catalog.csv` for clients that retrieve
at video grain.

---

## At a glance

| | |
|---|---|
| Queries                            | 31         |
| Topics                             | 23         |
| Positives (relevance:1)            | 279        |
| Hard negatives (relevance:0)       | 730        |
| Source videos                      | 933        |
| Total chunks                       | 943        |
| Shards                             | 5          |

---

## Directory layout

```
microvent/
├── README.md
│
├── annotations/                                              ← public eval inputs
│   ├── queries.jsonl
│   ├── judgments.jsonl
│   └── reference.json
│
├── videos/                                                   ← .mp4 + per-chunk JSON
│   ├── catalog.csv
│   └── shard_NNNNNN.tar   (×5)
│
├── audio/                                                    ← .m4a (AAC, demuxed from .mp4)
│   ├── catalog.csv
│   └── shard_NNNNNN.tar   (×5)
│
└── keyframes/uniform_5s/                                     ← .jpg frames, one every 5 s
    ├── catalog.csv
    └── shard_NNNNNN.tar   (×5)
```

Each artifact directory contains exactly two kinds of file: one
`catalog.csv` and the `shard_NNNNNN.tar` WebDataset shards. The
`annotations/` subtree is unique to microvent for now; multivent-raw's
annotations are pending upload.

Derived artifacts (`ocr/`, `asr/`, `embeddings/`) ship in **microvent-features**.

---

## Identifiers

Three IDs let you locate, group, and time-align everything. Same schema as
`multivent-raw`.

| field           | example                          | what it identifies |
|-----------------|----------------------------------|--------------------|
| `chunk_id`      | `XM5xOIzL_vSkGAKR_0000`          | one chunk; the join key across artifacts |
| `video_id`      | `XM5xOIzL_vSkGAKR`               | the source video the chunk came from |
| frame `tNNNNNN` | `t000005`                        | a keyframe within a chunk, at second NNNNNN of the chunk |

* `chunk_id == f"{video_id}_{chunk_index:04d}"`. Always 4-digit padded,
  even for single-chunk videos.
* `tNNNNNN` is the integer second offset **within the chunk** (zero-padded
  to 6 digits). Keyframes are sampled every 5 s.
* No `chunk_id` or `video_id` starts with `-`, so filenames are safe to
  pass to `tar`, `find`, `xargs`, etc. without escaping.

---

## Annotations (`annotations/`)

```
annotations/
├── queries.jsonl       31 rows, one per query
├── judgments.jsonl     279 positives + 730 hard negatives = 1009 rows
└── reference.json      23 topics with per-claim chunk-level evidence
```

### `queries.jsonl`

One JSON object per line, 31 rows total:

```json
{
  "query_id":      "1",
  "query_type":    "unbiased",        // or "biased"
  "language":      "english",
  "topic_id":      "TTdFH8QvqAzM",    // joins to reference.json
  "persona_title": "Statistician for North American Elections",
  "background":    "I am a statistician who monitors...",
  "query":         "Help me compile parliamentary and vote share statistics..."
}
```

Each query carries a unique `persona_title` + `background`. The `topic_id`
joins to `reference.json` (a many-to-one relationship: biased/unbiased
query pairs share a topic). Source-pool prefixes (`multivent_`, `anomaly_`,
`magmar_`) have been stripped to prevent provenance peeking.

### `judgments.jsonl`

1009 rows, keyed by `chunk_id`. Positives and negatives mixed.

Positive (`relevance: 1`):

```json
{"query_id": "1", "chunk_id": "_Ffutvei9wgoxMYS_0000", "relevance": 1, "language": "english"}
```

Positives were annotated at video grain (annotators marked a whole video
as relevant for a query) and expanded to chunk grain here: every chunk of
a video relevant to query Q inherits that relevance. A multi-chunk video
contributes one row per chunk.

Negative (`relevance: 0`, hard negative from the retrieval pool):

```json
{
  "query_id":        "1",
  "chunk_id":        "IY_y1OVmryOyKNAw_0000",
  "relevance":       0,
  "distractor_type": "other",        // or "same_camera"
  "rank_source":     "qwen3vl8b"     // also "ppocr" or "qwen3asr"
}
```

Distractors were mined at chunk grain, so each row points at one specific
chunk of one source video.

`rank_source` identifies which retrieval signal mined the negative, so
you can weight or hold-out negatives per signal:

| `rank_source` | signal | model |
|---------------|--------|-------|
| `qwen3vl8b`   | visual (keyframe embedding) | [Qwen/Qwen3-VL-Embedding-8B](https://huggingface.co/Qwen/Qwen3-VL-Embedding-8B) |
| `ppocr`       | OCR text from keyframes     | [PaddlePaddle/PaddleOCR-VL-1.5](https://huggingface.co/PaddlePaddle/PaddleOCR-VL-1.5) |
| `qwen3asr`    | ASR text from audio         | [Qwen/Qwen3-ASR-1.7B](https://huggingface.co/Qwen/Qwen3-ASR-1.7B) |

### `reference.json`

Single JSON document with a `version` field and a `topics` list:

```json
{
  "version": "1.0",
  "topics": [
    {
      "topic_id":   "TInVWzp25aIM",
      "query_id":   18,                                // joins to queries.jsonl
      "query_type": "biased",                          // or "unbiased"
      "language":   "english",
      "article":    null,                              // non-null only on magmar topics
      "chunks":     ["<chunk_id>", ...],               // oracle relevant set, chunk grain
      "claims": [
        {
          "claim_id": "TInVWzp25aIM_c0",               // stable, `<topic_id>_c<index>`
          "text":     "Emmonak, Alaska is being affected by the typhoon.",
          "evidence": {                                // chunk_id → list of modalities used
            "ls22tjnDj3GN8Jfj_0000": ["video-text"],
            "kkH5Nopcv9waN9dl_0000": ["audio-speech"]
          }
        }
      ]
    }
  ]
}
```

Each claim's `evidence` maps a supporting `chunk_id` to the list of
modalities used to support the claim. Annotators worked at chunk grain,
so a multi-chunk video can have different claims attributed to its
different chunks (e.g. a satellite-launch video's orbital-burn chunk
vs. its landing chunk). The set of supporting chunks for a claim is just
`evidence.keys()`; there is no separate `supporting_chunks` field.
Modality labels are preserved verbatim from upstream annotators:
`video-text`, `video-non-text`, `audio-speech`, `audio-non-speech`.

Lookup by topic_id:
```python
import json
ref = json.load(open("annotations/reference.json"))
topics_by_id = {t["topic_id"]: t for t in ref["topics"]}
```

---

## video_id ↔ chunk_id

`chunk_id` is the primary key throughout the release. Every artifact and
every annotation uses it. A `video_id` is the prefix of one or more
`chunk_id`s (`{video_id}_{NNNN}`); most videos contribute one chunk
(`{video_id}_0000`), but long-form sources (e.g. anomaly streams) split
into multiple. The
mapping each way is fully recoverable from `videos/catalog.csv`:

```python
import pandas as pd
cat = pd.read_csv("videos/catalog.csv")
video_to_chunks = cat.groupby("video_id")["chunk_id"].agg(list).to_dict()
# {"XM5xOIzL_vSkGAKR": ["XM5xOIzL_vSkGAKR_0000"],
#  "PxRXEWfLiL3w_E7y": ["PxRXEWfLiL3w_E7y_0000", "PxRXEWfLiL3w_E7y_0001"], ...}
chunk_to_video = dict(zip(cat["chunk_id"], cat["video_id"]))
```

Eval clients that want to roll chunk-level scores up to video grain can
use `chunk_to_video` to group.

---

## In-shard file names

Same convention as multivent-raw:

```
<chunk_id>.<artifact_tag>.<extension>
```

| artifact directory          | tag        | per-chunk members |
|-----------------------------|------------|-------------------|
| `videos/`                   | *(none)*   | `<chunk_id>.mp4`, `<chunk_id>.json` |
| `audio/`                    | *(none)*   | `<chunk_id>.m4a` (absent if `has_audio=False`) |
| `keyframes/uniform_5s/`     | `kf_uni5s` | `<chunk_id>.kf_uni5s.tNNNNNN.jpg` (one per 5 s) |

The stem before the first `.` is always the `chunk_id`. WebDataset uses
this prefix to group multi-artifact records into one sample. Feature
artifacts in **microvent-features** follow the same convention so they
join cleanly with these shards.

---

## Per-artifact details

### Videos (`videos/`)

`<chunk_id>.mp4` is the video clip itself; `<chunk_id>.json` carries the
per-chunk metadata (duration, codec, source-chunk offsets) that's also
summarized in `videos/catalog.csv`. Catalog columns:

```
chunk_id, video_id, chunk_index, chunk_count, shard_index,
duration_sec, chunk_start_sec, chunk_end_sec, size_bytes, vcodec, acodec
```

### Audio (`audio/`)

Each `<chunk_id>.m4a` is the raw AAC track demuxed from the matching
`<chunk_id>.mp4` with `ffmpeg -vn -c:a copy`. The audio is not re-encoded;
it is byte-identical to the bitstream inside the source mp4. 10 of 943
chunks have no audio stream (silent captures or upload-side stripping);
these have `has_audio=False` in `audio/catalog.csv` and no member in the
tar. Sample
rate / channel count vary per source (most are 44.1 kHz stereo from web
video) and are recorded per-row in the catalog:

```
chunk_id, video_id, chunk_index, chunk_count, shard_index,
has_audio, acodec, asample_rate_hz, achannels, duration_sec, size_bytes
```

### Keyframes (`keyframes/uniform_5s/`)

JPEG keyframes sampled uniformly at one frame per 5 s of chunk duration.
Member name `<chunk_id>.kf_uni5s.tNNNNNN.jpg`, where `NNNNNN` is the
integer-second offset within the chunk (zero-padded to 6 digits, e.g.
`t000005`, `t000010`, ...). Catalog columns:

```
chunk_id, video_id, chunk_index, shard_index, chunk_count,
frame_count, duration_sec
```

`frame_count` is the exact number of `.jpg` members for that chunk and
should match `ceil(duration_sec / 5)` modulo edge-case rounding.

Schema details (chunk JSON shape, exact catalog dtypes) are identical to
multivent-raw's; see that dataset's README for the canonical reference.

---

## Eval suite

The standard eval client for microvent is **MiRAGE**
([Martin et al., 2025](https://arxiv.org/abs/2510.24870)), a claim-centric
framework for evaluating multimodal retrieval-augmented generation. It
scores system output against `annotations/reference.json` along two axes:
**InfoF1** (claim-level information coverage and factuality) and
**CiteF1** (whether generated citations actually support the claims they
attach to).

---

## Sharding

5 shards of ~189 chunks each. Every artifact in this core release shards
identically: chunk `C` in shard `N` of `videos/` lives in shard `N` of
`audio/` and `keyframes/uniform_5s/`. Same join invariants as
multivent-raw. The feature release uses the same chunk → shard assignment
for the artifacts that were processed by the same pipeline; newer
embeddings in microvent-features may reshard (see that card).

---

## Pulling the data locally

The entire core release (or any subset of it) can be mirrored with the
`hf` CLI from `huggingface_hub`:

```bash
# everything
hf download hltcoe/microvent --repo-type dataset --local-dir ./microvent

# just the public annotations (small, fast)
hf download hltcoe/microvent --repo-type dataset --local-dir ./microvent \
    --include "annotations/*" "README.md"

# just videos + audio shards
hf download hltcoe/microvent --repo-type dataset --local-dir ./microvent \
    --include "videos/*" "audio/*"
```

`--local-dir` writes plain files (no blob/symlink indirection); drop it
to land in the standard `~/.cache/huggingface/hub/` layout instead.

---

## Loading with `datasets`

The repo is a plain WebDataset, so `huggingface/datasets` auto-detects it
when you ask for a config name (each top-level artifact dir is exposed as
one config in the YAML frontmatter):

```python
import datasets
vids   = datasets.load_dataset("hltcoe/microvent", "videos",               split="train", streaming=True)
audios = datasets.load_dataset("hltcoe/microvent", "audio",                split="train", streaming=True)
frames = datasets.load_dataset("hltcoe/microvent", "keyframes_uniform_5s", split="train", streaming=True)
```

If you prefer to drive `webdataset` directly, point it at the shard glob:

```python
import webdataset as wds
ds = wds.WebDataset("videos/shard_{000000..000004}.tar").decode()
```

The `annotations/` subtree is plain JSONL/JSON and should be read with
`json` / `pandas` rather than the WebDataset loader.

---

## Provenance protection

All `video_id`s are anonymized (token_urlsafe-derived, leading-dash
sanitized). The release contains no original YouTube/X/TikTok/Instagram
URLs, no uploader names, no `.info.json` files, and no source-pool labels.
The private mapping back to original identifiers stays in HLTCOE-internal
storage and is not redistributed.

---

## License

* HLTCOE-authored content (this README, the `catalog.csv` files, the
  `annotations/` JSON/JSONL, and the chunk JSON sidecars in `videos/`)
  is released under Apache-2.0.
* Video, audio, and keyframe content in the shards is copyrighted by its
  respective original owners and is redistributed here under research /
  fair-use terms only. Do not redistribute the raw shards outside
  research contexts; cite the upstream owners where known.