File size: 5,107 Bytes
c66ab6c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
---
license: other
pretty_name: ERCBench MultiShotMaster (priority 1-200)
tags:
- video-generation
- multi-shot
- text-to-video
---

# ERCBench-MultiShotMaster-400 — MultiShotMaster outputs, priority 1–200

Multi-shot videos generated with **MultiShotMaster** (KlingTeam, 1.3B, base model **Wan2.1-T2V-1.3B**) for the first
200 episodes (priority 1–200) of the UEC-Bench / ERCBench StoryMem prompt set. This release has 200 episodes and 1,000
shots: 120 four-shot, 60 six-shot and 20 eight-shot episodes. The prompts and the episode list are the same as in
[`BlueSourceJY/ERCBench-ShotStream-400`](https://huggingface.co/datasets/BlueSourceJY/ERCBench-ShotStream-400).

## Contents

```
episodes/<episode_id>/episode.mp4      # one multi-shot video per episode, all shots generated in one pass
episodes/<episode_id>/metadata.json    # prompts + sha256 + UMT5 token counts, frame ranges, configured and measured cuts, seed, video sha256, timing
inputs/all_200.csv                     # MultiShotMaster input CSV (shot_groups, caption JSON path, episode_id, priority), priority order
inputs/json/<episode_id>.json          # {"global_caption": "", "shot0": Shot1, ..., "shot{N-1}": ShotN}
runs/run_manifest.json                 # versions, revisions, attention backend, GPUs, start/end times (Dubai, UTC+4), cut offsets
runs/inference_episode.diff            # the only changes made to infer_multishot.py
runs/timing.csv                        # per-episode generation time and measured cut offsets
runs/logs/                             # per-GPU generation logs, tokenizer logs (every string sent to the text encoder), GPU memory
runs/scripts/                          # input-building, tokenizer-logging, finalize and packaging scripts, pip freeze
```

## Prompt source

- Dataset: [`BlueSourceJY/ERCBench-StoryMem-400`](https://huggingface.co/datasets/BlueSourceJY/ERCBench-StoryMem-400),
  revision `c96eccaf5f9de67181aa6bdcd22fae85252d5821`, file `storymem_inputs_400.zip`
  (sha256 `50ac67c03afc261a0228fc894596832676f4126ebf1a0edc5bf2628decc71c2f`).
- All 2,045 files were checked against `storymem_inputs/sha256.json`.
- Episodes come from `storymem_inputs/priority_200.ids.txt`. The file order is the priority order.
- Shot k of an episode is `shot_mapping.json` → `shots[k-1]`, which gives `(storymem_scene_num, storymem_shot_num)`.
  The prompt is `story_script.json` → the scene with that `scene_num` → `video_prompts[storymem_shot_num - 1]`.
  `make_inputs.py` re-derives every prompt from these source files and checks it against `prompt_sha256`.
- Prompts are used **verbatim**. MultiShotMaster's caption JSON keys start at `shot0`, so `shot0` holds Shot1,
  `shot1` holds Shot2, and so on. `global_caption` is the empty string; the code's own template then sends
  `"Story:  Now: <shot prompt>"` to the text encoder (its tokenizer cleaning collapses the double space).
- Every string sent to MultiShotMaster's own UMT5 tokenizer was logged (`runs/logs/tokens_gpu*.jsonl`, via
  `tok_hook_run.py`, log-only). For all 1,000 shots the shot text equals the dataset prompt (same sha256), shot k uses
  Shot k's prompt, and the untruncated token count is at most 512 (no truncation).

## Generation settings

- Code: [MultiShotMaster](https://github.com/KlingTeam/MultiShotMaster) commit `1df812dda262639e4a3ca6e4a1da9000b0a8e124`.
- Weights: `KlingTeam/MultiShotMaster` @ `5be642763b970d7e76a93958a122c459caa36681` (1.3B only).
- 832×480, **75 frames per shot**, shot groups `[[0,75],[75,150],…]`; the whole episode (300 / 450 / 600 frames) is
  generated in **one pass**. 50 steps, CFG 5.0, sigma shift 5.0, tiled VAE, the code's default negative prompt.
- 15 fps, written by the unmodified `save_video(fps=15, quality=5)`.
- Seed 42 (code default), set before every episode, so results do not depend on which GPU took an episode.
- Attention backend: FlashAttention-2 (`flash_attn` 2.8.3.post2). torch 2.8.0+cu128. NVIDIA H200 GPUs 0–3 (0,1 from the start; 2,3 after the ShotStream evaluation finished), one process
  per GPU, episodes claimed in priority order.
- Inference script: `infer_multishot.py` was copied to `inference_episode.py` with the changes in
  `runs/inference_episode.diff`: output named `<episode_id>.mp4`, `--output_folder`, skip an episode whose output
  already exists with the correct frame count, atomic per-episode claims so several GPUs work in priority order,
  timing and peak-memory log lines. Model loading, prompt construction, the pipeline call and `save_video` are unchanged.
  The per-shot caption preview video (`<episode_id>_with_caption.mp4`) is still written locally but not released.

## Cut frames

`shot_frame_ranges` and `cut_frames` are the configured ranges (`[0,75], [75,150], …`). MultiShotMaster's visible hard
cut usually lands one frame after the configured cut. Each `metadata.json` also has `measured_cut_frames` (and
`measured_cuts` with offset and strength): per cut, the frame with the strongest mean grayscale change within
[configured − 2, configured + 8]. The distribution of offsets is in `runs/run_manifest.json`.