Beyond the Frame: Benchmarking Long-Horizon Coherence in Generative Visual Narratives

Draft v0.1.0 — 6 September 2026. Companion to the Visual Story Benchmark release v0.1.0. Every number below is computed by the released code from the frozen release; the evidence status of each claim is stated where it is made and summarised in §12.

Abstract

Text-to-image models produce striking single images, but a story is a sequence of images that must agree with each other: the same person in the same clothes, an umbrella that stays broken after the wind breaks it, three balloons that become two and never three again. We introduce the Visual Story Benchmark (VSB), a benchmark for long-horizon narrative coherence built on procedurally generated stories with exact, machine-checkable world state. Each story is a world specification, a sequence of scene texts, and, for every scene, an expected state and a list of atomic requirements. Requirements are labelled by consistency dimension (identity, clothing, object persistence, object state, spatial arrangement, environment, causal continuity, chronology, action, adherence) and, crucially, by whether the fact is stated in the scene text or must be remembered from earlier scenes. This separates text–image adherence from coherence. VSB includes six prompting conditions (from independent scenes to structured memory and previous-image conditioning), provider-neutral model adapters with content-addressed caching and cost accounting, a multi-evaluator scoring stack (a blind structured-state extractor, rule checking, pairwise visual-consistency signals, CLIP/DINOv2 embeddings, and a calibrated VLM judge), an eleven-class failure taxonomy with a searchable gallery, a blinded, quality-controlled human-rating protocol with reliability statistics, and a judge-validation study that measures every automatic signal against a sealed oracle of injected faults and, when available, against humans. Release v0.1.0 contains 40 stories, 210 scenes, 3,865 requirements and 640 runs. Because no image-generation or VLM credentials were available in the build environment, all runs use procedural simulators with stated fault parameters; they establish that a perfect model scores 100% on every dimension, that injected faults are recovered with 98.5% recall, that paired story-level statistics detect known differences and known intervention effects, and that cheap visual-stability signals (histogram intersection, DINO consecutive similarity) are anti-correlated with fault presence because sticky drift makes wrong frames look alike. We release stories, code, images, metadata and the site, and we state precisely which claims the current evidence supports.

1. Introduction

Visual storytelling asks a generator to render a sequence of scenes from a narrative. The problem has a long history in story visualisation on cartoon datasets [Li et al., 2019; Maharana et al., 2022; Pan et al., 2024], has been reframed for open-ended stories [Liu et al., 2024a] and for video [Bugliarello et al., 2023], and has driven a line of consistent-subject generation methods [Ruiz et al., 2023; Gal et al., 2023; Avrahami et al., 2024; Tewel et al., 2024; Zhou et al., 2024]. Evaluation, however, has lagged. Most metrics judge one image against one prompt [Hessel et al., 2021; Hu et al., 2023; Cho et al., 2024; Lin et al., 2024], and consistency is usually reduced to a similarity between pairs of images — identity embeddings for faces [Deng et al., 2019], CLIP or DINO features for subjects [Radford et al., 2021; Oquab et al., 2024]. Similarity measures stability; it cannot tell whether an object that should have disappeared is still there, whether a state transition happened, or whether two characters are standing in the right order.

We argue that long-horizon coherence needs a reference world state. If the benchmark knows, for every scene, exactly which characters are present with which attributes, which objects exist in which state and in whose hands, and where everyone stands, then coherence becomes a set of discrete checks rather than a vibe. Procedural generation makes this feasible: a story template plus a seed yields a world, an event sequence, and — by replaying events through a state machine — the expected state of every scene. The scene text is written the way a screenwriter would write it: full descriptions in scene 1, then names, places and changes. Everything the text does not restate becomes a memory requirement.

Contributions.

1. A narrative state representation with a validated JSON Schema, a transition-checked state machine, and per-scene requirements tagged by dimension, failure class and source (stated vs remembered).
2. A procedural story generator: ten categories × three tiers with reversal traps; culturally neutral by construction; deterministic in a seed.
3. An intervention arm of six prompting conditions, so the benchmark measures what helps rather than only who wins.
4. A multi-evaluator scoring stack in which no single evaluator determines coherence, plus a sealed-oracle methodology for validating evaluators with simulators of known fault rates.
5. Component-first reporting: ten dimensions with story-clustered bootstrap CIs, paired comparisons, and a documented, sensitivity-tested global score.
6. A failure taxonomy, gallery, human-rating protocol with quality control and reliability statistics, and a judge-validation study — all released with an explicit evidence ledger.

2. Related work

Story visualisation. StoryGAN [Li et al., 2019] introduced the task on PororoSV and FlintstonesSV; StoryDALL-E [Maharana et al., 2022] adapted pretrained text-to-image transformers with story continuation; AR-LDM [Pan et al., 2024] and Make-A-Story [Rahman et al., 2023] use autoregressive latent diffusion with memory; StoryGen / Intelligent Grimm [Liu et al., 2024a] targets open-ended stories with unseen characters and releases StorySalon; StoryBench [Bugliarello et al., 2023] evaluates continuous story visualisation for text-to-video with action execution, story continuation and story generation tasks. These benchmarks rely on reference images or human judgement; VSB instead supplies a machine-readable expected state.

Consistent subjects. DreamBooth [Ruiz et al., 2023], Textual Inversion [Gal et al., 2023] and IP-Adapter [Ye et al., 2023] personalise a subject; The Chosen One [Avrahami et al., 2024], ConsiStory [Tewel et al., 2024] and StoryDiffusion [Zhou et al., 2024] pursue consistent characters across prompts without per-subject training. They are candidate systems for VSB; the benchmark asks what happens to objects, states and arrangements, not only to the protagonist's face.

Text-to-image evaluation. CLIPScore [Hessel et al., 2021], TIFA [Hu et al., 2023], DSG [Cho et al., 2024], VQAScore [Lin et al., 2024], GenEval [Ghosh et al., 2023], T2I-CompBench [Huang et al., 2023] and HEIM [Lee et al., 2023] evaluate single images against prompts, several through question generation and answering. VSB's VLM judge follows DSG's atomic-question discipline but derives questions from the state rather than from the prompt, which is what makes memory facts checkable. Preference models [Xu et al., 2023; Kirstain et al., 2023; Wu et al., 2023] measure single-image quality and are natural additions for RQ3 on real models.

Model-as-judge reliability. LLM judges are useful but biased [Zheng et al., 2023; Liu et al., 2023; Wang et al., 2023]; long contexts degrade recall of mid-context facts [Liu et al., 2024b]. VSB treats every judge as a measurement with a validation study, and its full_context condition exists precisely to expose long-context degradation in generators.

Visual narrative understanding. VIST [Huang et al., 2016] and Winoground [Thrush et al., 2022] probe narrative and compositional understanding in the reverse direction (images → text, or matching); VSB's structured-state extraction is the generation-side counterpart.

3. Benchmark design

3.1 The story unit

A story is a JSON document (schema in the release) with a world specification (1–3 characters with six attributes each; 0–3 objects with kind, colour, state and optional count; locations with time and weather), a scene sequence with events and text, expected states, requirements, and causal dependencies. Ten categories cover the phenomena in the brief: object persistence, wardrobe, location transitions, counting, possession, cause/effect, damage and state change, character relationships, spatial arrangement, temporal progression. Tiers fix length and complexity (easy 3 scenes / 1 character; medium 5 / 2; hard 8 / 2–3 with reversal traps: an object handed away and back, a character who exits and re-enters, an object set down and picked up again still broken). The default suite is 4 stories per category (easy, medium, medium, hard) = 40 stories, 210 scenes, 3,865 requirements; a different seed yields a different suite of identical structure.

3.2 Avoiding narrow or harmful content

Names are short and drawn from many languages with no gender or ethnicity marker. Skin tones are five neutral lightness labels drawn uniformly; hair, clothing and objects are generic. No template encodes occupation, religion, nationality or body type. We keep skin tone as an identity attribute because identity drift across skin tone is a known failure of real models that a coherence benchmark must be able to see (§13).

4. Narrative state representation

Fifteen event types (enter, exit, move, set_time, set_weather, appear, remove, change_state, give, drop, pickup, set_count, change_attr, swap, set_pose) drive a state machine that refuses impossible transitions. Replaying a scene's events yields its expected state; from the state we enumerate requirements: presence or absence of each character seen so far; six attributes per present character; pose; presence, holder, condition and count of each object; absence of each object that has left the story (a resurrection check); left-to-right order of adjacent characters; location, weather and time. A requirement's dimension and failure class follow from its kind; its source is prompt if the fact key is among the facts the scene text states, else memory. Causal dependencies mark objects whose state changed as the effect of a stated cause; their state checks belong to causal continuity in the cause scene and every later scene until the state changes again.

Two aggregate scores follow directly: adherence (pass rate over prompt requirements) and coherence (pass rate over memory requirements).

5. Models

5.1 Adapters

A provider-neutral interface (generate(request) → PNG + metadata + cost) is implemented for OpenAI Images (generations, and edits for image conditioning), Replicate (any text-to-image model; image input for Kontext-style models), Stability v2beta, Google Imagen, a stored-samples adapter for images produced elsewhere, and procedural simulators. Credentials are environment variables read at call time; a missing one skips the model. A content-addressed cache keyed by model, version, prompt, seed, parameters and reference-image hashes guarantees that identical requests are never regenerated; a ledger records latency, failures and approximate cost from a dated pricing table.

5.2 Procedural simulators (the models on this release)

No credentials were available, so v0.1.0 evaluates five simulators. A simulator reads the story, corrupts the expected state stochastically, and renders the corrupted state with a deterministic flat-colour renderer. Per fact and scene, the corruption probability is p_adherence if the fact is stated in the scene text; p_adherence × context factor if the condition supplies it through context (structured memory 1.0, summarised 1.3, full context 1.6); p_memory × image_bonus for visual facts when a reference image is supplied; otherwise p_memory. Drifted facts persist with probability 0.7. The chain is re-simulated from scene 1 on every call, so outputs are a pure function of (model, story, condition, seed, scene). Every injected fault is written to a sealed oracle that no evaluator reads.

simulator	p_memory	p_adherence	image_bonus	intended role
oracle	0	0	–	evaluator false-positive floor
drift-low	0.04	0.01	0.35	mild drift
drift-mid	0.12	0.02	0.35	reference
amnesiac	0.35	0.01	0.25	superb single images, no memory
sloppy	0.03	0.15	0.60	good memory, poor adherence

Simulators are not models of any real system. They exist to validate the measurement stack: what does a perfect model score, are injected faults recovered, and do the statistics detect differences and effects of known sign and size?

6. Evaluation metrics

No single evaluator determines coherence. All are recorded as measurements and compared in §11.

1. Blind structured-state extractor. Prompted with the world's entity vocabulary only (the analogue of giving an open-vocabulary detector its class names), it finds heads by skin-tone components, reads hair, top, trousers, accessory and pose from geometry-anchored samples, classifies objects by colour and shape signature (fill ratio, aspect, fragment count), counts small components, and reads location, time and weather from ground and sky colours. On true renders it raises zero violations over 15,460 checks. It is renderer-specific and detects nothing on real-model images; that is by design and by disclosure.
2. Rule checker. Assigns detected people to expected characters by weighted attribute distance (identity attributes weigh most), then evaluates every requirement; knock-on failures are attributed to the root cause (an undetected object fails its state check as a disappearance).
3. Pairwise pixel consistency. Colour-histogram intersection between consecutive frames, globally and on the figure band.
4. Embeddings. CLIP ViT-B/32 text–image similarity per scene; DINOv2-small CLS similarity between consecutive frames.
5. VLM QA judge. Each requirement becomes a YES/NO/UNSURE question under a calibrated system prompt; UNSURE never passes. Implemented for OpenAI-compatible and Anthropic endpoints with a fixture mode; not run on this release.

Scores. Per run, each dimension's score is its requirement pass rate. Model-level scores are macro-averages over stories with story-clustered percentile-bootstrap 95% CIs (2,000 resamples). The global score is the unweighted mean of the ten dimensions; it is reported after the components, and a 1,000-draw Dirichlet weight perturbation reports rank stability.

7. Human evaluation

The site's /evaluate route runs blinded sessions: model identities become letters re-randomised per session; items are single-story ratings on six 1–5 scales (identity consistency, object consistency, causal coherence, narrative coherence, visual quality, prompt adherence), pairwise preferences, control pairs with a known answer (the perfect model vs the memory-less amnesiac under independent prompting) and one repeated item; item times are recorded. Exports are validated against a schema; raters below 75% control accuracy or under 4 s median time are excluded; Krippendorff's α (ordinal, interval), ICC(2,k) on complete subsets, per-model means with CIs, pairwise preference tables and a mixed-effects model (rating ~ model + (1|story) + (1|rater)) are computed.

Status. No human ratings have been collected. The pipeline was exercised on six synthetic raters whose scores are oracle-derived plus Gaussian noise; all passed QC (control accuracy 100%, duplicate |Δ| 0.3–1.2 points), and ordinal α was 0.33–0.39 for identity, object and narrative coherence and ≈0 for visual quality (which the simulation holds constant). These numbers verify code paths only.

8. Results

All results: release v0.1.0, primary condition structured_memory, 40 stories per cell. Simulators throughout.

8.1 Leaderboard (component metrics)

model	identity	clothing	obj. persist.	obj. state	spatial	environment	causal	chronology	action	adherence	coherence	global
oracle	100.0	100.0	100.0	100.0	100.0	100.0	100.0	100.0	100.0	100.0	100.0	100.0
drift-low	99.7	97.5	96.9	89.5	98.1	99.6	93.6	99.2	99.2	99.4	98.1	98.2
amnesiac	96.3	97.2	96.5	91.9	93.5	99.7	100.0	99.7	98.3	98.7	96.3	97.5
drift-mid	96.1	95.0	95.4	95.6	97.1	97.2	80.0	97.7	98.2	97.7	95.1	96.4
sloppy	75.5	67.2	74.9	74.2	53.0	80.3	62.9	84.0	81.6	83.3	68.9	76.4

Paired story-level comparisons on the global score: every model differs significantly from the oracle (Δ 1.8–23.6 points, 95% CIs exclude 0) and from sloppy (Δ ≥ 20 points); drift-low, amnesiac and drift-mid are not separated from each other (|Δ| ≤ 1.9 points, CIs include 0). This is the correct answer: under structured-memory prompting nearly every persistent fact is restated, so memory hazards barely matter and what remains is p_adherence, which is similar for those three. Weight sensitivity: mean Kendall τ between equal-weight and perturbed rankings 0.89; oracle and sloppy keep their ranks under 100% of weightings, drift-mid under 91%, drift-low and amnesiac swap under roughly half.

8.2 RQ1 — decay with story length

Under independent prompting the memory pass rate falls from 68% (scene 2) to 27% (scene 8) for the amnesiac (fitted λ = 0.116 per scene) and from 81% to 74% for drift-mid (λ = 0.017). Under structured_memory every curve is flat (|λ| ≤ 0.004) because the prompt restates the state. Decay is therefore a property of model × condition, and VSB reports it per condition. Tier effects appear only where memory matters: drift-mid's global score is 98.8 / 96.8 / 93.1 for easy / medium / hard under the primary condition; the amnesiac's is flat (96.7 / 97.8 / 97.7).

8.3 RQ2 — which dimensions fail first

Among stories with any failure (primary condition), the first violation is most often in character identity (34–37% of stories for drift-mid and the amnesiac) and clothing (21–26%), followed by action (9–15%). This reflects requirement density (six attributes per character per scene) as much as fragility; the per-dimension position of first failure is reported alongside, and the same analysis under independent prompting is on the site.

8.4 RQ3 — single-image quality vs coherence

With adherence as the single-image proxy, the five simulators' adherence and coherence are rank-correlated (ρ ≈ 1.0, n = 5) because their parameters are. The designed counter-example is visible at the story level: the amnesiac has the second-highest adherence (98.7%) but under independent prompting its coherence collapses to 45.1%, whereas drift-mid keeps 74.6%. Single-image quality does not entail coherence once the prompt stops restating the world. On real models this question needs preference-model scores and is open.

8.5 RQ5 / RQ6 — prompting interventions (paired, story-level)

comparison	amnesiac Δ coherence [95% CI]	drift-mid Δ coherence [95% CI]
structured memory − independent	+51.2 [46.5, 55.6]	+20.5 [16.0, 25.5]
summarised state − independent	+51.2 [46.4, 55.6]	+18.7 [14.6, 22.8]
full context − independent	+50.9 [46.3, 55.3]	+18.2 [13.5, 23.3]
previous image − independent	+33.3 [27.4, 38.8]	+13.8 [8.3, 19.2]
previous text − independent	+14.3 [8.7, 19.7]	+10.6 [5.6, 16.0]
previous image − structured memory	−18.0 [−20.8, −15.2]	−6.7 [−11.4, −3.1]
full context − structured memory	−0.3 [−2.7, +1.9]	−2.3 [−4.7, +0.3]

Explicit state prompting (structured or summarised) yields the largest gains; previous-image conditioning helps but less; previous text alone helps least. Full context is statistically indistinguishable from structured memory for both simulators despite its higher context factor. These are demonstrations of detection power: the effects were parameterised into the simulators. What the table shows is that the paired design recovers them with tight intervals from 40 stories.

8.6 Prompt sensitivity and cost

The paraphrase arm changes nothing for simulators (Δ = 0.000, by construction). Generation cost is zero and p50 latency 4 ms per image; the cost dimension becomes informative only with hosted models.

9. Failure taxonomy

7,280 violations across all 640 runs, labelled into eleven classes: identity drift 34%, attribute drift 32%, object disappearance 9%, adherence failure 8%, background drift 8%, spatial contradiction 5%, state reversal 2%, chronology violation 2%, causal contradiction 0.4%, resurrection 0.1%, count inconsistency 0.1%. Identity and clothing dominate partly because each present character carries six attribute requirements per scene and partly because an omitted character fails all of them. The gallery on the site is searchable by class, model, category, tier and scene, and every card links to the full story analysis with expected vs detected state.

10. Prompting interventions as a benchmark component

Reporting a leaderboard under a single prompting strategy would confound the model with the harness. VSB fixes the scene text and varies only the context, so a system can be characterised by its response surface over conditions: how much it gains from explicit state, whether it can use a reference image, whether long contexts hurt. The primary board uses structured memory because it is the benchmark's own state representation; the intervention tables are first-class outputs.

11. Automatic evaluator validation

Against the sealed oracle (3,360 simulator scenes). The rule checker recovers injected faults with 98.5% recall overall; ≥ 97% in every class with ≥ 100 injections (identity drift 97.2%, attribute drift 99.1%, background drift, state reversal, chronology, count and object disappearance 100%, adherence failure 98.0%, spatial contradiction 99.4%). Precision is 74.4% when knock-on flags are counted as false positives (object disappearance 44.8%: an omitted object also fails its holder's "holding" requirement; identity 76%: an omitted character fails six attribute checks). Story-level rank correlation between rule-checker coherence and oracle coherence is ρ = 0.97 [0.96, 0.98].

Continuous signals. At the scene level, none of the stability signals detects faults: histogram intersection AUROC 0.42, DINOv2 consecutive similarity 0.40, CLIP text–image 0.37 — all below chance. The reason is visible in the simulator design and, we argue, in real models too: drift is sticky, so a frame that inherits last frame's wrong hair colour is more similar to its predecessor than a frame that corrects it. Stability is not correctness. At the story level the same signals correlate weakly with oracle coherence (DINO ρ = 0.29, histogram min 0.32, CLIP 0.12). A consistency benchmark that scores similarity alone would reward persistent errors.

Against humans. Not available. On synthetic raters, rule-based scores correlate with the simulated "narrative coherence" scale at ρ ≈ 0.2–0.4 and embedding signals at ρ ≈ 0.1–0.2; these numbers are a function of the injected rater noise and carry no evidence about people.

12. Limitations

• No real model has been evaluated. Adapters are transport-tested only. Every table is about simulators with stated parameters.
• The extractor is renderer-specific. Real-model images require the embedding and VLM evaluators and humans; validating those is the purpose of the judge study, which is currently possible only against the oracle.
• Forty stories is enough for paired detection of large effects; the suite scales by seed but confidence intervals on subtle differences will need hundreds.
• Requirement density weights identity and clothing heavily in counts and in the first-failure analysis; per-dimension scores are unweighted within dimension and are the primary reporting unit for that reason.
• Simulator parameters were chosen by us, including how conditions modulate fault rates; intervention results are demonstrations, not findings.
• Human protocol untested on humans; QC thresholds (75% control accuracy, 4 s median) are priors.
• Pricing is a hand-entered table with an as-of date; cost results are meaningful only once hosted models run.

13. Ethics

Stories are procedurally generated; no scraped images, characters or copyrighted text are used or redistributed. Characters have no ethnicity, gender, religion, occupation or body-type markers; names are cross-cultural; skin tone is retained as a neutral five-level attribute because coherence failures along skin tone are a documented harm in generative models and a benchmark that cannot see them would understate it. Face-identity embeddings are not used on this release; if added for real models, they should be run on synthetic characters only and never on photographs of real people. Human raters are pseudonymous; exports contain no personal data beyond the chosen id and timing. Model-as-judge outputs are labelled as measurements with known biases.

14. Conclusion

VSB turns "is this story coherent?" into thousands of checkable facts, each tagged by dimension and by whether the model had to remember it. Release v0.1.0 delivers the complete loop — generation, six prompting conditions, cached generation with cost accounting, multi-evaluator scoring, taxonomy, statistics, human protocol, judge validation, immutable release and site — and validates it with simulators against a sealed oracle: a perfect model scores 100%, injected faults are recovered at 98.5% recall, paired statistics detect known effects, and similarity-based consistency metrics are shown to reward sticky errors. What it does not yet deliver is evidence about real models or real people; both are one credential and one rating session away, and the release is designed so that adding them changes numbers, not code.

References

Venues marked ✓ were verified against the proceedings or publisher during drafting; the remaining entries are cited from the authors' knowledge and must be verified before submission. No entry was invented.

• Avrahami, O., Hertz, A., Vinker, Y., Arar, M., Fruchter, S., Fried, O., Cohen-Or, D., Lischinski, D. The Chosen One: Consistent Characters in Text-to-Image Diffusion Models. SIGGRAPH 2024.
• Bugliarello, E., Moraldo, H., Villegas, R., Babaeizadeh, M., Saffar, M. T., Zhang, H., Erhan, D., Ferrari, V., Kindermans, P.-J., Voigtlaender, P. StoryBench: A Multifaceted Benchmark for Continuous Story Visualization. NeurIPS 2023 Datasets and Benchmarks. ✓
• Cho, J., Hu, Y., Baldridge, J., Garg, R., Anderson, P., Krishna, R., Bansal, M., Pont-Tuset, J., Wang, S. Davidsonian Scene Graph: Improving Reliability in Fine-grained Evaluation for Text-to-Image Generation. ICLR 2024. ✓
• Deng, J., Guo, J., Xue, N., Zafeiriou, S. ArcFace: Additive Angular Margin Loss for Deep Face Recognition. CVPR 2019.
• Efron, B. Bootstrap Methods: Another Look at the Jackknife. Annals of Statistics, 1979.
• Gal, R., Alaluf, Y., Atzmon, Y., Patashnik, O., Bermano, A. H., Chechik, G., Cohen-Or, D. An Image is Worth One Word: Personalizing Text-to-Image Generation using Textual Inversion. ICLR 2023.
• Ghosh, D., Hajishirzi, H., Schmidt, L. GenEval: An Object-Focused Framework for Evaluating Text-to-Image Alignment. NeurIPS 2023.
• Hessel, J., Holtzman, A., Forbes, M., Le Bras, R., Choi, Y. CLIPScore: A Reference-free Evaluation Metric for Image Captioning. EMNLP 2021.
• Hu, Y., Liu, B., Kasai, J., Wang, Y., Ostendorf, M., Krishna, R., Smith, N. A. TIFA: Accurate and Interpretable Text-to-Image Faithfulness Evaluation with Question Answering. ICCV 2023.
• Huang, K., Sun, K., Xie, E., Li, Z., Liu, X. T2I-CompBench: A Comprehensive Benchmark for Open-world Compositional Text-to-image Generation. NeurIPS 2023.
• Huang, T.-H., Ferraro, F., Mostafazadeh, N., et al. Visual Storytelling. NAACL 2016.
• Kirstain, Y., Polyak, A., Singer, U., Matiana, S., Penna, J., Levy, O. Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation. NeurIPS 2023.
• Krippendorff, K. Content Analysis: An Introduction to Its Methodology. Sage, 2004.
• Lee, T., Yasunaga, M., Meng, C., et al. Holistic Evaluation of Text-to-Image Models. NeurIPS 2023.
• Li, Y., Gan, Z., Shen, Y., Liu, J., Cheng, Y., Wu, Y., Carin, L., Carlson, D., Gao, J. StoryGAN: A Sequential Conditional GAN for Story Visualization. CVPR 2019.
• Lin, Z., Pathak, D., Li, B., Li, J., Xia, X., Neubig, G., Zhang, P., Ramanan, D. Evaluating Text-to-Visual Generation with Image-to-Text Generation. ECCV 2024. ✓
• Liu, C., Wu, H., Zhong, Y., Zhang, X., Wang, Y., Xie, W. Intelligent Grimm — Open-ended Visual Storytelling via Latent Diffusion Models. CVPR 2024. ✓ (2024a)
• Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., Liang, P. Lost in the Middle: How Language Models Use Long Contexts. TACL 2024. (2024b)
• Liu, Y., Iter, D., Xu, Y., Wang, S., Xu, R., Zhu, C. G-Eval: NLG Evaluation using GPT-4 with Better Human Alignment. EMNLP 2023.
• Maharana, A., Hannan, D., Bansal, M. StoryDALL-E: Adapting Pretrained Text-to-Image Transformers for Story Continuation. ECCV 2022.
• Oquab, M., Darcet, T., Moutakanni, T., et al. DINOv2: Learning Robust Visual Features without Supervision. TMLR 2024.
• Pan, X., Qin, P., Li, Y., Xue, H., Chen, W. Synthesizing Coherent Story with Auto-Regressive Latent Diffusion Models. WACV 2024.
• Radford, A., Kim, J. W., Hallacy, C., et al. Learning Transferable Visual Models From Natural Language Supervision. ICML 2021.
• Rahman, T., Lee, H.-Y., Ren, J., Tulyakov, S., Mahajan, S., Sigal, L. Make-A-Story: Visual Memory Conditioned Consistent Story Generation. CVPR 2023.
• Ruiz, N., Li, Y., Jampani, V., Pritch, Y., Rubinstein, M., Aberman, K. DreamBooth: Fine Tuning Text-to-Image Diffusion Models for Subject-Driven Generation. CVPR 2023.
• Shrout, P. E., Fleiss, J. L. Intraclass Correlations: Uses in Assessing Rater Reliability. Psychological Bulletin, 1979.
• Tewel, Y., Kaduri, O., Gal, R., Kasten, Y., Wolf, L., Chechik, G., Atzmon, Y. Training-Free Consistent Text-to-Image Generation. ACM Transactions on Graphics 43(4), 2024 (SIGGRAPH). ✓
• Thrush, T., Jiang, R., Bartolo, M., Singh, A., Williams, A., Kiela, D., Ross, C. Winoground: Probing Vision and Language Models for Visio-Linguistic Compositionality. CVPR 2022.
• Wang, P., Li, L., Chen, L., et al. Large Language Models are not Fair Evaluators. arXiv 2023.
• Wu, X., Hao, Y., Sun, K., et al. Human Preference Score v2: A Solid Benchmark for Evaluating Human Preferences of Text-to-Image Synthesis. arXiv 2023.
• Xu, J., Liu, X., Wu, Y., et al. ImageReward: Learning and Evaluating Human Preferences for Text-to-Image Generation. NeurIPS 2023.
• Ye, H., Zhang, J., Liu, S., Han, X., Yang, W. IP-Adapter: Text Compatible Image Prompt Adapter for Text-to-Image Diffusion Models. arXiv 2023.
• Zheng, L., Chiang, W.-L., Sheng, Y., et al. Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena. NeurIPS 2023.
• Zhou, Y., Zhou, D., Cheng, M.-M., Feng, J., Hou, Q. StoryDiffusion: Consistent Self-Attention for Long-Range Image and Video Generation. NeurIPS 2024. ✓