Hugging Face's logo

Datasets:
hltcoe
/
microvent

Tasks:
Video Classification
Visual Question Answering
Text Retrieval
Modalities:
Text
Video
Audio
Formats:
webdataset
Languages:
English
Spanish
Russian
Size:
< 1K
ArXiv:
Tags:
video
audio
multimodal
webdataset
retrieval
claim-extraction
Libraries:
Datasets
WebDataset
License:
Dataset card Data Studio Files
xet
 Community
microvent / README.md
rekriz11's picture
rekriz11
Upload README.md with huggingface_hub
3c4d4c9 verified
preview code
|
raw
history blame contribute delete
14.8 kB
metadata 
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_ids; 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:

{
  "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):

{"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):

{
  "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
ppocr OCR text from keyframes PaddlePaddle/PaddleOCR-VL-1.5
qwen3asr ASR text from audio Qwen/Qwen3-ASR-1.7B

reference.json

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

{
  "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:

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_ids ({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:

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), 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:

# 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):

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:

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_ids 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.