g2zr004/MovieCharacterNaming

Movie Character Naming (MCN)

MCN is a dataset for working out who is who in a film from the film alone, without cast lists, actor photos or character banks. A model sees a clip with a colored box on each face and hears a name in the dialogue. It then has to pick the color that belongs to that name, or answer that the character has no face on screen.

MCN accompanies As the Story Unfolds: Watching a Film and Identifying Characters as a Human Does (Gui, Xie, Han, Xie, Zisserman, 2026).

Paper · Project page

It has two types of annotation:

• Character Naming (CN): multiple-choice questions on video clips, each mapping a spoken name to a face track or to none. Clips are cut around name occurrences in the dialogue.
• First Occurrence (FO): two timestamps per character across full films, marking when the character first appears and when a viewer can first put a name to the face.

Statistics

Annotation	Split	Clips	Films	Characters	Questions (non-none)	Duration
CN	train	21,662	377	1,853	22,210 (21,150)	108.4 h
CN	test	1,338	30	226	1,582 (1,399)	6.52 h
CN	test_unseen	102	4	84	159 (134)	0.60 h
FO	full films		20	287	574 timestamps	39.98 h of film

Each train clip comes in two color variants, so there are 10,831 unique clips, 11,105 unique questions and 54.2 h of unique video. The train character count is unique name strings, as in the paper; counted per film, it is 2,018. Durations are summed from end - start, so they differ slightly from the paper's.

test_unseen contains four films released from March 2026 onward: Voicemails for Isabelle, In the Grey, The Death of Robin Hood and Heartstopper Forever. They came out after the training cut-offs of the models evaluated in the paper, so those models cannot answer from memories of the film.

Contents

MCN_release/
├── annotations/
│   ├── cn/
│   │   ├── train.csv
│   │   ├── test.csv
│   │   └── test_unseen.csv
│   └── fo/
│       ├── annotations.json         # timestamps and weights
│       ├── name_annotations.json    # subtitle mention counts
│       └── imdbid_list.json         # film IDs
├── json/
│   ├── stage_1_sft_cold_start_aug.json    # Stage I training data (SFT)
│   └── stage_2_grpo_rl_aug.json           # Stage II training data (GRPO)
└── vid/
    ├── train.tar          # 180.6 GB, 21,662 clips
    ├── test.tar           # 17.0 GB, 1,380 clips
    └── test_unseen.tar    # 60 MB, 102 clips

Full films are not included. You need your own copies to use the FO timestamps.

Getting started

Extract the clips inside vid/. The tars are uncompressed, so this needs another 198 GB of disk.

cd vid
tar -xf train.tar
tar -xf test.tar
tar -xf test_unseen.tar

Paths in the annotations are relative to the release root, for example vid/test/5.mp4. In the CN CSVs, some columns hold Python literals and others hold JSON:

import ast, csv, json

csv.field_size_limit(10**9)

def load_cn(path):
    rows = list(csv.DictReader(open(path, encoding='utf-8')))
    for r in rows:
        r['start'], r['end'] = float(r['start']), float(r['end'])
        for k in ('name', 'gt', 'color_map', 'bbox'):
            r[k] = ast.literal_eval(r[k])
        for k in ('clusters', 'subtitles'):
            r[k] = json.loads(r[k])
    return rows

Clips

• The colored boxes are part of the video. Each face track is drawn into the frames, and face-track coordinates are not provided separately. There are 10 colors: blue, brown, cyan, green, magenta, orange, pink, red, teal and yellow.
• Colors only mean something within a clip. The same character can have different colors in different clips.
• train clips come in pairs. vid/train/<id>_0.mp4 and <id>_1.mp4 are the same clip with the colors permuted. This is the paper's color-permutation augmentation, which stops a model from learning shortcuts such as "the protagonist is red". test and test_unseen clips have one version.
• Boxes can be wrong. Faces were detected and tracked automatically, so a box occasionally lands on something else, such as a clock face.
• All clips have audio. Formats differ by split:

Split	Video codec	Typical width	Frame rate
train	MPEG-4 Part 2	mostly 1280 px	19–25 fps
test	MPEG-4 Part 2	1280–1920 px	24–25 fps
test_unseen	H.264	666–864 px (360p)	24–25 fps

Character Naming annotations

One row per clip. Here is a row from train.csv, after loading:

{
  "video_path": "vid/train/2_1.mp4",
  "imdbid": "tt0118929",
  "start": 509.884375,
  "end": 513.387875,
  "text": "You must be Emma Murdoch.",
  "name": ["Emma Murdoch"],
  "bbox": [[[12299, 580, 124, 642, 298]]],
  "clusters": [
    {"cluster_idx": 0, "track_indices": ["162_0"], "label": null},
    {"cluster_idx": 1, "track_indices": ["163_0"], "label": null},
    {"cluster_idx": 2, "track_indices": ["163_1"], "label": "Emma Murdoch"}
  ],
  "gt": {"Emma Murdoch": "magenta"},
  "color_map": {"162_0": "green", "163_0": "red", "163_1": "magenta"},
  "subtitles": [
    {"start": 511.04, "end": 513.2, "text": "You must be Emma Murdoch.",
     "diar_speaker": 1, "diar_iou": 0.5864, "speaker": "red"}
  ]
}

Column	Meaning
video_path	Clip path, relative to the release root
imdbid	IMDb ID of the film
start, end	Position of the clip in the film, in seconds
text	Dialogue in which the name is spoken
name	Character names being asked about. These can be fuller than the spoken form
gt	The answer. Maps each name to its box color, or to "unknown" if the character has no face track in the clip (none in the paper)
color_map	Maps each face track ID to its box color
clusters	Character-level face clusters. track_indices lists track IDs in the form <shot>_<track>, and label is the character's name or null
bbox	Source body boxes as [frame, x1, y1, x2, y2], grouped in nested lists. Not needed for the task
subtitles	Dialogue lines in and around the clip, timed in film seconds. speaker is the box color of the assigned face, or "none". diar_speaker is the voice cluster, or "none", and diar_iou is that line's overlap with the cluster
cleaned	test and test_unseen only. Always True

Where the labels come from. train labels are automatic: name-to-body annotations from MovieNet and Movie101 were aligned with face tracks. test was then manually inspected and corrected, and test_unseen was manually annotated.

How the rest was produced. Shots come from SceneDetect, face tracks from SAM 3, and face clusters from InsightFace features. Dialogue is transcribed with Parakeet, then diarized with DiariZen, and TalkNet links voices to faces. Speaker tags are therefore predictions, not ground truth, in every split.

Building prompts

The json/ files contain prompts for train only. This function produces the same template for any row, and reproduces all 21,585 training prompts exactly (Stage I adds <video>\n at the start):

def build_prompt(r):
    colors = ', '.join(sorted(set(r['color_map'].values())))
    lines = [
        f"<{s['start'] - r['start']:.2f} seconds> "
        f"[{'unknown' if s['speaker'] == 'none' else s['speaker']}]: {s['text']} "
        f"<{s['end'] - r['start']:.2f} seconds>"
        for s in r['subtitles']
    ]
    return (
        'Match characters to bounding box colors using the subtitles and video.\n\n'
        f"Candidates:\n{', '.join(r['name'])}\n\n"
        f'Colors:\n{colors}\n\n'
        'Subtitles:\n' + '\n'.join(lines) + '\n\n'
        'Question:\nWhich character is each color?\n\n'
        'After </think>, output ONLY a JSON object:\n'
        '{"character_name": "color"} or {"character_name": "unknown"}'
    )

Prompt times are relative to the start of the clip. They can be negative, because a line can begin before the clip does.

First Occurrence annotations

annotations.json maps each film to its characters:

{"tt0330373": {"Harry Potter": {"visual_time": 226.96, "linkage_time": 231.9, "weight": 0.358}}}

Field	Meaning
visual_time	First visual occurrence: when the character first appears on screen, in seconds from the start of the film
linkage_time	First naming: when a viewer can first link the face to the name, based only on what came before
weight	The character's share of subtitle mentions in the film. Weights sum to 1 per film

name_annotations.json holds the mention counts behind weight, as film → name → count. imdbid_list.json lists the film IDs. All FO films are also in test.csv.

Training files

json/ holds the data for the paper's two-stage fine-tuning. Both files use train clips, share no clips with each other, and together leave out 77 train videos.

File	Stage	Videos	Unique clips	Format
stage_1_sft_cold_start_aug.json	I: supervised fine-tuning	4,971	2,499	video, conversations (one human and one gpt turn)
stage_2_grpo_rl_aug.json	II: GRPO reinforcement learning	16,614	8,307	problem_id, problem, solution, path, data_type, problem_type, options, data_source

Stage I targets are reasoning traces generated by a teacher model (Gemini-3-Flash-Preview), followed by </think> and the answer. There is no opening <think> tag. In Stage II, data_type is always video, problem_type is always name_linking, and options and data_source are always empty.

Answers in both files are JSON-encoded twice:

stage1 = json.load(open('json/stage_1_sft_cold_start_aug.json'))
stage2 = json.load(open('json/stage_2_grpo_rl_aug.json'))

answer1 = json.loads(json.loads(stage1[0]['conversations'][1]['value'].split('</think>')[1]))
answer2 = json.loads(json.loads(stage2[0]['solution']))

All Stage II answers match train.csv. In Stage I, 34 of 4,971 do not, so compare against train.csv if you need exact labels.

Evaluation

Character Naming is scored per name, not per clip. Overall accuracy covers all questions, and Known accuracy covers only those whose answer is a color.

def score(rows, preds):
    """preds maps video_path to {name: color or 'unknown'}. Missing answers count as 'unknown'."""
    hits = total = known_hits = known_total = 0
    for r in rows:
        for name, answer in r['gt'].items():
            hit = preds.get(r['video_path'], {}).get(name, 'unknown') == answer
            total += 1
            hits += hit
            if answer != 'unknown':
                known_total += 1
                known_hits += hit
    return {'overall': 100 * hits / total, 'known': 100 * known_hits / known_total, 'questions': total}

rows = load_cn('annotations/cn/test.csv')
print(score(rows, {}))  # answering 'unknown' everywhere: overall 11.57, known 0.0, 1582 questions

For reference, these are results from the paper's Table 2 on test:

Model	Overall	Known
Random baseline	29.90	33.74
Qwen3VL-4B-Thinking (SFT + RL)	72.76	81.06
Gemini-3.1-Pro-Preview	82.47	89.69

First Occurrence supports Mean Temporal IoU, which compares when a model knows a character with when a viewer does. For a film of length T, TIoU(c) = |H_c ∩ P_c| / |H_c ∪ P_c|, where P_c is when the model correctly identifies character c and H_c runs from the character's timestamp to T. The overall score is the mean of TIoU(c) weighted by weight. Using visual_time gives the visual variant and linkage_time the name variant. See Section 5.1 of the paper for this and for Principal Character Recall.

License

Apache License 2.0. The clips are excerpts from commercial films, and their copyright stays with the rights holders. The CN annotations build on MovieNet and Movie101, so check their terms as well.

Citation

@article{gui2026streamcast,
  title   = {As the Story Unfolds: Watching a Film and Identifying Characters as a Human Does},
  author  = {Gui, Zhongrui and Xie, Junyu and Han, Tengda and Xie, Weidi and Zisserman, Andrew},
  journal = {arXiv preprint arXiv:2610.37579},
  year    = {2026}
}

Please also cite MovieNet (Huang et al., ECCV 2020) and Movie101 (Yue et al., ACL 2023), which MCN builds on.

Contact

Zhongrui Gui: zhongrui@robots.ox.ac.uk