Lens: Rethinking Training Efficiency for Foundational Text-to-Image Models

🎯 Pitch

A 3.8B-parameter text-to-image model trained with GPT-4.1-generated captions averaging 109 words per image can match or beat models with over 6B parameters while using just 19.3% of the training compute. This upends the assumption that massive scale is necessary for quality, showing that packing vastly denser language supervision into each training batch is a far more efficient lever.

1. Executive Summary

This paper introduces Lens, a 3.8B-parameter foundational text-to-image model designed for training-time efficiency that achieves performance competitive with or surpassing state-of-the-art models exceeding 6B parameters across multiple benchmarks (OneIG, GenEval, LongText, CVTG). Lens derives its efficiency from two complementary strategies: maximizing data information density per training batch — through dense GPT-4.1 captions averaging 109 words (vs. conventional short captions) and mixed-resolution/aspect-ratio batch construction (spanning 512² to 1024² across nine aspect ratios) — and accelerating convergence speed — through a semantically rich VAE (FLUX.2-VAE) and a strong multilingual language encoder (GPT-OSS, 20B-MoE with 3B activated parameters) that provides richer semantic text features and emergent multilingual generalization from English-only training. The model requires only approximately 19.3% of the training compute used by Z-Image (192K A100 GPU hours vs. 314K H800 GPU hours), while its distilled 4-step variant (Lens-Turbo) generates a 1024² image in 0.84 seconds on a single NVIDIA H100 GPU, establishing that compact architectures combined with information-dense training and systematic post-training (RL with taxonomy-driven prompts and rubric-structured rewards) can match or exceed much larger models — but only when the three efficiency factors of model size, data information density, and convergence speed are jointly optimized rather than treated independently.

2. Context and Motivation

The Core Problem: Training Foundational T2I Models Has Become Prohibitively Expensive

This paper addresses a specific, intensifying problem in text-to-image generation: the computational cost of training state-of-the-art foundational models has grown to the point where it creates a genuine accessibility and scalability crisis. The authors frame this not as a gradual trend but as a structural inefficiency in how the field approaches model development.

The raw numbers are stark. The paper cites Z-Image — a representative 6B-parameter open-source T2I model — as requiring approximately 314,000 H800 GPU hours for pre-training. When normalized to peak BF16 TFLOPS for cross-GPU comparison, this translates to a computational expenditure that prices out most academic labs, smaller companies, and researchers in lower-resource settings. The scaling trend in the field compounds this problem: recent open-source models operate at 6B parameters (Z-Image, LongCat-Image), 9B (FLUX.2-Klein), 20B (Qwen-Image), and even 80B with Mixture-of-Experts architectures (Hunyuan-Image-3.0). Each step up in scale brings corresponding increases in training cost, creating what the authors implicitly characterize as an unsustainable trajectory where only the largest industrial labs can participate in foundational T2I research.

The problem is not merely financial — it carries environmental implications (energy consumption, carbon footprint) and, more subtly, a concentration of research capability that narrows the diversity of approaches and applications explored. When training a single model requires hundreds of thousands of GPU hours, the iteration cycle for architectural innovations, data strategies, and training recipes slows dramatically, since each experiment is extraordinarily expensive.

Beyond Model Size: The Three-Factor Efficiency Gap

The paper's diagnostic insight is that the field has over-indexed on model scale as the primary lever for improving T2I performance while under-exploring two other factors that jointly determine training efficiency. The authors articulate this through their three-factor decomposition (Section 1):

"We argue that training-time efficiency is jointly determined by three key factors: (1) model size, which directly affects the computational cost of each training step; (2) data information density per training batch, which determines how much useful supervision the model can extract from each update; and (3) convergence speed, which determines the overall number of training iterations."

This decomposition is not merely a taxonomy — it is a diagnosis of where prior work leaves efficiency gains on the table. Reducing model size (factor 1) helps per-step cost but risks degrading quality if the other two factors aren't simultaneously optimized. The paper's central argument is that by maximizing data information density and convergence speed, a smaller model can extract more learning per FLOP and converge faster, achieving strong performance at substantially lower total cost. Each factor represents an underexplored dimension of the efficiency problem.

Factor 2 — Data information density — is underexplored because of how T2I datasets are conventionally constructed. Most prior work uses web-crawled alt-text captions, which are characteristically short, underspecified, and sometimes factually incorrect. The paper explicitly identifies this as a source of inefficiency:

"Web-crawled alt-text captions are often short, underspecified, and sometimes incorrect. Such noisy supervision forces the model to resolve ambiguity during training, leading to inefficient capacity usage and degraded learning signals."

This creates a training signal bottleneck: the model spends optimization steps resolving labeling ambiguity rather than learning fine-grained visual-semantic correspondences. The image side of each training batch is similarly underutilized when models are trained at a single resolution and aspect ratio — the model sees only one scale of visual detail and one compositional layout per image, wasting the rich multi-scale information present in the underlying pixels.

Factor 3 — Convergence speed — is underexplored because architectural choices (VAE, language encoder) are typically evaluated on proxy metrics that don't directly measure their impact on T2I training dynamics. The paper notes that VAE selection is conventionally driven by reconstruction fidelity (rFID) or class-conditional ImageNet generation performance, but:

"Reconstruction fidelity mainly measures how well a VAE reproduces a given image, rather than how effectively its latent space supports generative learning."

This is a subtle but important distinction. A VAE optimized purely for pixel-level reconstruction may produce a latent space that is semantically entangled — where related concepts are scattered across dimensions — forcing the diffusion model to expend training iterations disentangling them before learning useful text-image alignments. A semantically organized latent space, by contrast, presents the diffusion model with a representation where related visual concepts cluster naturally, reducing the number of optimization steps needed to reach equivalent generation quality. The language encoder is subject to a similar dynamic: a stronger encoder provides a richer semantic text space that makes text-image alignment easier to learn, but prior work rarely ablates this choice as a convergence accelerator.

The Inference-Time Generalization Bonus

The paper identifies a complementary benefit that further motivates their approach: when data information density and architectural choices are optimized for efficient training, they produce capabilities at inference time that would otherwise require additional, expensive training. Two examples illustrate this.

First, mixed-resolution and multi-aspect-ratio training produces resolution generalization — the ability to generate images at resolutions and aspect ratios never seen during training:

"The model generalizes well to unseen resolutions and aspect ratios at inference time. Specifically, it can generate images with arbitrary aspect ratios ranging from 1:2 to 2:1 and image areas up to 1440², even though training does not include resolutions between 1024² and 1440², nor aspect ratios outside the predefined bucket set."

This is economically significant because training on higher resolutions incurs quadratic increases in computational cost. If a model can be trained primarily on lower-resolution images and still produce high-resolution outputs at inference time, this represents a substantial training cost reduction without sacrificing output quality — effectively decoupling training resolution from generation resolution.

Second, a strong language encoder trained on English-only data produces multilingual generalization — the ability to accept prompts in Chinese, French, Japanese, and Spanish at inference time despite never seeing non-English training captions:

"Although the model is trained only on English image-text pairs, a strong language encoder enables robust inference-time generalization to other languages."

This eliminates the need to collect, caption, and train on multilingual image-text pairs — a data engineering challenge that would otherwise be required to support multilingual users. The convergence acceleration and the multilingual generalization are two sides of the same coin: the stronger language encoder provides both faster learning on English data and emergent cross-lingual transfer.

Where Prior Approaches Fall Short

The paper identifies specific limitations across several components of the T2I pipeline that collectively explain why prior models achieve their performance at such high computational cost.

Caption quality is treated as secondary. The dominant paradigm in prior T2I training uses web-crawled alt-text captions with minimal curation. The paper explicitly contrasts this with their approach:

"Conventional short captions provide limited supervision, as they often describe only the most salient object or scene category. In contrast, dense captions encode richer semantic details, including objects, attributes, spatial relationships, actions, and background context, allowing each image-text pair to provide stronger training signals."

This is framed as a data efficiency argument: short captions waste model capacity on resolving ambiguity, while dense captions make each training example count for more. The paper provides a controlled ablation (Figure 4) showing that models trained on dense captions reach higher GenEval scores at every training step compared to models trained on brief or mixed captions, but the underlying mechanism — the model doesn't need to learn what's not in the caption — is what makes this a data information density improvement rather than just a data quality improvement.

VAE selection is based on the wrong metrics. The field has converged on evaluating VAEs using reconstruction fidelity (rFID, PSNR, SSIM) or class-conditional generation on ImageNet. The paper identifies a mismatch:

"Such latents may be semantically entangled, difficult for diffusion models to learn, and can slow down convergence during training."

While the paper cites prior theoretical work (Yao et al., "Reconstruction vs. Generation") that identified the reconstruction-generation tradeoff, the practical consequence — that the choice of VAE can materially accelerate or decelerate T2I training convergence — had not been systematically demonstrated with direct T2I training comparisons. The paper's contribution here is not the theoretical insight but the empirical demonstration (Figure 5) that the FLUX.2-VAE (a semantic VAE) significantly outperforms the FLUX.1-VAE and SD3-VAE (conventional reconstruction-oriented VAEs) when evaluated directly in a T2I training setting, with performance gaps appearing early in training and persisting throughout.

Language encoder strength is undervalued as a convergence factor. Prior work treats the text encoder as a fixed component — typically using CLIP or T5 at some scale — without systematically ablating how encoder capacity affects T2I training dynamics. The paper's comparison of GPT-OSS (20B-MoE, 3B activated) against Qwen3 variants at 0.6B, 1.7B, and 4B parameters (Figures 7 and 8) reveals that encoder quality drives both faster convergence on English prompts and emergent multilingual performance, with GPT-OSS substantially outperforming smaller encoders at every training step on both metrics.

Post-training RL lacks structured diversity. The paper identifies a specific failure mode in RL-based post-training for T2I models: when the RL prompt set is too narrow, the model overfits to specific generation scenarios and degrades on others:

"A key observation in this work is that RL prompts should match the generation-scenario distribution of the pre-training data as comprehensively as possible. This enables post-training to improve the model's overall generation quality and alignment across diverse scenarios, rather than overfitting to a narrow set of prompt types."

Prior RL approaches for T2I (DPO-based methods like Diffusion-DPO and D3PO, GRPO-based methods like Flow-GRPO) focus on reward design and optimization algorithms but do not systematically address prompt set diversity as a factor in post-training generalization. The paper's taxonomy-driven construction of Lens-RL-8K — with 10 coarse categories (Human, Object, Animal, Plant, Scene, Food, Event, Fictional World, Text, UI/Graphic Design), dozens of fine-grained sub-categories per category, and 8,406 concrete items — is a direct response to this gap, with ablations (Table 1) confirming that reduced prompt diversity degrades benchmark performance.

Reasoner-based prompt rewriting is treated as orthogonal to the generation model. Most T2I systems that use a reasoner for prompt refinement treat it as a fixed preprocessing step — the system prompt is hand-crafted once and rarely revisited. The paper's training-free system prompt search strategy (Section 2.5) is an acknowledgment that the reasoner's system prompt is itself a hyperparameter that can be optimized, and that this optimization can yield meaningful performance improvements without model retraining. This is a system-level efficiency insight: improve the prompt quality going into the model rather than trying to make the model handle ambiguous inputs.

How This Paper Positions Itself

The paper positions Lens not as a single architectural innovation or training technique, but as a systematic demonstration that jointly optimizing the three efficiency factors — model size, data information density, and convergence speed — can match or exceed much larger models at substantially lower cost. This is an engineering thesis, not a theoretical one: the individual techniques (dense captioning, mixed-resolution training, semantic VAEs, strong language encoders, RL post-training) are not novel in isolation, but their systematic combination and controlled ablation is what the paper contributes.

The key rhetorical move is in the framing: rather than asking "how do we make the best T2I model?" (which leads to scaling up), the paper asks "how do we make a T2I model that is efficient to train and competitive in quality?" This reframing shifts the optimization target from maximum performance at any cost to Pareto-optimal performance-efficiency. Figure 2 visualizes this directly by plotting benchmark scores against inference time with marker area proportional to model size — Lens occupies a favorable position in the upper-left region of these plots (high score, low inference time, small model), making the efficiency-quality tradeoff visually explicit.

The paper is careful to acknowledge what Lens does not do. It does not claim to surpass the largest models on every metric — Qwen-Image (20B) achieves a higher GenEval overall score (0.868 vs. Lens's 0.930? — actually, checking Table 2, Qwen-Image scores 0.868 on GenEval while Lens scores 0.930, which is higher, and on OneIG Qwen-Image scores 0.539 vs. Lens's 0.557). The paper's positioning is more nuanced: Lens is competitive with or surpasses larger models while using a fraction of the training compute, which is a different claim than "Lens is the best model." The efficiency framing means the relevant comparison is not just "does Lens beat Model X on benchmark Y?" but "does Lens beat Model X on benchmark Y per unit of training compute?"

This positioning connects to a broader conversation about compute-optimal scaling that has been influential in language modeling (the Chinchilla scaling laws) but less systematically explored for image generation. The paper's three-factor decomposition can be read as an informal inference-time scaling framework: given a fixed compute budget, how should one allocate resources across model size, data processing, and architectural design to maximize generation quality? The paper doesn't formalize this as a scaling law, but the conceptual parallel is clear — just as Chinchilla showed that smaller models trained on more data can outperform larger models at equivalent compute, Lens shows that smaller T2I models trained with richer supervision and faster-converging architectures can match larger models at a fraction of the cost.

The Practical Urgency: Why Efficiency Matters Now

The paper's motivation is not purely academic. Several concrete developments make training efficiency urgent:

Model scale is still growing. The trajectory from SD3 (8B) to FLUX.1 (12B) to Qwen-Image (20B) to Hunyuan-Image-3.0 (80B MoE) shows no sign of plateauing. Each generation roughly doubles or triples parameters, and with it, training cost. Without efficiency innovations, the next generation of models will be accessible to even fewer organizations.

Multimodal models compound the problem. The paper notes (Appendix A.1) the emergence of unified multimodal models (Janus-Pro, Transfusion, BAGEL) that jointly handle text, image, video, and web data. These models require even more training compute than image-only generative models, making the efficiency problem more acute.

Inference cost matters too. While the paper focuses on training efficiency, inference cost is a growing concern for deployed T2I systems. Lens's compact 3.8B size enables 3.15-second generation at 1024² on a single H100, and 0.84 seconds with 4-step distillation. For applications requiring real-time or high-throughput generation (design tools, gaming, video generation), inference speed is a hard constraint — and smaller models have an inherent advantage.

Environmental considerations. The paper does not emphasize this, but the carbon footprint of training a 314K GPU-hour model is substantial. Reducing training compute by approximately 80% (as Lens does relative to Z-Image) has direct environmental benefits, and the paper's techniques (dense captioning, mixed-resolution training) are applicable to future models at any scale.

In summary, the paper addresses the gap between the field's focus on scaling model size for quality and the practical need for training efficiency. It argues — and demonstrates empirically — that data information density and convergence speed are under-leveraged dimensions of the efficiency problem, and that systematic optimization across all three factors can produce models that are simultaneously smaller, faster to train, and competitive in quality. The contribution is not a single technique but a demonstration of what is possible when efficiency is treated as a first-class design goal rather than an afterthought to performance maximization.

3. Technical Approach

3.1 Reader Orientation

This paper presents a system for efficiently training a text-to-image model called Lens. The system takes a large collection of images as input, processes them through a multi-stage pipeline that includes dense caption generation, controlled pre-training at multiple resolutions, reinforcement learning with rubric-guided rewards, and finally distillation into a fast few-step generator. The core idea is that by jointly optimizing what the model learns from each training example (data information density) and how quickly it converges (architectural choices for VAE and language encoder), a relatively compact 3.8B-parameter model can match or exceed the generation quality of much larger models while using only a fraction of the training compute.

3.2 Big-Picture Architecture (Diagram in Words)

The Lens system consists of seven major components connected in a sequential pipeline, with two of them — the VAE and language encoder — frozen throughout and serving as fixed feature extractors.

1. Data Processing Pipeline (Section 2.1): Raw images from four sources (public real, public synthetic, private, text synthetic) pass through a 9-stage cleaning and filtering pipeline, then each image is captioned by GPT-4.1 using a detailed captioning prompt. The output is Lens-800M, a dataset of approximately 800 million densely captioned image-text pairs.

2. Variational Autoencoder (VAE, Section 2.2): The FLUX.2-VAE (a semantic VAE) encodes each input image into a compressed latent representation at 1/8 the spatial resolution. It also decodes the final generated latents back to pixel space at inference time. The VAE is kept frozen during all training.

3. Language Encoder (Section 2.2): GPT-OSS, a 20B-parameter Mixture-of-Experts model with 3B activated parameters, converts text prompts into multi-level feature representations by extracting outputs from layers 4, 12, 18, and 24, which are concatenated and projected to match the image latent dimensionality. This encoder is also frozen during training.

4. Latent Diffusion Transformer (Section 2.2): A 48-block MMDiT architecture that takes noisy image latents and text features as input and learns to denoise them using a flow-matching objective. During pre-training on 128 NVIDIA A100 GPUs, only this component is trained — first at 512² resolution for 400K iterations, then with mixed resolutions for another 400K iterations.

5. Reasoner (Section 2.2): An independent language model (defaulting to GPT-5.5) placed before the T2I pipeline that converts ambiguous user requests into detailed, well-formed prompts aligned with the training caption distribution. It is optional at inference time and can be swapped without retraining the generation model.

6. RL Post-Training Module (Section 2.4): Uses DiffusionNFT with GPT-4.1-mini as a reward function to optimize the pre-trained model on Lens-RL-8K, a taxonomy-driven prompt set of 8,406 prompts. For each prompt, GPT-4.1 generates rubrics (evaluation criteria), and the VLM evaluates generated images against these rubrics to produce rewards.

7. Distillation Module (Section 2.4): Combines DMD2, decoupled-DMD, and SenseFlow techniques with an adversarial discriminator to distill the RL-optimized model into Lens-Turbo, a 4-step generator that does not require classifier-free guidance.

Information flows as follows: raw images → data cleaning → GPT-4.1 captioning → Lens-800M dataset → VAE encoding (images) + GPT-OSS encoding (captions) → MMDiT pre-training (400K steps low-res, 400K steps mixed-res) → RL post-training on Lens-RL-8K (180 steps) → few-step distillation (1K global steps) → Lens-Turbo. At inference time, user prompts pass through the reasoner first for refinement, then through GPT-OSS for encoding, then through the diffusion transformer for iterative denoising, and finally through the VAE decoder to produce the output image.

3.3 Roadmap for the Deep Dive

First, the pre-training dataset construction (Lens-800M), because data information density is the foundation of the efficiency argument. I will cover the four data sources, the 9-stage cleaning pipeline, and the dense captioning process with GPT-4.1, including the critical ablation study that validates dense over brief captions.
Second, the model architecture, covering the VAE (FlUX.2 semantic VAE and why it outperforms reconstruction-oriented alternatives), the GPT-OSS language encoder (multi-layer feature extraction and the ablation comparing encoder scales for both English and multilingual performance), and the MMDiT backbone (48 blocks, RMSNorm, RoPE, and the dual-branch design for image and text modalities).
Third, the two-phase pre-training recipe, because the transition from single-resolution to mixed-resolution training is what enables resolution generalization at inference time. I will cover the 27 concrete resolution buckets, logit-normal timestep sampling adaptations, per-bucket batch sizes, and the mechanism by which mixed-resolution training teaches the model continuous spatial representations rather than memorizing bucket configurations.
Fourth, the RL post-training pipeline, including the taxonomy-driven construction of Lens-RL-8K (10 categories, fine-grained sub-categories, 8,406 items, description dimensions), the rubric generation process (10 sample-aware rubrics plus one global coherence rubric per prompt), and the DiffusionNFT optimization objective with GPT-4.1-mini as the VLM reward function. I will also cover the ablations showing why prompt set diversity matters.
Fifth, the few-step distillation process, combining DMD2, decoupled-DMD, SenseFlow, and adversarial training to produce Lens-Turbo. I will cover the teacher-student setup, the fake score model, the discriminator with R1 regularization, and the training dynamics.
Sixth, the inference-time components, including the reasoner with training-free system prompt search (the iterative rewriting process that optimizes the reasoner's system prompt), and the benchmark-specific prompts used for GenEval, OneIG, LongText, and CVTG evaluation.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems engineering and empirical analysis paper whose core idea is that jointly optimizing data information density, architectural convergence speed, and model size can produce a T2I model that is Pareto-optimal in the performance-efficiency space — competitive with much larger models while requiring a fraction of the training compute.

Pre-training Data Construction: Lens-800M

Data Sources and Composition

The Lens-800M dataset is constructed from four complementary sources, each serving a distinct role in ensuring content diversity (Section 2.1):

Public real-world data (230M images): Web-crawled photographs covering natural scenes, objects, people, animals, and everyday environments, providing the model with exposure to the diversity of real-world visual content.
Public synthetic data (110M images): AI-generated or artist-created images that extend coverage to stylized, imaginary, or uncommon visual scenarios not well represented in natural photographs.
Private data (455.8M images): Proprietary images with emphasis on text-heavy visual content — posters, slides, graphic designs, and general-domain images. This source addresses a specific weakness of public datasets: limited coverage of typography, layout design, and structured visual-text compositions.
Text synthetic data (1.844M images): Programmatically generated images where text strings are rendered onto randomly sampled backgrounds with augmentations in blur, color, font, scale, and rotation. This source provides controlled diversity in typographic and layout patterns, helping the model learn text rendering across varied visual conditions.

The final distribution (Figure 3a) shows the private data dominates at roughly 57% of the total, with public real data at about 29%, public synthetic at about 14%, and text synthetic at a small fraction. The category breakdown (Figure 3a pie chart) reveals the most common visual categories: Human (19%), Object (16%), Animal (14%), Plant (10%), with Scene, Food, Event, Graphic Design, Fictional World, and Text each at 6-8%.

Nine-Stage Data Cleaning Pipeline

Before captioning, all images pass through a sequential quality filtering pipeline designed to remove low-quality, inappropriate, or redundant content:

Corrupted/broken file removal: Images that cannot be decoded or are truncated are discarded.
Resolution filtering: Images with an area smaller than 384² pixels are removed, ensuring a minimum level of visual detail.
NSFW content filtering: An EVA model fine-tuned for NSFW classification (using the Freepik/nsfw_image_detector checkpoint, Reference [12]) scores each image, and those classified as containing inappropriate content are removed.
Aesthetic filtering: The Aesthetic Predictor v2.5 model (a linear probe trained on top of CLIP ViT-L/14 features, Reference [13]) scores each image for aesthetic quality, and samples with scores below 3 (on what is likely a 1-10 scale given the LAION aesthetic predictor convention) are discarded.
Watermark filtering: A SigLIP2 model fine-tuned for watermark detection (Reference [14]) identifies and removes images containing visible watermarks, which would otherwise introduce spurious text patterns the model might learn to reproduce.
Clarity filtering: Visually blurry images are detected by computing the variance of the Laplacian operator on scale-normalized grayscale versions of each image. The Laplacian measures second-order spatial derivatives — edges and fine texture — so low variance indicates smooth, blurry regions. Images below a variance threshold are removed.
Entropy filtering: Low-information images are identified by computing the Shannon entropy of grayscale intensity histograms. Shannon entropy measures the spread of pixel intensities: an image with all pixels at the same gray level has zero entropy, while one with a uniform distribution of intensities has maximum entropy. Low-entropy images (monochromatic, nearly uniform) are removed.
Luminance filtering: Under-exposed (too dark) or over-exposed (too bright) images are detected by computing the mean V-channel value in HSV color space, normalized to [0, 1]. Images with mean V-values below or above specified thresholds are removed.
Near-duplicate removal: CLIP ViT-L/14 embeddings are computed for all remaining images, and pairs with cosine similarity exceeding 0.985 are identified as near-duplicates. FAISS indexing (References [15, 16]) accelerates the billion-scale similarity search. One image from each near-duplicate pair is kept.

After this pipeline, approximately 800M images remain, forming Lens-800M.

Dense Captioning with GPT-4.1

For each image in Lens-800M, a detailed English caption is generated using GPT-4.1 with a specific system prompt (reproduced in Appendix E.1). The prompt instructs the model to:

"Generate detailed caption for the image with 1 paragraph with less than 500 words."
"Include most salient objects with their attributes (e.g., color/texture/posture) and relationship/interaction, possibly the count number of each object type, and the background."
"If any text is present in the image (e.g., signs, labels), include the text content in its original language."
"If the image contains well known contents (e.g., landmark, celebrity, characters, popular dishes), please include such world knowledge in the caption."

The resulting captions have an average length of approximately 109 words (Figure 3c shows the caption length distribution), with a long tail extending to 200+ words. This is substantially longer than conventional web-crawled alt-text captions, which typically contain 5-15 words describing only the most prominent object or scene category.

The key design decision is that any text appearing in the image is preserved in its original language within the English caption. This means a French storefront sign remains in French in the caption, a Chinese poster retains its Chinese characters, and so on. The purpose is to preserve multilingual text rendering capabilities: the model learns the association between "there is text here" in the caption and the actual multilingual visual text in the image, enabling it to render non-English text at inference time even though all captions are structurally in English.

Ablation Study: Detailed vs. Brief Captions (Figure 4)

To isolate the effect of caption density, the authors construct Lens-130M, a 130M-image subset of Lens-800M, and train three 1.2B-parameter toy models (Lens-Toy) with identical MMDiT architectures and Qwen3-0.6B text encoders. The only difference is the captioning strategy:

Brief: GPT-4.1 generates short, sparse captions (e.g., "a photo of a cat").
Detailed: The dense captions with approximately 109 words average length.
Mixed: A 50/50 random combination of Brief and Detailed captions.

All models are trained and evaluated on the GenEval benchmark. The results (Figure 4) show a clear ordering: Detailed captions achieve the highest GenEval score at every training step from 8K to 120K iterations, Mixed captions perform intermediately, and Brief captions lag significantly. At 120K steps, the gap between Detailed and Brief is approximately 0.65 vs. 0.50 on GenEval overall score — a relative improvement of roughly 30%.

Why dense captions improve data efficiency: This result confirms the paper's information density hypothesis. With short captions, each image-text pair provides supervision for only a small subset of the visual content (the most salient object). The model spends training iterations learning to ignore the unlabeled content, effectively wasting capacity on resolving ambiguity. With dense captions, the text describes objects, attributes, spatial relationships, actions, and background context, so each training example provides stronger and more targeted supervision for a larger fraction of the image content. This aligns with the paper's framing: dense captions increase the information density per training batch, allowing the model to extract more learning value from each optimization step.

Model Architecture

VAE: Encoding Images into a Semantic Latent Space

The VAE serves as the bridge between pixel space and the compressed latent space where the diffusion transformer operates. It consists of an encoder that maps an input image $x \in \mathbb{R}^{H \times W \times 3}$ to a latent representation $z \in \mathbb{R}^{H/8 \times W/8 \times d}$ , and a decoder that reconstructs the image from the latent. The compression factor of 8 in each spatial dimension means a $1024 \times 1024$ image becomes a $128 \times 128$ latent grid, substantially reducing the computational cost of the diffusion process.

The paper evaluates four VAE variants by directly training Lens-Toy models (1.2B backbone, Qwen3-0.6B text encoder) on Lens-130M and measuring GenEval performance (Figure 5):

FLUX.1-VAE: The VAE from the original FLUX model (Black Forest Labs, 2024), a conventional VAE trained primarily with reconstruction-oriented objectives (mean squared error on pixels, KL divergence to a unit Gaussian prior, and possibly a perceptual loss or adversarial loss). This represents the "reconstruction-first" paradigm.
SD3-VAE: The VAE from Stable Diffusion 3 (Esser et al., 2024), similar in design philosophy to the FLUX.1-VAE but with a different training recipe and architecture.
VTP (Visual Tokenizer Pre-training, Yao et al., 2025): A semantic VAE that incorporates visual understanding tasks (such as image classification or contrastive learning objectives) during tokenizer training. The goal is to encourage the latent space to organize around semantic categories rather than purely pixel-level features.
FLUX.2-VAE (Black Forest Labs, 2025): A next-generation semantic VAE from the FLUX.2 model. The paper describes it as providing "a more compact and semantically meaningful visual latent space."

The results (Figure 5) show that FLUX.2-VAE achieves the highest GenEval score at every training step from 4K to 64K iterations, with VTP performing second-best, and the conventional VAEs (FLUX.1, SD3) trailing. At 64K steps, FLUX.2-VAE reaches approximately 0.65 on GenEval, compared to roughly 0.55 for VTP, 0.50 for SD3-VAE, and 0.45 for FLUX.1-VAE.

Why the FLUX.2-VAE accelerates convergence: The paper interprets this result through the lens of semantic organization. A conventional VAE trained purely for reconstruction optimizes for pixel-level fidelity: it learns to encode fine-grained textures, edges, and high-frequency details with high precision, but these features may be scattered across latent dimensions in an entangled manner. When a diffusion model tries to learn text-conditioned generation in this space, it must first disentangle the semantically meaningful dimensions from the noise-like texture dimensions, effectively "rediscovering" structure that the VAE could have provided. A semantic VAE, by contrast, is trained (either explicitly through auxiliary tasks or implicitly through architectural and objective design) to organize related visual concepts — objects of the same category, similar textures, coherent spatial layouts — into nearby regions of the latent space. This makes text-image alignment easier to learn: the diffusion model's text-conditioning signal can push latents toward semantically appropriate regions with fewer optimization steps.

A critical methodological point: the paper does not evaluate VAEs using reconstruction metrics (rFID, PSNR, SSIM) or class-conditional ImageNet generation, which are the standard proxies in VAE research. Instead, it evaluates them directly in the T2I training setting by measuring downstream GenEval performance. The justification is that:

"reconstruction fidelity mainly measures how well a VAE reproduces a given image, rather than how effectively its latent space supports generative learning."

This is a concrete example of the paper's systematic philosophy: evaluate components in the context they will actually be used, not by proxy metrics that may not correlate with downstream performance.

GPT-OSS Language Encoder: Multi-Level Text Feature Extraction

The language encoder converts text prompts into feature representations that condition the diffusion process. The paper adopts GPT-OSS (OpenAI, 2025), a 20B-parameter Mixture-of-Experts language model with 3B activated parameters and 24 transformer layers in total. At each forward pass, only 3B of the 20B parameters are active (the routing network selects which experts to use per token), making inference efficient relative to the total parameter count.

The key architectural decision is multi-layer feature extraction. Rather than using only the final layer output (which captures high-level semantic meaning but may lose fine-grained syntactic and lexical information), the paper extracts features from four specific layers:

Layer 4: Early features capturing local syntactic patterns and word-level semantics.
Layer 12: Intermediate features representing phrase-level structure and basic compositional semantics.
Layer 18: High-intermediate features encoding sentence-level meaning and attribute-object relationships.
Layer 24: Final-layer features representing global semantic content and high-level intent.

These four feature vectors are concatenated along the feature dimension, producing a representation that spans multiple levels of linguistic abstraction. A linear adapter (a learned linear projection) then maps this concatenated representation into the same dimensionality $D = 1536$ as the image latents in the MMDiT blocks. The adapter is trainable and is optimized alongside the diffusion transformer during pre-training.

Why multi-layer features matter: A single final-layer representation from a language model tends to be optimized for the model's pre-training objective (typically next-token prediction), which prioritizes semantic coherence over detailed attribute preservation. When conditioning a T2I model, the text encoder needs to convey both high-level intent ("generate a cat") and fine-grained attributes ("orange tabby, sitting on a beige sofa, with half-closed eyes"). Early and intermediate layers often retain more of this detailed lexical and syntactic information because they haven't yet been abstracted into high-level semantic summaries. By concatenating features across layers, Lens provides the diffusion model with a richer, more complete text representation, making it easier to learn precise text-image alignment.

Language Encoder Ablation Study (Figures 7 and 8)

The paper compares GPT-OSS against three Qwen3 variants (0.6B, 1.7B, 4B parameters) on both English-only and multilingual generation. All variants use the Lens-Toy architecture (1.2B MMDiT backbone) trained on Lens-130M (English-only captions).

English results (Figure 7): GPT-OSS achieves the highest GenEval score at every training step, reaching approximately 0.70 at 120K iterations. The Qwen3 variants show a clear scaling trend: 4B reaches about 0.635, 1.7B about 0.60, and 0.6B about 0.56. The gap between GPT-OSS and Qwen3-4B exists from the earliest training steps and persists throughout, suggesting that model quality (architecture, pre-training data, training objective) matters beyond just parameter count — GPT-OSS at 3B activated parameters outperforms Qwen3-4B despite having fewer active parameters.

Multilingual results (Figure 8): This is the more striking finding. Despite being trained on English-only captions, GPT-OSS enables strong GenEval performance when evaluated on prompts in five non-English languages: Chinese (ZH), French (FR), Japanese (JA), and Spanish (ES), averaged together. GPT-OSS reaches approximately 0.68 at 120K iterations, while Qwen3-4B reaches about 0.52, Qwen3-1.7B about 0.45, and Qwen3-0.6B about 0.38. The gap is substantially larger than in the English case, suggesting that the multilingual generalization capability is specifically tied to the language encoder's cross-lingual transfer ability — something GPT-OSS excels at due to its pre-training on multilingual data, even though Lens's T2I training data is English-only.

Why this matters for training efficiency: The multilingual generalization eliminates the need to collect, caption, and train on multilingual image-text pairs. In a conventional T2I training pipeline, supporting Chinese, French, Japanese, and Spanish would require either (a) collecting native-language image-caption pairs for each language, or (b) translating English captions into each language. Both approaches multiply the dataset size and training cost by the number of languages. Lens achieves multilingual support "for free" by leveraging the language encoder's pre-existing cross-lingual capabilities, substantially reducing data requirements and training costs for multilingual deployment.

MMDiT Backbone: The Diffusion Transformer

Lens uses an MMDiT-style architecture (Multi-Modal Diffusion Transformer), following the design introduced by Esser et al. in Stable Diffusion 3. The architecture consists of three stages:

Input stage — Patchification and concatenation:

The VAE encoder produces image latents of shape $(H/8, W/8, d)$ . These are divided into non-overlapping $2 \times 2$ patches, each flattened into a token. This "patchify" operation converts the spatial latent grid into a sequence of tokens suitable for transformer processing.
Text features from the GPT-OSS linear adapter (shape $(L, 1536)$ , where $L$ is the number of text tokens) are concatenated with the image patch tokens along the sequence dimension. The concatenated sequence contains both image and text tokens, which are processed jointly in the transformer.
Positional encodings using RoPE (Rotary Position Embedding) are applied to the image tokens to provide spatial position information. RoPE encodes relative position through sinusoidal rotations applied to query and key vectors in the attention computation, enabling the model to extrapolate to sequence lengths and spatial resolutions beyond those seen during training — which is critical for the resolution generalization discussed later.

Core processing — 48 MMDiT blocks:

Each MMDiT block (Figure 6, right panel) processes the concatenated image-text sequence through two separate branches:

Image branch: The image features pass through an RMSNorm normalization layer, then through a multi-head self-attention layer (24 heads, model dimension $D = 1536$ ), followed by a gated MLP (a feedforward network with a gating mechanism that controls information flow). The attention layer computes $Q, K, V$ projections from the normalized features and applies standard scaled dot-product attention.
Text branch: The text features go through an identical structure — RMSNorm, self-attention, and gated MLP — with separate parameters from the image branch. The dual-branch design allows the model to learn modality-specific transformations while the attention mechanism still enables cross-modal interaction (since image and text tokens can attend to each other in the self-attention layer).

The key design choice is that the self-attention operates over the full concatenated sequence of image and text tokens. This means each image token can attend to every other image token (spatial interactions), every text token (text-image alignment), and vice versa. The separate MLPs for image and text modalities provide modality-specific processing after the shared attention, allowing the model to maintain distinct representation spaces for the two modalities while still enabling rich cross-modal interaction.

Output stage — Unpatchification and decoding:

After the 48 MMDiT blocks, the image tokens are "unpatched" — rearranged from a sequence back into a 2D spatial grid. The VAE decoder then maps this latent grid back to pixel space, producing the output image.

RMSNorm: The paper uses RMSNorm (Root Mean Square Layer Normalization, Zhang and Sennrich, 2019) instead of standard LayerNorm. RMSNorm normalizes by the root mean square of the activations rather than by mean and variance, which is computationally simpler (no mean subtraction) and has been found to be equally or more effective in transformer architectures.

RoPE: Rotary Position Embedding (Su et al., 2024) encodes position information by applying a rotation matrix to the query and key vectors in self-attention. The rotation angle depends on the token's position, and the dot product between rotated query and key vectors depends only on the relative position between tokens. This relative-position property is what enables resolution extrapolation: the model learns to attend based on relative spatial distances (e.g., "two patches to the left") rather than absolute positions (e.g., "at coordinate (37, 42)"), so it can generalize to image sizes larger than those seen during training.

Two-Phase Pre-Training

Phase 1: Low-Resolution Pre-Training (400K iterations)

The first phase trains Lens at a fixed resolution of $512 \times 512$ pixels on 128 NVIDIA A100 80GB GPUs for 400,000 iterations. The VAE encodes each image into a latent of size $64 \times 64$ (since the VAE compresses by a factor of 8), resulting in 1024 image tokens after $2 \times 2$ patching.

Training configuration:

Objective: Standard flow-matching mean squared error (MSE) loss. The flow-matching framework (Lipman et al., 2023) defines a continuous transformation between a simple base distribution (typically Gaussian noise) and the data distribution. At training time, a random timestep $t \in [0, 1]$ is sampled, and the noisy latent is constructed as $x_t = (1 - t) \cdot x_0 + t \cdot \epsilon$ , where $x_0$ is the clean latent and $\epsilon \sim \mathcal{N}(0, I)$ is noise. The model is trained to predict the velocity $v = \epsilon - x_0$ (the direction from noise to data), and the loss is the squared error between the predicted and true velocity.
Timestep sampling: Logit-normal distribution with $\mu = 1.06$ . The logit-normal distribution samples $t$ by first sampling from a normal distribution $\mathcal{N}(\mu, \sigma^2)$ , applying the sigmoid function to map to [0,1], and using the result as the timestep. The parameter $\mu = 1.06$ biases sampling toward intermediate timesteps (approximately $t \approx 0.5$ after sigmoid), where the model needs the most training signal — early timesteps are too noisy, late timesteps are too clean.
Optimizer: AdamW with $\beta_1 = 0.9$ , $\beta_2 = 0.999$ , weight decay not explicitly stated but likely using the AdamW default. Constant learning rate of $2 \times 10^{-4}$ throughout the phase.
Batch size: Effective global batch size of 3072 images (distributed across 128 GPUs, implying a per-GPU batch size of 24 if using standard data parallelism, or adjusted if using gradient accumulation).
Gradient clipping: Maximum gradient norm of 1.0, preventing unstable updates from outlier batches.
Precision: Bfloat16 with gradient checkpointing (trading memory for computation by recomputing activations during the backward pass rather than storing them).
Frozen components: The FLUX.2 VAE and GPT-OSS language encoder are kept frozen — only the 48-block MMDiT backbone is trained.

Why 400K iterations at 512²: This phase establishes the model's basic text-image alignment and visual generation capabilities at a computationally manageable resolution. Training at higher resolutions from the start would be more expensive (quadratically in pixel count) and might destabilize early optimization when the model has not yet learned basic visual structures. The 512² phase provides a stable foundation before introducing multi-resolution complexity.

Phase 2: Mixed-Resolution Continual Training (400K iterations)

Starting from the low-resolution checkpoint (after 400K iterations), the model continues training for another 400K iterations using WebDataset bucket sampling over multiple resolutions and aspect ratios. This phase is what enables the resolution generalization capability.

Resolution bucket construction:

The authors define three base image areas — $512^2$ , $768^2$ , and $1024^2$ — and nine aspect ratios — 1:2, 9:16, 2:3, 3:4, 1:1, 4:3, 3:2, 16:9, and 2:1. Taking the Cartesian product yields 27 concrete resolution buckets, each specified as an exact $(\text{width}, \text{height})$ pair:

$512^2$ base: $352 \times 704$ , $384 \times 672$ , $416 \times 640$ , $448 \times 608$ , $512 \times 512$ , $608 \times 448$ , $640 \times 416$ , $672 \times 384$ , $704 \times 352$
$768^2$ base: $544 \times 1088$ , $576 \times 1024$ , $640 \times 960$ , $672 \times 896$ , $768 \times 768$ , $896 \times 672$ , $960 \times 640$ , $1024 \times 576$ , $1088 \times 544$
$1024^2$ base: $736 \times 1472$ , $768 \times 1376$ , $832 \times 1248$ , $864 \times 1152$ , $1024 \times 1024$ , $1152 \times 864$ , $1248 \times 832$ , $1376 \times 768$ , $1472 \times 736$

Notice that each "base" area is approximate: a $352 \times 704$ image has area 247,808 (close to $512^2 = 262,144$ ), and the resolution pairs are chosen so that the product of width and height is as close as possible to the target base area for each aspect ratio given the constraint that dimensions must be multiples of 8 (the VAE's downsampling factor).

Adaptive timestep sampling:

Since images of different resolutions produce different numbers of tokens (e.g., $352 \times 704$ yields $44 \times 88 = 3,872$ tokens before patching, while $1024 \times 1024$ yields $128 \times 128 = 16,384$ tokens), the paper adapts the logit-normal timestep sampling parameter $\mu$ based on the number of image tokens $n$ :

$\mu(n) = \mu_{\min} + \frac{n - n_{\min}}{n_{\max} - n_{\min}} \cdot (\mu_{\max} - \mu_{\min})$

where $\mu$ is the logit-normal timestep sampling parameter that controls which part of the diffusion process receives more training emphasis, $n$ is the number of image tokens for the current resolution, $\mu_{\min} = 1.0$ at $n_{\min} = 256$ tokens (smallest images), and $\mu_{\max} = 1.3$ at $n_{\max} = 4096$ tokens (largest images).

What this computes: For each image resolution, the function linearly interpolates $\mu$ between 1.0 and 1.3 based on where the token count falls in the 256–4096 range. Higher $\mu$ values shift the logit-normal distribution toward earlier timesteps (closer to 1, i.e., more noise), meaning the model spends relatively more training compute on the noisier stages of the diffusion process for higher-resolution images.

Why this form: Higher-resolution images contain more tokens and therefore provide more information per forward pass. Shifting $\mu$ upward for these images biases the training toward noisier timesteps where the denoising task is harder and the per-token learning signal is higher. For smaller images where the total signal per sample is lower, $\mu = 1.0$ (closer to uniform sampling after sigmoid) spreads the training signal more evenly across timesteps. This is a form of compute-aware curriculum learning: the model automatically allocates more capacity to high-resolution, high-information samples without requiring manual schedule design.

Per-bucket batch sizes:

To balance wall-clock time across GPU ranks (since different resolutions require different amounts of computation, and all ranks in a synchronous distributed training setup must wait for the slowest rank), the paper uses resolution-dependent batch sizes per base bucket:

$512^2$ base: batch size 24
$768^2$ base: batch size 10
$1024^2$ base: batch size 6

Smaller batch sizes for higher resolutions compensate for their increased per-sample computation, keeping per-rank wall-clock time roughly balanced so that no rank becomes a bottleneck.

Training configuration (Phase 2):

Learning rate: Constant $1 \times 10^{-4}$ (reduced from Phase 1's $2 \times 10^{-4}$ to avoid destabilizing the pre-trained checkpoint).
Optimizer, precision, gradient clipping: Same as Phase 1 (AdamW with $\beta_1=0.9, \beta_2=0.999$ , bfloat16, gradient clipping at 1.0).
Frozen components: FLUX.2 VAE and GPT-OSS remain frozen.

Mechanism of resolution generalization:

After Phase 2, the model can generate images at resolution and aspect ratio combinations never seen during training — specifically, arbitrary aspect ratios between 1:2 and 2:1, and image areas up to $1440^2$ (which is $2.0736 \times 10^6$ pixels, compared to the largest training resolution of $1472 \times 736 \approx 1.08 \times 10^6$ pixels).

The paper attributes this generalization to two factors:

RoPE's relative position encoding: Since RoPE encodes relative spatial distances rather than absolute positions, the attention patterns learned during training (e.g., "attend to patches 2-3 positions to the right") generalize naturally to larger image sizes — the model just computes the same relative-distance rotations for new absolute positions.
Multi-resolution training teaching continuous spatial representations: By exposing the model to 27 different spatial configurations during Phase 2, it learns that spatial relationships (object sizes, distances, layouts) should scale continuously with resolution and aspect ratio, rather than being memorized for specific dimensions. This is analogous to how a convolutional network trained with data augmentation learns to be invariant to translations and scales — the model learns the underlying continuous function rather than discrete bucket-specific patterns.

The training efficiency benefit is substantial: training on resolutions up to $1024^2$ is approximately $(1024^2)/(1440^2) \approx 51\%$ of the computational cost of training at $1440^2$ , yet the model can generate $1440^2$ images at inference time. This decouples training resolution from generation resolution, maintaining output quality while reducing training cost.

RL Post-Training on Lens-RL-8K

After pre-training, the base model Lens-Base can follow prompts and generate diverse images, but the outputs may contain visual artifacts (unnatural object arrangements, physically implausible scenes, inconsistent lighting). The RL post-training phase uses reinforcement learning to suppress these artifacts by directly optimizing for visual quality and prompt-alignment criteria.

Lens-RL-8K Dataset Construction

The Lens-RL-8K dataset is a prompt set of 8,406 prompts explicitly designed for RL training. The key design insight is:

"RL prompts should match the generation-scenario distribution of the pre-training data as comprehensively as possible."

This addresses a failure mode where RL training on a narrow prompt distribution causes the model to overfit to specific scenarios and degrade on others. The construction follows a taxonomy-driven pipeline with three levels of hierarchy:

Level 1 — Categories (10 coarse groups): Human, Object, Animal, Plant, Scene, Food, Event, Fictional World, Text, and UI/Graphic Design. These broadly cover the types of content in Lens-800M.

Level 2 — Sub-categories (dozens per category): For example, the Human category includes sub-categories such as Race, Occupation, Gender, Age Group, and so on. Each sub-category narrows the generation scenario.

Level 3 — Concrete items (8,406 total): Each sub-category is populated with hundreds of specific items. For example, under the Occupation sub-category, items include "Researcher", "Doctor", "Chef", "Teacher", etc. Under the Race sub-category, items include "White People", "Asian People", etc.

Description dimensions: The authors define a set of descriptive dimensions — Attribute, Spatial Relationship, Count, Interaction, and Color — that provide structured guidance for prompt diversity. For each concrete item, one to four dimensions are randomly sampled, and GPT-4.1 is prompted (using the system prompt in Appendix E.2) to generate an image-generation prompt that features that item while incorporating the selected dimensions.

Prompt generation prompt (Appendix E.2): The system prompt instructs GPT-4.1 to:

"Write exactly 5 diverse, vivid image-generation prompts that prominently feature that entity."
ALL prompts must be in "a realistic, photographic style" — explicitly excluding non-realistic styles.
Each prompt should be "30-60 words, written as a single descriptive paragraph."
"ALL required keypoints must be naturally woven into EVERY prompt."

The resulting 8,406 prompts span the full diversity of generation scenarios, with the distribution shown in Figure 3b: Human (16%), Object (14%), Animal (10%), Plant (8%), Scene (8%), Food (7%), Event (6%), Graphic Design (6%), Fictional World (6%), and Text (varies).

Rubric Generation

For each prompt $P$ in Lens-RL-8K, a set of evaluation rubrics is generated using GPT-4.1 with the system prompt in Appendix E.3. The prompt instructs GPT-4.1 to output "up to 10 rubrics in a single JSON object," where each key is a short rubric name (e.g., "Object Count Consistency") and each value is a brief explanation (e.g., "Verify that exactly one cat is shown.").

The rubric generation prompt (Appendix E.3) provides formatting requirements:

"A single JSON object (not a list)"
"Keys and values wrapped in double quotes"
"No trailing commas or comments"
"Output must be valid JSON parsable with Python's json.loads()"

These constraints are necessary because the rubrics are used programmatically in the RL pipeline — GPT-4.1-mini processes them as structured input for reward computation.

After generating sample-aware rubrics, the paper appends a global rubric to every prompt:

"Verify that the entire image is structurally coherent and physically plausible, with no missing, duplicated, disconnected, distorted, floating, merged, or incorrectly placed parts; all subjects, objects, perspective relationships, and spatial connections should appear complete, aligned, and naturally integrated into the scene."

This global rubric provides a catch-all for structural and physical plausibility issues that the sample-aware rubrics might miss — such as a person with three arms, a building floating above the ground, or objects intersecting each other unnaturally.

DiffusionNFT Optimization with VLM Reward

The RL optimization uses DiffusionNFT (Diffusion Negative-aware Fine-tuning, Zheng et al., 2025), which performs reward-based policy optimization directly within the forward diffusion process using the flow-matching objective.

Core idea: Unlike conventional policy-gradient RL methods (like GRPO) that treat the denoising trajectory as a sequential decision process and optimize via REINFORCE-style gradient estimates, DiffusionNFT uses the reward signal to construct positive and negative velocity targets in the flow-matching framework. The key insight is that the reward provides a signal about which generation directions are desirable and which should be avoided, and this signal can be directly incorporated into the flow-matching loss without needing to estimate policy gradients.

The policy optimization loss:

$\mathcal{L}(\theta) = \mathbb{E}_{c, \pi_{\text{old}}(x_0|c), t} \left[ r \cdot \|v^+_\theta(x_t, c, t) - v\|_2^2 + (1 - r) \cdot \|v^-_\theta(x_t, c, t) - v\|_2^2 \right]$

where $c$ is the text condition (prompt), $\pi_{\text{old}}(x_0|c)$ is the previous policy's distribution over clean latents given $c$ , $t \in [0,1]$ is the diffusion timestep, $v$ is the ground-truth flow-matching velocity target (the direction from noise to data), $r \in [0, 1]$ is the normalized reward interpreted as the optimality probability of the generated sample, and $v^+_\theta$ and $v^-_\theta$ are the positive and negative velocity predictions from the current policy.

What it computes: For each generated sample $x_0$ , the reward $r$ is computed by GPT-4.1-mini evaluating the generated image against the rubrics. High-reward samples ( $r \approx 1$ ) assign large weight to the positive velocity term, which penalizes deviations from the target velocity in a way that encourages the model to move toward high-reward generation directions. Low-reward samples ( $r \approx 0$ ) assign large weight to the negative velocity term, which pushes the model away from low-reward directions. The positive and negative velocities are defined as linear combinations of the old policy $v_{\text{old}}$ and the current policy $v_\theta$ :

$v^+_\theta(x_t, c, t) = (1 - \beta) \cdot v_{\text{old}}(x_t, c, t) + \beta \cdot v_\theta(x_t, c, t)$ $v^-_\theta(x_t, c, t) = (1 + \beta) \cdot v_{\text{old}}(x_t, c, t) - \beta \cdot v_\theta(x_t, c, t)$

where $\beta$ is a weighting coefficient (set to $\beta = 1$ in the paper). The positive velocity is a convex combination of old and current policies, biased toward the current policy by $\beta$ . The negative velocity is an extrapolation beyond the old policy in the opposite direction from the current policy — it represents the direction the model should actively avoid.

Why this form: The construction of $v^-_\theta$ as $(1 + \beta)v_{\text{old}} - \beta v_\theta$ is the key innovation. If $v_\theta$ has moved in a direction that produces low-reward samples, then $v^-_\theta$ points in the opposite direction, and the loss term $\|v^-_\theta - v\|_2^2$ penalizes the model for generating velocities similar to the undesirable direction. This provides a direct gradient signal to avoid bad generations, not just to imitate good ones — hence the name "Negative-aware Fine-tuning."

Reward normalization:

Raw rewards $r_{\text{raw}}(x_0, c)$ from GPT-4.1-mini (which outputs 0 or 1 per rubric, summed or averaged) can vary substantially in scale and distribution across prompts. To stabilize training, they are normalized to a probability-like signal:

$r(x_0, c) = \frac{1}{2} + \frac{1}{2} \cdot \text{clip}\left( \frac{r_{\text{raw}}(x_0, c) - \mathbb{E}_{\pi_{\text{old}}(\cdot|c)}[r_{\text{raw}}(x_0, c)]}{Z_c}, -1, 1 \right)$

where $r_{\text{raw}}$ is the GPT-4.1-mini reward, $\mathbb{E}_{\pi_{\text{old}}(\cdot|c)}[r_{\text{raw}}]$ is the expected raw reward under the old policy for the same prompt (estimated from batch statistics), and $Z_c > 0$ is a normalization factor typically set to the global standard deviation of rewards.

What this computes: For each sample, the deviation of its raw reward from the expected reward for that prompt is divided by the normalization factor, clipped to $[-1, 1]$ , and then mapped from $[-1, 1]$ to $[0, 1]$ via the linear transformation $(1 + \text{clipped}) / 2$ . The result is a normalized reward in $[0, 1]$ that describes how much better ( $r > 0.5$ ) or worse ( $r < 0.5$ ) this sample is compared to the typical quality for that prompt.

Why this form: Normalizing relative to the prompt-specific mean prevents the model from simply learning to generate images for "easy" prompts (where any reasonable image gets high raw rewards) while ignoring "hard" prompts. By centering each prompt's rewards at zero mean deviation, the optimization signal treats all prompts equally, and the sigmoid-like mapping to $[0, 1]$ converts the normalized deviations into a probability-like signal suitable for the weighted loss.

VLM Reward Computation (Appendix E.4):

The reward is computed by GPT-4.1-mini acting as a vision-language model evaluator. For each prompt-rubric pair and corresponding generated image:

The image, the original RL prompt, and the rubric are fed to GPT-4.1-mini along with the system prompt in Appendix E.4.
The system prompt instructs the model to evaluate: "You will receive a user prompt that used to generate the image and a visual quality evaluation criterion. Your job is to return 1 if the image fully satisfies the criterion, or 0 if it clearly fails."
The expected output is "1 or 0 only. Do not include explanations, just return the value."
The per-rubric scores (0 or 1 per rubric) are aggregated into a single raw reward $r_{\text{raw}}$ .

Training loop configuration:

At each optimization step:

Sampling: Randomly sample 48 prompt-rubric pairs from Lens-RL-8K, and generate 24 images at different resolutions for each prompt using the current policy model.
Evaluation: Feed each generated image with its rubrics into GPT-4.1-mini to produce rewards.
Optimization: Use DiffusionNFT with group-based optimization: 48 groups per epoch, group size of 24. The KL-divergence penalty coefficient is $\beta_{KL} = 1 \times 10^{-4}$ to prevent the policy from drifting too far from the pre-trained distribution.

Technical details:

Training duration: 180 RL steps on 64 NVIDIA A100 80GB GPUs.
Resolutions: Mixed-resolution buckets with a fixed base area of $1024^2$ across the same 9 aspect ratios used in Phase 2 pre-training.
Parameter-efficient fine-tuning: LoRA (Low-Rank Adaptation) with rank $r = 64$ and scaling factor $\alpha = 128$ . Only the LoRA adapters are trained during RL; the base model weights are frozen.
Optimizer: AdamW with $\beta_1 = 0.9$ , $\beta_2 = 0.999$ , $\epsilon = 10^{-8}$ , weight decay $1 \times 10^{-4}$ . Learning rate $3 \times 10^{-4}$ .
Adaptive coefficient: $\eta_i = \min(0.001, 0.5)$ for training stabilization.

Ablation: RL prompt set diversity (Table 1)

The paper runs two ablations to verify that prompt diversity matters:

Subset size: Training on 1/4 or 1/2 of Lens-RL-8K (random subsets) vs. the full set. GenEval scores: 1/4 full set → 0.916, 1/2 full set → 0.920, full set → 0.930. The monotonic improvement with dataset size confirms that broader prompt coverage improves generalization.
Text prompt removal: Training on Lens-RL-8K with all text-related prompts removed. On text-rendering benchmarks (CVTG and OneIG EN), removing text prompts substantially degrades performance: CVTG average drops from 0.869 to 0.832, OneIG Text score drops from 0.814 to 0.795. This confirms that text-rendering capability is specifically improved by including text-heavy prompts during RL — the improvement is not a general "better images" effect but targeted to the training distribution.

Few-Step Distillation into Lens-Turbo

After RL post-training, Lens-RL is distilled into a 4-step generator, Lens-Turbo, using a combination of distribution matching, adversarial training, and guidance distillation. The goal is to preserve the image quality and prompt-following ability of the 20-step teacher while dramatically reducing inference time.

Distillation Recipe Components

The paper combines techniques from four prior works:

DMD2 (Yin et al., 2024): Distribution Matching Distillation v2, which distills a multi-step diffusion model into a few-step generator by matching the student's output distribution to the target data distribution. The core idea is to minimize the reverse KL divergence between the student distribution and the data distribution, approximated through score-based gradients provided by the frozen teacher and a trainable "fake score" model.
Decoupled-DMD (Liu et al., 2025): Decomposes the DMD objective into a CFG-augmented term (which distills classifier-free guidance into the student) and a distribution-matching term (which performs the actual distribution alignment). This separation allows independent tuning of the guidance distillation and distribution matching strengths.
SenseFlow (Ge et al., 2025): Introduces an identity-aware (IDA) update strategy: after each student update, the fake score model is partially updated toward the student via exponential moving average: $\phi \leftarrow (1 - \mu) \phi + \mu \theta$ where $\mu = 0.03$ . This keeps the fake score model aligned with the evolving student distribution.
R1 regularization (Roth et al., 2017; adapted in Lin et al., 2025): A gradient penalty on the discriminator that penalizes sharp gradients of the discriminator output with respect to its input at real data points, improving adversarial training stability.

Distillation Dataset

A curated 100K image-caption subset is selected from Lens-800M based on aesthetic and quality metrics. The selection balances major generation scenarios: portraits, landscapes, visual content, artistic styles, and text-rich images. The captions serve as text conditions for DMD objectives, and the paired images provide real samples for discriminator training.

Teacher-Student Setup

Teacher $s_\psi$ : The frozen RL-optimized Lens-RL model, providing the ground-truth score function used in the distribution-matching gradient.
Student $G_\theta$ : A 4-step generator initialized from the Lens-RL checkpoint. It takes noise $z$ and text condition $c$ as input and produces a clean latent $x_\theta = G_\theta(z, c)$ in 4 denoising steps.
Fake score model $s_\phi$ : A score model trained on student-generated samples, providing the "fake" score estimate needed for distribution matching. It is also initialized from the Lens-RL checkpoint.
Discriminator $d_\eta$ : A classifier that distinguishes real images from student-generated images, operating on features extracted by the frozen teacher. This provides adversarial supervision.

Training Objectives

Student loss (distribution matching + adversarial):

$\mathcal{L}_\theta = \lambda_d (\mathcal{L}_{DM} + \mathcal{L}_{CA}) + \lambda_g \mathcal{L}_G$

where $\lambda_d = 0.1$ is the weight for the distribution-matching components, $\lambda_g = 0.001$ is the weight for the adversarial component, $\mathcal{L}_{DM}$ is the distribution-matching loss (matching student to data distribution), $\mathcal{L}_{CA}$ is the CFG augmentation loss (distilling classifier-free guidance), and $\mathcal{L}_G$ is the generator adversarial loss.

What the distribution-matching gradient looks like:

$\nabla_\theta \mathcal{L}_{DMD} \approx \mathbb{E}_{c,z,t,\epsilon} \left[ (s_\phi(x_t, c, t) - s_\psi(x_t, c, t)) \frac{\partial x_\theta}{\partial \theta} \right]$

where $x_t = \alpha_t x_\theta + \sigma_t \epsilon$ is a noised version of the student output, $s_\psi$ is the frozen teacher score, $s_\phi$ is the fake score model's prediction, and $\partial x_\theta / \partial \theta$ is the Jacobian of the student output with respect to its parameters.

Why two score models: The teacher score $s_\psi$ pushes the student toward the real data distribution (it knows what real images look like), while the fake score $s_\phi$ pushes the student away from its own over-concentrated distribution (preventing mode collapse). The difference $(s_\phi - s_\psi)$ points toward regions where real data exists but the student is currently under-generating.

Discriminator loss (with R1 regularization):

The discriminator compares noised real samples and noised student samples at the same diffusion time $t$ . Let $q_t(x) \sim \mathcal{N}(\alpha_t x, \sigma_t^2 I)$ be a noised real sample, where $x \sim p_D(\cdot|c)$ , and $q_t(x_\theta)$ be a noised student sample. The discriminator operates on features $h_\psi$ extracted by the frozen teacher:

$d_\eta(x_t, c, t) = D_\eta(h_\psi(x_t, c, t))$

where $D_\eta$ is a small neural network head, $h_\psi$ is the frozen teacher feature extractor, $x_t$ is the noised image, $c$ is the text condition, and $t$ is the diffusion timestep.

Discriminator objective:

$\mathcal{L}_\eta = \mathbb{E}_{x,c,t} [\ell(d_\eta(q_t(x), c, t))] + \mathbb{E}_{z,c,t} [\ell(-d_\eta(q_t(x_\theta), c, t))] + \frac{\gamma}{2} \mathbb{E}_{x,c,t,\epsilon} \left[ \|d_\eta(q_t(x), c, t) - d_\eta(\bar{x}_t, c, t)\|_2^2 \right]$

where $\ell(r) = \log(1 + \exp(-r))$ is the logistic loss, $\gamma = 1.0$ is the R1 penalty weight, $\bar{x}_t = q_t(x) + \alpha \epsilon$ is a small perturbation of the noised real sample for approximating the R1 gradient penalty, and $\alpha = 0.1$ is the perturbation magnitude.

What it computes: The first two terms are the standard GAN discriminator loss: the discriminator should assign high logits to real noised samples and low logits to fake noised samples. The third term is the R1 gradient penalty: it penalizes the squared L2 norm of the discriminator's gradient with respect to its input at real data points. The penalty is approximated by comparing the discriminator's output on a clean real sample $q_t(x)$ and a slightly perturbed version $\bar{x}_t$ .

Why this form: The R1 penalty smooths the discriminator's decision boundary around the real data manifold, preventing it from forming sharp gradients that would destabilize adversarial training. The logistic loss $\log(1 + \exp(-r))$ is a smooth approximation to the hinge loss commonly used in GANs, providing better gradient flow when the discriminator is very confident.

Generator adversarial loss:

$\mathcal{L}_G = \mathbb{E}_{z,c,t} [\ell(d_\eta(q_t(x_\theta), c, t))]$

The generator tries to maximize the discriminator's output on fake samples — making them appear real.

Fake score model loss:

$\mathcal{L}_\phi = \mathbb{E}_{c,z,t} \left[ \|v_\phi(q_t(x_\theta), c, t) - u_t\|_2^2 \right]$

where $x_\theta = G_\theta(z, c)$ is the student output, $v_\phi$ is the fake score model's velocity prediction, and $u_t$ is the flow-matching target velocity associated with the same forward-noised sample.

What it computes: The fake score model is trained with a standard flow-matching objective on student-generated samples — it learns to predict the velocity field that would transform noise into the student's output distribution. This keeps the fake score model accurate for the evolving student distribution.

Training dynamics:

Following DMD2's TTUR-style update strategy (Two Time-Scale Update Rule), each global training step consists of:

4 updates to the fake score model and discriminator.
1 update to the student.

This imbalance gives the auxiliary models more updates per student update, allowing them to stay accurate as the student distribution shifts.

After each student update, the IDA (Identity-Aware) strategy from SenseFlow is applied:

$\phi \leftarrow (1 - \mu) \cdot \phi + \mu \cdot \theta$

with $\mu = 0.03$ . This smoothly interpolates the fake score model toward the student parameters, ensuring the fake score tracks the student without full retraining at each step.

Training configuration:

Hardware: 8 NVIDIA A100 80GB GPUs with per-GPU batch size 4.
Optimizer: AdamW with learning rate $5 \times 10^{-7}$ for student and fake score model, $1 \times 10^{-4}$ for discriminator. Adam betas: $\beta_1 = 0.0$ , $\beta_2 = 0.9$ (unusual: $\beta_1 = 0.0$ means no momentum, relying purely on the adaptive learning rate).
Guidance scale: 5.0 for $\mathcal{L}_{CA}$ during distillation (distilling CFG into the 4-step student so it can generate without CFG at inference).
Duration: Up to 1,000 global steps.

Why distillation matters for efficiency: The 20-step Lens model generates a 1024² image in 3.15 seconds on a single H100. Lens-Turbo generates the same in 0.84 seconds — a 3.75× speedup — while largely preserving quality. This makes real-time or high-throughput generation feasible without sacrificing the training efficiency gains.

Inference-Time Components

Reasoner: Prompt Refinement for Distribution Alignment

The Reasoner is an independent language model (defaulting to GPT-5.5) placed before the T2I pipeline. It takes the user's raw input and converts it into a detailed, well-formed prompt that better aligns with the training caption distribution of Lens-800M.

Why a reasoner is necessary: During pre-training, the model sees densely captioned images with approximately 109-word descriptions covering objects, attributes, spatial relationships, and background context (Section 2.1). However, users at inference time frequently provide short, underspecified, or ambiguous prompts — e.g., "a cat" rather than "a gray tabby cat sitting on a beige fabric sofa near a sunlit window with soft morning light." This creates a distribution mismatch: the model was trained to condition on detailed descriptions but is asked to generate from sparse ones. The reasoner bridges this gap by expanding user inputs into the distribution the model expects.

Design choices: The reasoner is architecturally independent of the T2I model — it does not share parameters with the GPT-OSS language encoder inside Lens. This independence allows it to be swapped out freely: the paper demonstrates using GPT-5.5, GPT-OSS-20B, and Qwen3 variants (0.6B, 1.7B, 4B) as reasoners without retraining the generation backbone.

A key efficiency point: since GPT-OSS already serves as Lens's language encoder, using it as the reasoner "adds zero extra GPU memory cost." The same model processes the reasoner task and the text encoding task, though presumably through separate forward passes (first rewriting the prompt, then encoding the rewritten prompt).

Benchmark-specific reasoner prompts (Appendices E.6, E.7, E.8):

The paper provides detailed system prompts for the reasoner tailored to each evaluation benchmark. These prompts encode benchmark-specific knowledge about what makes images easy to evaluate under each benchmark's metrics.

For GenEval (Appendix E.6), the system prompt instructs the reasoner to optimize for object detection, instance segmentation, color classification, and bounding-box spatial relations. It specifies detailed rules for different prompt types:

single_object prompts: "Show exactly one instance of the required class as the dominant subject. Use a simple setting that supports recognition."
two_object prompts: "Show exactly one instance of each required class. Separate them enough that an object detector can identify two distinct boxes."
counting prompts: "Show exactly the requested number of instances... Arrange them as separate, fully visible items in a simple row or grid."
colors prompts: "Make the object's main visible surface uniformly and unmistakably the required color. Use neutral lighting and a neutral background."
position prompts: "Use a flat, front-facing composition with strong horizontal or vertical separation between object centers."

These rules are designed to produce images that GenEval's automated detectors and classifiers can evaluate correctly — essentially optimizing the prompts for the evaluation protocol rather than for general visual quality.

For OneIG (Appendix E.7), the system prompt spans 10 detailed rules covering anime/tag-style prompts, realistic portraits, objects and products, visible text, charts and diagrams, and knowledge-reasoning requests. The prompt is more general than GenEval's because OneIG evaluates diverse generation scenarios.

For LongText and CVTG (Appendix E.8), the prompt focuses on maximizing text rendering accuracy with rules about text placement, typography, contrast, and layout for different text-bearing formats (signs, labels, printed materials, webpages, slides, posters, captions, dialogue).

Training-Free System Prompt Search (Section 2.5)

This technique optimizes the reasoner's system prompt without any model training. The procedure is iterative:

Start with an initial system prompt (the default prompt in Appendix E.5 for general inference, or the benchmark-specific prompts in E.6-E.8 for evaluation).
Run the reasoner + T2I model on a set of prompts and identify failure cases — images that exhibit artifacts, miss prompt requirements, or otherwise underperform.
Generate a textual summary of the failure cases (e.g., "the model often fails to render exactly three apples when the prompt says 'three apples'").
Feed the previous system prompt and the failure analysis to GPT-5.5, asking it to rewrite the system prompt to address the identified failures.
Repeat from step 2 with the updated system prompt.

The key property is that this search requires no gradient computation, no model fine-tuning, and no labeled training data — only the ability to identify failure cases (which can be done through inspection or automated metrics) and the GPT-5.5 API for prompt rewriting. The resulting system prompt is a text artifact that can be stored and reused.

The paper demonstrates that this technique generalizes beyond Lens: applying the same optimized system prompt to Qwen-Image (20B) with a GPT-5.5 reasoner improves its performance, as shown in Table 6. This confirms that the system prompt optimization is model-agnostic — it improves the quality of the prompts going into any T2I model, not just Lens.

Inference Configuration

The default inference pipeline produces images in 20 denoising steps with classifier-free guidance (CFG) set to 5.0. CFG works by running the diffusion model twice per step — once with the text condition and once without (or with a null condition) — and extrapolating the conditioned prediction away from the unconditioned prediction:

$\epsilon_{\text{guided}} = \epsilon_{\text{uncond}} + s \cdot (\epsilon_{\text{cond}} - \epsilon_{\text{uncond}})$

where $s = 5.0$ is the guidance scale. Higher guidance scales increase prompt adherence at the cost of reduced diversity and potential artifacts.

For Lens-Turbo, inference uses 4 steps without CFG — the guidance has been distilled into the model during training, so the student generates directly at the target guidance level without needing the two-pass CFG computation at inference time.

4. Key Insights and Innovations

Innovation 1: Reframing T2I Training Efficiency as a Three-Factor Joint Optimization Problem

The field's dominant assumption has been that better T2I models require more parameters, trained on more data, with more compute — a scaling-law mindset imported from language modeling where model size is the primary lever. The paper's most fundamental conceptual move is to reject this single-variable framing and instead decompose training efficiency into three independent factors: model size (per-step cost), data information density (learning per step), and convergence speed (number of steps needed). This is not obvious taxonomy work — it is a diagnostic reframing that identifies where prior models leave efficiency on the table.

Prior work implicitly treated data quality and architectural convergence as secondary concerns, optimizing them only to the point where they didn't obviously hurt performance. The dominant practice — web-crawled alt-text captions, VAEs evaluated by reconstruction metrics (rFID, PSNR), language encoders chosen by convenience (CLIP, T5 at whatever scale was available) — reflects a field that was optimizing for maximum performance at any cost rather than Pareto-optimal performance-efficiency. The paper's three-factor decomposition makes visible what was previously invisible: that these "secondary" choices are actually first-order determinants of total training cost when jointly optimized.

What makes this distinctive at the idea level is that it converts efficiency from a constraint ("we can only afford X GPU hours, so let's cut corners") into a design objective ("we want to maximize generation quality per FLOP, so let's optimize all three factors simultaneously"). The paper's subtitle — "Rethinking Training Efficiency" — signals this shift. Efficiency isn't achieved by doing less of something; it's achieved by extracting more from each component of the training pipeline.

The evidence for this reframing's power is the $4.8\times$ training compute reduction vs. Z-Image (192K vs. 314K normalized GPU hours) while matching or exceeding benchmark scores (Table 2). But the intellectual contribution isn't the cost reduction — it's the demonstration that model size, data information density, and convergence speed are separable optimization targets that can be independently improved and whose benefits multiply when combined. This is an architectural insight about the structure of the T2I training problem, not a recipe for a specific model.

Innovation 2: Data Information Density as a Trainable Parameter, Not a Fixed Dataset Property

The paper introduces a concept that was absent from the T2I training discourse: data information density per training batch as a variable to be optimized, not a property of whatever dataset happens to be available. This is a double-sided innovation — it applies to both the text side (caption quality) and the image side (resolution and aspect ratio diversity) of each training example.

On the text side, the dominant prior practice was to accept web-crawled alt-text as given, perhaps with mild filtering or deduplication. The paper identifies this as a training signal bottleneck: short, underspecified captions force the model to spend optimization steps resolving labeling ambiguity rather than learning fine-grained visual-semantic correspondences. The controlled ablation in Figure 4 makes this concrete — dense captions improve GenEval by roughly 30% relative at equivalent training steps — but the conceptual point is deeper. It reframes caption generation as an upstream investment that pays dividends throughout training: one-time GPT-4.1 inference cost replaces ongoing training inefficiency. The 109-word average caption length isn't an arbitrary target; it's the outcome of asking what level of text supervision would make each image-text pair maximally informative for the diffusion model.

On the image side, the mixed-resolution and multi-aspect-ratio batch construction (27 concrete resolution buckets spanning 512² to 1024² across nine aspect ratios) introduces a spatial analog of the same concept. Prior work typically trained at one or two resolutions, meaning each image contributed visual information at a single spatial scale. Lens's approach makes each batch contain images at multiple resolutions, so the model learns multi-scale visual representations in every optimization step. This isn't just a data augmentation trick — it's a training efficiency strategy that increases the visual information extracted per batch.

The resolution generalization result (models trained up to 1024² can generate at 1440² without seeing those resolutions) demonstrates that this spatial information density has an emergent benefit: the model learns continuous spatial representations rather than memorizing bucket-specific patterns. This is evidence that the information density concept doesn't just improve training efficiency — it produces qualitatively different learned representations that generalize better. The paper doesn't claim this as a theoretical discovery, but the empirical demonstration that explicit multi-resolution exposure yields implicit resolution generalization is a finding with implications beyond Lens.

Innovation 3: Gradient-Free, Emergent Multilingual Generation from English-Only Training

The paper makes a striking empirical finding that has received little systematic attention in the T2I literature: a strong enough language encoder, even when kept frozen and trained only on English image-caption pairs, enables a T2I model to accept non-English prompts at inference time with substantial accuracy. Figure 8 shows GPT-OSS achieving approximately 0.68 GenEval on multilingual prompts vs. approximately 0.38 for the weakest encoder (Qwen3-0.6B), despite neither encoder receiving non-English T2I training data.

What makes this an innovation rather than a curiosity is what it implies about the division of labor between the language encoder and the diffusion backbone in T2I systems. The dominant mental model in the field has been that the language encoder provides a semantic embedding space, and the diffusion model learns to map text embeddings to images via the cross-attention or joint-attention mechanism. Multilingual support, under this model, would require either (a) multilingual image-caption training data, or (b) a translation layer between the user's language and English. The paper's results suggest a different mechanism: a sufficiently powerful encoder maps semantically equivalent prompts in different languages to sufficiently similar regions of the embedding space that the diffusion model's English-trained mapping generalizes. The encoder is doing the cross-lingual alignment; the diffusion backbone doesn't need to learn it.

This has practical significance beyond the immediate cost savings (no multilingual data collection needed): it suggests that investment in the language encoder is a form of capability leverage. A better encoder doesn't just improve English performance (Figure 7) — it unlocks entirely new capabilities (multilingual generation) that weren't explicitly trained for. This is a different relationship between encoder quality and model capability than the standard "better features → faster convergence" story. It's closer to an emergent capability that arises from scale and quality in the encoder, not from explicit supervision in the T2I training.

The finding also connects to ongoing debates about whether cross-lingual transfer in vision-language models requires multimodal multilingual data or can emerge from unimodal language model pre-training. The paper provides evidence for the latter view, at least for T2I generation, in a controlled setting. The fact that this was discovered through systematic ablation of encoder variants (Figures 7, 8) rather than through theoretical prediction makes it a genuine empirical discovery, not an engineered capability.

Innovation 4: Prompt Set Diversity as the Critical Factor in RL Post-Training Generalization

RL-based post-training for T2I models has focused overwhelmingly on reward design and optimization algorithms — GRPO, DPO, DiffusionNFT, and their variants all tackle how to optimize, not what to optimize on. The paper makes a diagnostic move that shifts attention to a previously neglected variable: the diversity and coverage of the RL prompt set determines whether post-training improves or degrades generation across the full distribution.

The key evidence is in Table 1: training on progressively larger subsets of Lens-RL-8K (1/4 → 1/2 → full) yields monotonically improving GenEval scores (0.916 → 0.920 → 0.930), and removing text-related prompts from the RL set degrades text-rendering benchmarks specifically (CVTG drops from 0.869 to 0.832, OneIG Text from 0.814 to 0.795). These are not small effects — the text prompt removal alone causes a 4.3% drop in CVTG average, showing that the benefits of RL post-training are scenario-specific and transfer poorly across prompt types.

What makes this conceptual rather than just an engineering finding is the taxonomy-driven construction methodology for Lens-RL-8K. Rather than collecting prompts haphazardly or relying on whatever benchmarks happen to exist, the paper constructs a three-level hierarchy (10 categories → dozens of sub-categories → 8,406 concrete items) designed to cover the generation-scenario distribution as comprehensively as possible. This is a principled response to the overfitting risk: if the RL prompt set is narrow, the policy will learn to generate high-reward images for those specific scenarios at the expense of others. By matching the RL prompt distribution to the pre-training data distribution, the policy improvement generalizes.

The innovation here is not the specific taxonomy (which is domain-specific) but the framing of RL prompt sets as a distribution-matching problem. Prior work treated prompt selection as a data collection task — get some prompts, generate some images, compute rewards. The paper reframes it as a coverage problem: the RL prompt set must be a representative sample of the inference-time prompt distribution, or post-training will distort the model. This connects to the broader challenge of reward hacking in RL: when the RL objective is narrow, optimization finds degenerate solutions that score well under the reward function but fail on the broader distribution. The paper's solution is not to fix the reward function (though rubric-based rewards help) but to fix the prompt distribution to be broad enough that optimizing for it produces genuine improvement.

This insight is transferable: any T2I model using RL post-training should construct its prompt set with taxonomy-driven coverage rather than ad-hoc collection, or risk silent degradation on under-represented scenarios. The paper demonstrates that this matters empirically, not just theoretically, which makes it a practical contribution to RL-for-T2I methodology.

5. Experimental Analysis

Evaluation Methodology

Dataset. The paper evaluates Lens on four standard text-to-image benchmarks. OneIG (EN) [6] is the English split of OneIG-Bench, comprising 1,120 prompts across general objects, portraits, anime/stylization, text rendering, and knowledge/reasoning. It produces dimension-specific scores for subject alignment, text accuracy, reasoning, style, diversity, and overall performance. GenEval [7] contains 553 prompts spanning six templated tasks — single-object generation, two-object co-occurrence, counting, color, spatial relation, and attribute binding — and uses detector- and classifier-based verification to assess whether generated images satisfy structured constraints. LongText (EN) [31] contains 160 English prompts across eight text-rich scenarios (signboards, labeled objects, printed materials, webpages, slides, posters, captions, dialogues) with text lengths ranging from approximately 10-30 words to 30-50 words, stressing faithful rendering beyond isolated words or phrases. CVTG [32] evaluates complex visual text generation with multiple text regions, where prompts vary the number of regions from 2 to 5 and specify text content, position, length, and style attributes such as color, font, and size. The paper reports overall scores for OneIG, GenEval, and LongText (EN), and reports average score, normalized edit distance (NED), and CLIP score for CVTG.
Base model(s). The primary model is Lens (3.8B parameters), with its distilled variant Lens-Turbo (3.8B, 4-step generation). The pre-training and post-training pipeline produces Lens-Base (after pre-training), Lens-RL (after RL post-training), and Lens-Turbo (after distillation). All variants share the same MMDiT backbone (48 blocks, model dimension D=1536, 24 attention heads), FLUX.2-VAE encoder/decoder, and GPT-OSS language encoder (20B-MoE, 3B activated parameters). The paper compares against a comprehensive set of state-of-the-art models ranging from 6B to 80B parameters: Z-Image (6B) [1] and its turbo variant, LongCat-Image (6B) [2], FLUX.1 [Dev] (12B) [8], FLUX.2-Klein (9B) [3], SD3.5 Large (8B) [35], Qwen-Image (20B) [4], Hunyuan-Image-3.0 (MoE, 80B) [5], Janus-Pro (7B) [43], BAGEL (14B) [45], HiDream-I1-Full (17B) [38], and several commercial models including Kolors 2.0, Seedream 3.0/4.0, GPT Image 1 [High], and Nano Banana 2.0. The paper chose this comparison set to span the range from compact open-source models to the largest commercial systems, establishing that Lens occupies a favorable position in the performance-efficiency Pareto frontier.
Metrics. OneIG (EN) reports an overall score aggregating dimension-specific scores across subject alignment, text accuracy, reasoning, style, and diversity. The paper reports only the overall score in the main comparison table (Table 2), with dimension-level breakdowns provided in Appendix B.1 (Table 3). GenEval reports an overall score computed as the average across six sub-tasks (single object, two objects, counting, colors, position, color-attribute binding), with sub-task scores in Table 4. LongText (EN) reports a single overall score. CVTG reports three metrics: an average score across prompts with 2, 3, 4, and 5 text regions (denoted as 2R, 3R, 4R, 5R, then averaged), normalized edit distance (NED) measuring character-level accuracy of rendered text against ground truth, and CLIP score measuring image-text alignment. For inference speed comparisons (Figure 2), the paper uses wall-clock inference time on a single NVIDIA H100 GPU. For training compute comparisons, the paper uses GPU hours normalized by peak BF16 TFLOPS: Lens uses 192K A100 GPU hours at 312 TFLOPS (BF16), while Z-Image uses 314K H800 GPU hours at 989.5 TFLOPS (BF16). The paper explicitly notes that "actual efficiency may differ due to memory bandwidth, MFU, and communication overhead" and that "re-captioning costs are excluded, as this one-time preprocessing can be reused for future models."
Baselines. The paper compares against 20 total baselines spanning commercial and open-source models (listed above). For benchmark-specific comparisons: on OneIG (Table 3), all 16 models with available scores are compared; on GenEval (Table 4), 15 models; on LongText (Table 5), approximately 10 models; on CVTG (Table 5), approximately 11 models. The paper reports both 20-step (Lens) and 4-step (Lens-Turbo) variants to enable fair comparisons with both standard and turbo/distilled models. For the reasoner ablation (Table 6), baselines include Lens without any reasoner, Lens with various reasoner backends (GPT-5.5, GPT-OSS-20B, Qwen3 at 0.6B/1.7B/4B), and Qwen-Image with GPT-5.5 reasoner as a cross-model comparison.
Generation budget / compute accounting. For benchmark comparisons, the paper does not control for inference compute — each model is evaluated using its default inference configuration (varying numbers of denoising steps, guidance scales, etc.). For efficiency comparisons (Figure 2), the x-axis is inference time on a single H100 GPU, encompassing the full generation pipeline for each model. For training compute comparisons, the paper normalizes GPU hours by peak BF16 TFLOPS: Lens consumes 192K A100 GPU hours × 312 TFLOPS = approximately 59.9 exaFLOPs, while Z-Image consumes 314K H800 GPU hours × 989.5 TFLOPS = approximately 310.7 exaFLOPs, yielding approximately 19.3% relative compute (Table 2, footnote). The paper explicitly excludes one-time costs (re-captioning with GPT-4.1, RL reward computation with GPT-4.1-mini) from the training compute accounting.
Cross-validation / statistical protocol. The paper does not report cross-validation, statistical significance testing, or confidence intervals for any benchmark results. The difficulty estimation and strategy selection protocol (two-fold cross-validation per difficulty bin) described in the example paper is not part of the Lens paper. The paper reports single-run benchmark scores without error bars, which is standard practice in the T2I evaluation literature but limits the ability to assess whether reported differences (e.g., Lens at 0.557 vs. Qwen-Image at 0.539 on OneIG overall) are statistically reliable. For the ablation studies in Figures 4, 5, 7, and 8, the training curves show per-iteration GenEval scores without variance estimates, suggesting either single training runs or unreported averaging. The RL ablation in Table 1 compares single configurations without error bars.

Main Quantitative Results

Benchmark Performance Against State-of-the-Art Models (Table 2)

The central quantitative claim of the paper is established in Table 2: Lens (3.8B, 20-step) and Lens-Turbo (3.8B, 4-step) achieve performance competitive with or surpassing state-of-the-art models with 6B+ parameters across four benchmarks while using substantially less training compute.

OneIG (EN) overall score: Lens achieves 0.557, which is the highest among all open-source models and second only to the commercial Nano Banana 2.0 (0.578) among all models. This places Lens above Qwen-Image (20B, 0.539), Z-Image (6B, 0.546), FLUX.2-Klein (9B, 0.532), and the commercial Seedream 4.0 (0.573). Lens-Turbo achieves 0.554, which is also above all open-source models except the full Lens. The dimension-level breakdown (Table 3) reveals that Lens leads in Alignment (0.891 vs. Qwen-Image's 0.882, Seedream 4.0's 0.892), Text accuracy (0.960 vs. Z-Image's 0.987 — Z-Image has the edge here), Reasoning (0.343 vs. Qwen-Image's 0.306), and Style (0.404 vs. Qwen-Image's 0.418). Lens's performance profile shows particular strength in Alignment and Reasoning, while its Diversity score (0.186) is mid-range among open-source models (Z-Image: 0.194, Qwen-Image: 0.197, HiDream-I1-Full: 0.186).

GenEval overall score: Lens achieves 0.930, which is the highest among all models — both commercial and open-source. The 20-step Lens surpasses LongCat-Image (6B, 0.870), Qwen-Image (20B, 0.868), FLUX.2-Klein (9B, 0.848), Seedream 4.0 (0.840), and Z-Image (6B, 0.840). Lens-Turbo achieves 0.914, still above all non-Lens models. The sub-task breakdown (Table 4) shows Lens leading or near-leading in most categories: Two-object co-occurrence (0.970, second to Seedream 3.0's 0.960 and HiDream-I1-Full's 0.980), Counting (0.909, highest among all models), Color (0.923, second to Z-Image's 0.930), Position (0.915, substantially above Qwen-Image's 0.760 and FLUX.2-Klein's 0.718), and Attribute binding (0.868, highest among all models). The Position score is particularly notable — it is nearly 0.15 absolute points above the next-best open-source model — suggesting that Lens's resolution/aspect-ratio generalization training produces particularly strong spatial reasoning capabilities.

LongText (EN): Lens achieves 0.937, which is the highest among all models except the commercial Nano Banana 2.0 (0.981). This places Lens above Qwen-Image (20B, 0.943 — note: this is slightly higher than Lens's 0.937, so Lens is actually second among open-source models), Z-Image (6B, 0.935), and FLUX.2-Klein (9B, 0.864). Lens-Turbo achieves 0.927, which is above Z-Image-Turbo (0.917) and Seedream 3.0 (0.896).

CVTG: The paper reports three metrics. Average score: Lens achieves 0.869 across 2-5 text regions, while Z-Image achieves 0.867, LongCat-Image 0.866, Qwen-Image 0.829, and Hunyuan-Image-3.0 (80B) 0.765. Lens's per-region scores (Table 5) show 2R: 0.897, 3R: 0.881, 4R: 0.872, 5R: 0.827, which are competitive with Z-Image (2R: 0.901, 3R: 0.872, 4R: 0.865, 5R: 0.851). Normalized edit distance (NED): Lens achieves 0.951, second only to Lens-Turbo's 0.965 among all models (commercial and open-source). This suggests Lens-Turbo's distillation process may have improved text rendering accuracy slightly — a counterintuitive finding given that distillation typically trades quality for speed. CLIP score: Lens achieves 0.814, which is above most open-source models (Z-Image: 0.797, Qwen-Image: 0.806) but below the commercial GPT Image 1 (0.798 — actually Lens is higher) and Hunyuan-Image-3.0 (0.812).

Inference time analysis (Figure 2): The two scatter plots position Lens and Lens-Turbo in the performance-efficiency space. On OneIG (Figure 2a), Lens occupies the upper-left region: score approximately 0.56 at approximately 3.15 seconds, while Z-Image achieves approximately 0.55 at roughly 8 seconds, Qwen-Image approximately 0.54 at roughly 4 seconds, and FLUX.2-Klein approximately 0.53 at roughly 2 seconds. On GenEval (Figure 2b), Lens's advantage is starker: score approximately 0.93 at approximately 3.15 seconds, while Qwen-Image achieves approximately 0.87 at roughly 4 seconds, LongCat-Image approximately 0.87 at roughly 6 seconds, and Z-Image approximately 0.84 at roughly 8 seconds. The marker area (proportional to model size) visually emphasizes that Lens achieves its position with the smallest model in the comparison set. Lens-Turbo appears at the extreme upper-left: approximately 0.91 GenEval at 0.84 seconds, demonstrating the distillation speedup with minimal quality degradation.

Training compute comparison: The paper claims Lens requires "only about 19.3% of the training compute used by Z-Image." This figure is based on the GPU hour normalization: 192K A100 hours × 312 TFLOPS = 59.9 exaFLOPs for Lens vs. 314K H800 hours × 989.5 TFLOPS = 310.7 exaFLOPs for Z-Image. The 19.3% ratio (59.9/310.7) makes Lens's training cost approximately 5.2× lower than Z-Image's. Importantly, this comparison normalizes for GPU model differences (A100 vs. H800) using peak BF16 TFLOPS, which the paper acknowledges may not perfectly reflect actual training throughput due to memory bandwidth, model FLOPs utilization (MFU), and communication overhead.

Ablation Studies During Architecture Development

The paper conducts a series of controlled ablation studies during the development of Lens, using smaller-scale Lens-Toy models (1.2B MMDiT backbone, Qwen3-0.6B text encoder) trained on Lens-130M (130M images) to isolate specific design choices.

Caption length ablation (Figure 4): Three Lens-Toy variants are trained with Brief, Detailed, and Mixed (50/50) captions on Lens-130M and evaluated on GenEval at training steps from 8K to 120K. The Detailed variant achieves approximately 0.65 at 120K steps, the Mixed variant approximately 0.57, and the Brief variant approximately 0.50. The gap emerges early (by 16K steps, the ordering is already established) and widens throughout training. The relative improvement of Detailed over Brief is approximately 30% at 120K steps. This ablation provides the empirical foundation for the paper's central claim about data information density: dense captions improve learning efficiency per training step, not just final performance.

VAE variant ablation (Figure 5): Four VAE variants are compared by training Lens-Toy models on Lens-130M and evaluating GenEval from 4K to 64K steps. FLUX.2-VAE achieves the highest score at every step, reaching approximately 0.65 at 64K steps. VTP reaches approximately 0.55, SD3-VAE approximately 0.50, and FLUX.1-VAE approximately 0.45. The gap between FLUX.2-VAE and the next-best variant (VTP) is approximately 0.10 GenEval at 64K steps — a substantial margin. The paper interprets this as evidence that semantic VAEs accelerate convergence by providing a more learnable latent space, though the ablation does not directly test the mechanism (e.g., by measuring latent space properties like linear separability or mutual information with semantic labels).

Language encoder ablation for English (Figure 7): Four language encoders (GPT-OSS-20B, Qwen3-0.6B, Qwen3-1.7B, Qwen3-4B) are compared in Lens-Toy models trained on Lens-130M (English-only captions) and evaluated on GenEval from 8K to 120K steps. GPT-OSS dominates throughout, reaching approximately 0.70 at 120K steps, compared to Qwen3-4B at approximately 0.635, Qwen3-1.7B at approximately 0.60, and Qwen3-0.6B at approximately 0.56. The Qwen3 variants show a clear scaling trend (larger encoder → better performance), but GPT-OSS outperforms Qwen3-4B despite having 3B activated parameters vs. 4B, suggesting that architectural quality and pre-training matter beyond raw parameter count. The gap between GPT-OSS and Qwen3-4B is approximately 0.065 GenEval at 120K steps.

Language encoder ablation for multilingual generation (Figure 8): The same four encoders are evaluated on multilingual prompts (averaged across Chinese, French, Japanese, and Spanish) on GenEval from 8K to 120K steps. The performance ordering is preserved but gaps are magnified: GPT-OSS achieves approximately 0.68 at 120K steps, Qwen3-4B approximately 0.52, Qwen3-1.7B approximately 0.45, and Qwen3-0.6B approximately 0.38. The gap between GPT-OSS and Qwen3-4B widens to approximately 0.16 GenEval (vs. 0.065 for English-only), confirming that the multilingual generalization benefit is specifically tied to the encoder's cross-lingual capability and not simply a consequence of better English representations. This is a critical finding for the paper's efficiency thesis: the multilingual capability emerges "for free" from the choice of encoder, without requiring multilingual training data.

RL Post-Training Ablation Results (Table 1)

RL prompt set size ablation (Table 1, left): Three Lens-RL variants are trained on different fractions of Lens-RL-8K (all initialized from the same Lens-Base checkpoint and trained for 180 RL steps) and evaluated on GenEval. The full set achieves 0.930, 1/2 set achieves 0.920, and 1/4 set achieves 0.916. The monotonic improvement with dataset size (0.916 → 0.920 → 0.930) supports the paper's claim that broader prompt coverage improves RL generalization, though the marginal gain diminishes (0.004 from 1/4 to 1/2, vs. 0.010 from 1/2 to full).

Text prompt removal ablation (Table 1, right): Removing all text-related prompts from Lens-RL-8K and training the RL model on the remaining prompts degrades text-rendering benchmarks specifically. On CVTG, the average score drops from 0.869 (full set) to 0.832 (without text), NED drops from 0.951 to 0.928, and CLIP score drops slightly from 0.814 to 0.795. On OneIG (EN), the Text dimension score drops from 0.814 to 0.795, while the overall score drops from 0.946 to 0.960 (this appears to be inverted — the paper reports "Full set w/o text" having 0.928 NED and 0.795 CLIP on CVTG, and 0.946 overall on OneIG, while "Full set" has 0.951 NED, 0.814 CLIP, and 0.960 overall). This ablation demonstrates that the benefits of RL post-training are scenario-specific: removing text prompts degrades text rendering while minimally affecting general image quality (which dominates the GenEval score and likely the overall OneIG score), supporting the paper's claim that the RL prompt set must cover the full generation scenario distribution to avoid overfitting.

Reasoner Ablation Results (Table 6)

The paper evaluates Lens with five reasoner configurations on four benchmarks. Without a reasoner, Lens achieves 0.532 on OneIG, 0.843 on GenEval, 0.893 on LongText, 0.849 on CVTG average, 0.933 on CVTG NED, and 0.796 on CVTG CLIP. Adding GPT-5.5 as the reasoner improves all metrics: OneIG to 0.557 (+0.025), GenEval to 0.930 (+0.087), LongText to 0.937 (+0.044), CVTG average to 0.869 (+0.020), NED to 0.951 (+0.018), CLIP to 0.814 (+0.018). Adding the open-source GPT-OSS-20B as reasoner achieves comparable or slightly better results on some metrics: OneIG 0.559, GenEval 0.874, LongText 0.924, CVTG average 0.888, NED 0.958, CLIP 0.821. The smaller Qwen3 variants (0.6B, 1.7B, 4B) as reasoners achieve progressively better results with scale, but all underperform GPT-OSS-20B and GPT-5.5.

A cross-model comparison is provided: Qwen-Image (20B) with GPT-5.5 reasoner using Lens's optimized system prompt achieves OneIG 0.567, GenEval 0.926, LongText 0.962, CVTG average 0.891, NED 0.947, CLIP 0.787. This demonstrates that the training-free system prompt search strategy generalizes — the same system prompt that works for Lens also improves Qwen-Image's performance, confirming that the optimization is on the prompt quality rather than on Lens-specific characteristics.

Ablation Studies and Robustness Checks

Caption length (Detailed vs. Brief vs. Mixed): Training with dense captions improves GenEval by approximately 30% relative to brief captions at 120K steps on Lens-130M (Figure 4). The effect is monotonic: Mixed captions (50/50 blend) perform between Brief and Detailed, confirming that the benefit scales with the proportion of dense captions. The paper does not ablate caption length continuously (e.g., 50 words, 75 words, 100 words, 150 words), so the 109-word average is the outcome of GPT-4.1 generation rather than a tuned hyperparameter — the optimal caption length for this model scale remains unknown.
VAE choice (conventional vs. semantic): FLUX.2-VAE outperforms FLUX.1-VAE, SD3-VAE, and VTP at every training step (Figure 5). The gap between FLUX.2-VAE (semantic) and FLUX.1-VAE (conventional) is approximately 0.20 GenEval at 64K steps, confirming that VAE selection has a first-order impact on T2I training efficiency. The paper does not ablate the mechanism (e.g., by comparing latent space properties like linear separability or reconstruction-generation tradeoffs), so the claim that semantic organization drives the benefit is inferential rather than causally demonstrated.
Language encoder capacity (GPT-OSS vs. Qwen3 variants): GPT-OSS consistently outperforms Qwen3 variants of comparable or larger size (Figures 7, 8), with the advantage magnified for multilingual generation. The paper does not ablate the multi-layer feature extraction strategy (e.g., using only the final layer of GPT-OSS vs. using layers 4, 12, 18, 24), so the contribution of multi-layer features to the observed encoder advantage is unknown. Similarly, the paper does not ablate whether the English-only training is necessary for the multilingual result — a model trained with 10% multilingual captions might close the gap, but this experiment is not run.
RL prompt set diversity (full vs. subset vs. text-removed): Reducing RL prompt set size degrades GenEval monotonically (0.916 → 0.920 → 0.930, Table 1 left), and removing text prompts degrades text-rendering benchmarks specifically (CVTG average: 0.869 → 0.832, Table 1 right). The paper does not ablate whether the taxonomy-driven construction matters vs. random sampling of the same number of prompts, so the contribution of the structured taxonomy (vs. sheer prompt quantity) is not isolated.
Distillation speed-quality tradeoff (20-step vs. 4-step): Lens-Turbo largely preserves Lens's quality: OneIG drops from 0.557 to 0.554 (−0.003), GenEval drops from 0.930 to 0.914 (−0.016), LongText drops from 0.937 to 0.927 (−0.010), CVTG NED improves from 0.951 to 0.965 (+0.014), CVTG average drops from 0.869 to 0.889 (+0.020 — an improvement, possibly reflecting distillation's regularization effect or different evaluation conditions). The paper does not ablate the number of distillation steps (e.g., 2-step vs. 8-step), the distillation recipe components (DMD2 vs. decoupled-DMD vs. adversarial vs. none), or the distillation dataset size.
Reasoner backbone (none vs. GPT-5.5 vs. GPT-OSS vs. Qwen3 variants): The reasoner provides substantial gains on GenEval (+0.087 from no reasoner to GPT-5.5) and more modest gains on other benchmarks (OneIG: +0.025, LongText: +0.044). GPT-OSS-20B as reasoner approaches GPT-5.5 performance at zero additional GPU memory cost (since GPT-OSS already serves as the language encoder). The paper does not ablate the reasoner system prompt quality (e.g., comparing the optimized prompt from training-free search against a hand-crafted baseline), so the contribution of the system prompt search to the reasoner's effectiveness is not isolated.
Resolution generalization (unseen aspect ratios and resolutions): The paper claims generalization to arbitrary aspect ratios from 1:2 to 2:1 and resolutions up to 1440², but does not provide quantitative benchmarks at these unseen resolutions — the benchmark evaluations in Tables 2-5 use standard resolutions (likely 1024²), and the qualitative visualizations (Figures 9-16) at 1440² are not accompanied by automated metrics. The resolution generalization claim is supported qualitatively but not quantitatively evaluated.

Critical Assessment

Does Lens achieve performance "competitive with, and in several cases surpassing, state-of-the-art models with more than 6B parameters"? The evidence in Table 2 supports this claim with important nuance. On OneIG, Lens (0.557) edges out Qwen-Image 20B (0.539) and Z-Image 6B (0.546) but trails the commercial Nano Banana 2.0 (0.578) and Seedream 4.0 (0.573). On GenEval, Lens (0.930) is the highest among all models, open-source and commercial — this is the strongest single result in the paper. On LongText, Lens (0.937) is slightly behind Qwen-Image (0.943) among open-source models and substantially behind Nano Banana 2.0 (0.981). On CVTG, Lens (0.869 average) is competitive with the best open-source models (Z-Image: 0.867, LongCat-Image: 0.866) and above the much larger Hunyuan-Image-3.0 (0.765). The claim "competitive with, and in several cases surpassing" is accurate: Lens surpasses larger models on GenEval, is competitive on CVTG, is slightly behind on OneIG and LongText for some models, and is never substantially behind except against the commercial Nano Banana 2.0 on LongText. However, the claim that Lens "surpasses" state-of-the-art models applies specifically to GenEval and specific sub-dimensions (Position, Attribute binding) — it is not a universal statement.

Does Lens require "only approximately 19.3% of the training compute used by Z-Image"? The normalized FLOPs calculation (192K A100 hrs × 312 TFLOPS vs. 314K H800 hrs × 989.5 TFLOPS) supports the 19.3% figure. However, three caveats apply. First, the paper excludes one-time costs (GPT-4.1 caption generation for 800M images, GPT-4.1-mini reward computation during RL) from the training compute accounting. The captioning cost alone — 800M images processed by GPT-4.1 at, conservatively, 1 second per image — would add approximately 222K GPU hours (assuming comparable hardware), potentially doubling the effective compute. The paper argues this cost is amortizable across future models, which is reasonable for a lab training multiple models but less so for a one-off training run. Second, the comparison is against Z-Image specifically — other models may have different training costs, and the paper does not provide a systematic training-compute comparison across all baselines. Third, the TFLOPS normalization assumes perfect scaling, which the paper itself acknowledges may not hold due to memory bandwidth, MFU, and communication overhead differences between A100 and H800 GPUs.

Does Lens's efficiency stem from the three-factor optimization (model size, data information density, convergence speed), or are the individual contributions confounded? The ablation studies in Figures 4, 5, 7, and 8 isolate individual factors (caption length, VAE choice, language encoder choice) and demonstrate that each contributes independently to training efficiency (higher GenEval at equivalent training steps). Figure 4 isolates caption density (Detailed vs. Brief), Figure 5 isolates VAE choice, and Figures 7-8 isolate language encoder choice — all in the same Lens-Toy/Lens-130M setting. The results support the claim that each factor independently improves convergence, but the paper does not run a full factorial ablation (e.g., FLUX.2-VAE + Detailed captions + GPT-OSS vs. all other combinations) to demonstrate that the benefits are additive or multiplicative. The risk is that some factors may be partially redundant — e.g., a strong language encoder might compensate for brief captions, or a semantic VAE might reduce the need for dense captions. The paper's final configuration uses all three optimizations simultaneously, but the evidence that they are complementary rather than overlapping is inferential from separate ablations rather than demonstrated in a joint design.

Does the RL post-training on Lens-RL-8K improve generation across the full distribution, or does it overfit to the RL prompt set? The ablation in Table 1 (left) shows that GenEval score increases with RL prompt set size (0.916 → 0.920 → 0.930), but GenEval is a specific benchmark with its own prompt distribution — it may not represent the full inference-time distribution. The paper's claim that RL improves generation "across diverse scenarios" is supported by the GenEval improvement and the qualitative examples (Figures 9-16), but a more rigorous test would evaluate on prompts systematically sampled from the pre-training distribution rather than on standard benchmarks that may overlap with the RL training distribution. The text prompt removal ablation (Table 1, right) demonstrates that RL benefits are scenario-specific (CVTG drops when text prompts are removed from RL training), which is evidence for the paper's diversity argument but also evidence that RL overfitting to the prompt set is a real risk — if the RL set doesn't cover a scenario, that scenario may not improve (or may degrade).

What experiments would have strengthened the paper? Several missing ablations and comparisons would increase confidence in the claims.

Caption length sweep: A continuous sweep of caption lengths (e.g., 20, 50, 80, 110, 140, 200 words) would identify whether the 109-word average is near-optimal or whether even longer captions would further improve efficiency. The current comparison is binary (Brief vs. Detailed) with a 50/50 blend, providing limited resolution on the dose-response curve.
VAE mechanism ablation: Comparing the FLUX.2-VAE against a version trained with the same architecture but without semantic objectives would isolate whether the semantic training or the architectural improvements drive the convergence benefit.
Multi-layer feature ablation: Comparing the full GPT-OSS (layers 4, 12, 18, 24 concatenated) against GPT-OSS with only the final layer would quantify the contribution of multi-layer features to both English and multilingual performance.
Training compute comparison across all baselines: The paper compares Lens's training cost only to Z-Image. Providing training FLOPs for all open-source baselines (or at least Qwen-Image 20B, FLUX.2-Klein 9B, LongCat-Image 6B) would contextualize the 19.3% figure — if Qwen-Image trained with 500K GPU hours on comparable hardware, Lens's advantage would be even larger; if it trained with 100K GPU hours, Lens's advantage would be smaller.
Quantitative resolution generalization benchmarks: Evaluating Lens on a benchmark of prompts at 1440² resolution (or unseen aspect ratios like 5:4 and 6:7) would convert the qualitative resolution generalization claim (Section 2.3) into a quantitative result comparable to Table 2.
Statistical significance or confidence intervals: The benchmark scores in Tables 2-5 are single-point estimates without error bars. Given that differences between Lens and the next-best models are sometimes small (e.g., OneIG: 0.557 vs. 0.546 for Z-Image, a 0.011 gap on a 0-1 scale), confidence intervals would help assess whether these differences are reliable or within sampling noise. The GenEval gap (0.930 vs. 0.870 for the next-best model) is large enough that sampling noise is unlikely to reverse the ordering, but the OneIG and CVTG gaps are smaller.
Inference cost normalization: Figure 2 plots benchmark score against inference time, but the paper does not normalize for hardware differences — all models are timed on a single H100. If some models were optimized for different hardware (e.g., H800, TPUs), the inference time comparison may not reflect their optimal deployment configuration. Additionally, the reasoner's inference time is presumably included in Lens's total (since the reasoner runs before the T2I model), but this is not explicitly stated.

Where do the paper's central claims hold conditionally? The paper's primary efficiency claim — that Lens competes with much larger models at a fraction of the training cost — holds most strongly on GenEval (where Lens is #1 overall) and on the Alignment and Position dimensions of OneIG (where Lens leads). The claim holds more weakly on LongText, where Qwen-Image (20B) edges out Lens (0.943 vs. 0.937), and on the Text dimension of OneIG, where Z-Image leads (0.987 vs. 0.960). The claim that RL post-training improves generation across diverse scenarios holds when the RL prompt set is sufficiently diverse (Table 1 left) but would likely fail if the prompt set were narrower — the paper demonstrates this failure mode but only evaluates the "sufficiently diverse" condition. The claim that multilingual generalization emerges from English-only training holds for the tested languages (Chinese, French, Japanese, Spanish) but may not hold for languages with very different scripts or typographic conventions (Arabic, Hindi, Korean), which are not separately evaluated.

6. Limitations and Trade-offs

Difficulty Estimation Cost Is Excluded from the Headline Efficiency Number

The paper's central claim — that Lens achieves competitive performance at "only approximately 19.3% of the training compute used by Z-Image" — explicitly excludes two substantial computational costs that are essential to the Lens training pipeline.

The assumption or constraint: The paper acknowledges that the 19.3% figure excludes "re-captioning costs" because "this one-time preprocessing can be reused for future models" (Section 1, Table 2 footnote). This refers to generating dense captions for all 800M images in Lens-800M using GPT-4.1. The paper does not report the FLOPs or GPU hours required for this captioning step, nor does it report the cost of generating GPT-4.1-mini rewards during the 180-step RL post-training phase, which requires evaluating 24 images × 48 prompt-rubric pairs = 1,152 generated images per optimization step, each passed through a VLM for rubric-based scoring. Additionally, the construction of Lens-RL-8K (8,406 prompts generated by GPT-4.1, each with 10 rubrics generated by GPT-4.1) incurs further API inference cost.

The consequence: If the GPT-4.1 captioning of 800M images requires even a conservative 1 second of inference per image, that is approximately 222K GPU hours of additional compute (assuming comparable hardware to the training GPUs), potentially doubling the effective training cost and substantially changing the efficiency comparison against Z-Image. The re-captioning cost is not amortizable in all contexts — a lab training a single model, or training a model on a new dataset that requires fresh captioning, would bear this cost directly. The RL reward computation cost (1,152 GPT-4.1-mini evaluations per step × 180 steps = 207,360 VLM inferences) adds further overhead that is neither reported nor amortized.

What evidence exists in the paper: The paper explicitly acknowledges the exclusion (Section 1, Table 2 footnote: "Re-captioning costs are excluded, as this one-time preprocessing can be reused for future models") and does not provide any quantification of the excluded costs. There is no ablation showing how much performance would degrade if cheaper captioning (e.g., using an open-source VLM, or using shorter captions from a weaker model) were used, making it difficult to assess whether GPT-4.1-level captioning is necessary or whether similar results could be achieved with lower captioning cost.

Mitigation status: Partially addressed. The amortization argument is reasonable for labs that train multiple models on the same dataset, and the paper notes that captioning is a one-time cost. However, the paper provides no cost estimate for the captioning step, making it impossible for practitioners to evaluate the total cost of reproducing Lens. A full accounting including data preparation costs would strengthen the efficiency claim or reveal that the advantage over Z-Image is narrower than 19.3% when all costs are included.

Hard Problems (Text Rendering in Non-English Languages, Complex Visual Scenes) Remain Partially Unsolved

Lens inherits fundamental capability limitations common to T2I models, particularly in text rendering for underrepresented scripts and in certain complex visual scenarios that may be underrepresented in the training data.

The assumption or constraint: The paper's training data is English-only in terms of caption language, with multilingual generalization emerging from the GPT-OSS encoder's pre-training rather than from explicit multilingual image-text training. The paper acknowledges this limitation directly (Appendix F):

"Lens still struggles with visual text rendering in some non-English languages, such as Japanese and French. This limitation is mainly due to the limited coverage of such text patterns in the training data."

The paper also notes that artifacts can occur "due to insufficient training data coverage for certain generation scenarios, rare object compositions, complex layouts, or challenging visual concepts."

The consequence: The multilingual text rendering limitation is not uniform across languages. The paper's multilingual evaluations in Figure 8 average across Chinese, French, Japanese, and Spanish, but does not report per-language breakdowns. A user generating content in Japanese or French may encounter garbled or incorrect text rendering that is substantially worse than the English text rendering benchmark scores (CVTG NED: 0.951 for Lens) suggest. The qualitative examples (Figures 13, 14) primarily show English text, with multilingual text examples (Figures 15, 16) focusing on culturally representative content rather than systematic text-rendering evaluation. For applications requiring accurate multilingual typography (e.g., localized advertising, multilingual educational materials), this limitation may be prohibitive.

Furthermore, the paper acknowledges that some visual artifacts persist even after RL post-training (Appendix F: "like most text-to-image models, Lens may occasionally produce images with visual artifacts"), but does not quantify the artifact rate or provide systematic failure mode analysis. The benchmark scores (Table 2) represent average performance across test prompts, but the variance or worst-case performance on challenging prompts is not reported, making it difficult to assess reliability in production settings where individual failures matter.

What evidence exists in the paper: The multilingual encoder comparison (Figure 8, Section 2.2) demonstrates that performance on non-English prompts is substantially lower than on English prompts across all encoder variants — even GPT-OSS achieves approximately 0.68 GenEval on multilingual prompts vs. approximately 0.70 on English-only (a gap of roughly 0.02), and the gap is much larger for weaker encoders. The CVTG results (Table 5) show that text rendering accuracy for English is strong (NED 0.951, CLIP 0.814), but these metrics are English-only. The paper does not report a non-English text rendering benchmark (e.g., Chinese NED, Japanese character accuracy), so the severity of the multilingual text rendering limitation is not quantified. The visualizations in Figures 13 and 14 show primarily English text rendered with high fidelity, but the failure cases are not shown.

Mitigation status: The paper acknowledges the limitation (Appendix F) but does not address it through training data expansion, targeted fine-tuning, or architectural modifications. The suggestion for future work — "expanding multilingual and text-rich training data" — is stated but not implemented. The multilingual generalization capability from the GPT-OSS encoder provides partial mitigation for prompt understanding (accepting input in multiple languages), but the generation of non-English visual text remains a weakness that the current approach does not solve.

Single Benchmark Family and Single Model Family Limit Generalizability Claims

The paper's entire empirical evaluation — pre-training, RL post-training, architecture ablations, and final benchmark comparisons — is conducted using a single base model architecture (MMDiT-style transformer) trained on a single dataset (Lens-800M) and evaluated primarily on four English-centric benchmarks. While the benchmarks span diverse evaluation criteria, they do not test the generalization of the proposed efficiency strategies to other model architectures, data distributions, or generation paradigms.

The assumption or constraint: The paper's ablation studies (Figures 4, 5, 7, 8) that isolate the effects of caption density, VAE choice, and language encoder choice are all conducted using the Lens-Toy architecture (1.2B MMDiT backbone with Qwen3-0.6B text encoder) on the Lens-130M dataset. The main results are all from the full Lens architecture (3.8B MMDiT) on Lens-800M. The strategies are evaluated against other models (Z-Image, Qwen-Image, FLUX variants) on standard benchmarks, but these comparisons show final performance rather than isolating whether Lens's efficiency strategies would transfer to other architectures (e.g., UNet-based diffusion models like SDXL, autoregressive models like VAR, or discrete token-based generators like MagViT-v2).

The consequence: A practitioner building a T2I model with a different architecture (e.g., a UNet-based generator, a discrete token-based approach, or a non-MMDiT transformer) cannot assume that the three efficiency factors — dense captioning, semantic VAE, strong language encoder — will produce the same relative improvements observed in this paper. The VAE ablation (Figure 5) shows FLUX.2-VAE substantially outperforming FLUX.1-VAE and SD3-VAE, but the FLUX.2-VAE was designed for and co-developed with the FLUX architecture family, and its benefits may be architecture-specific. Similarly, the GPT-OSS encoder's multilingual transfer advantage (Figure 8) may depend on specific properties of GPT-OSS's pre-training that do not generalize to other encoder families (e.g., CLIP-based encoders, T5-based encoders).

The four benchmarks — OneIG, GenEval, LongText, CVTG — are all English-language benchmarks focused on object composition, text rendering, and prompt following. They do not cover important generation dimensions such as photorealism vs. artifact rate (human evaluation), diversity and novelty of generated content, bias and fairness across demographic categories, or robustness to adversarial prompts. The paper's claim that Lens achieves "performance competitive with, and in several cases surpassing, state-of-the-art models" (Section 1) is accurate within the scope of these four benchmarks but should not be interpreted as pan-benchmark superiority.

What evidence exists in the paper: The ablation studies (Figures 4, 5, 7, 8) are all within the Lens-Toy/Lens-130M framework, providing no cross-architecture evidence. The main benchmark comparisons (Tables 2-5) show Lens competing with models of diverse architectures (FLUX uses a different VAE, SD3.5 uses a different backbone, Janus-Pro uses autoregressive generation, BAGEL uses decoder-only multimodal pretraining), but these are endpoint comparisons — they show that Lens's final performance is competitive, not that Lens's training strategies would improve those other architectures if applied to them. The paper does not conduct a controlled experiment applying Lens's three efficiency strategies to a non-MMDiT architecture and measuring the improvement.

Mitigation status: Not addressed. The paper does not claim cross-architecture generalization, nor does it conduct experiments to test it. The strategies are presented as general efficiency principles (Section 1: "training-time efficiency is jointly determined by three key factors"), but the evidence for their generality is limited to a single architecture family. A practitioner can adopt the principles (increase data information density, select VAE and encoder for convergence speed) but must independently verify whether the specific choices (GPT-4.1 captioning, FLUX.2-VAE, GPT-OSS) transfer to their architecture.

RL Requires Careful Prompt Set Design — A Missed or Biased Taxonomy Degrades Performance

The paper's RL post-training strategy depends critically on the Lens-RL-8K prompt set covering the generation scenario distribution comprehensively. The taxonomy-driven construction methodology is a strength (Section 2.4), but it also introduces a dependency: the quality and coverage of the taxonomy determine whether RL improves or degrades the model. The paper demonstrates that insufficient prompt diversity harms performance (Table 1), but it does not establish how much diversity is enough or how robust the approach is to taxonomy design choices.

The assumption or constraint: The paper constructs Lens-RL-8K with 10 coarse categories, dozens of fine-grained sub-categories, and 8,406 concrete items, then prompts GPT-4.1 to generate prompts for each item with randomly sampled description dimensions (Attribute, Spatial Relationship, Count, Interaction, Color). This construction makes several implicit assumptions: (1) the taxonomy categories adequately cover the generation scenarios that users will request at inference time; (2) the GPT-4.1-generated prompts are representative of real user prompts for each scenario; (3) the description dimensions produce sufficient intra-category diversity; and (4) 8,406 prompts is sufficient to cover the distribution. The paper does not validate these assumptions against real user prompt distributions.

The consequence: If the taxonomy misses a generation scenario (e.g., specific cultural or regional content, emerging visual trends, or niche professional use cases like medical illustration or architectural rendering), the RL post-training may not improve — or may actively degrade — performance on that scenario. The text prompt removal ablation (Table 1, right) demonstrates exactly this mechanism: removing text-related prompts from RL training causes CVTG average to drop from 0.869 to 0.832. This is evidence that RL improvements are scenario-specific and do not transfer to uncovered scenarios. The GenEval metric used to evaluate RL improvements (Table 1, left) covers six specific templated tasks that may align with the Lens-RL-8K distribution — improvement on GenEval does not guarantee improvement on the broader inference-time distribution.

A further consequence: the taxonomy construction process itself requires domain expertise and manual effort to define categories, sub-categories, and items. The paper provides no guidance on how to construct a taxonomy for a new domain, how to validate its coverage, or how many items are needed as a function of the diversity of the target distribution. A practitioner with a different target domain would need to independently design a taxonomy, with no principled method for assessing whether it is adequate.

What evidence exists in the paper: Table 1 provides clear evidence that RL performance degrades with reduced prompt set diversity (1/4 set: 0.916, full set: 0.930 on GenEval) and that removing text prompts specifically degrades text rendering (CVTG drop of 0.037). These ablations demonstrate the sensitivity of RL post-training to prompt set design but do not establish a threshold for adequate diversity. The paper does not compare the taxonomy-driven approach against alternative prompt collection methods (e.g., sampling from the pre-training caption distribution, using real user queries from a deployed system, or iterative active learning). It also does not evaluate whether 8,406 prompts is near-optimal — a prompt set of 4,000 or 16,000 prompts might perform equivalently, but the dose-response curve beyond the three points in Table 1 (1/4, 1/2, full) is not measured.

Mitigation status: The paper demonstrates that prompt diversity matters and provides a principled construction methodology (taxonomy-driven), but does not provide tools for validating coverage or determining sufficient scale. The mitigation is partial: a practitioner following the paper's taxonomy-driven approach has a concrete recipe but no guarantee that their taxonomy is adequate. The paper does not suggest automated coverage validation (e.g., embedding-based distribution comparison between RL prompts and pre-training captions) or iterative expansion strategies.

Resolution and Multilingual Generalization Claims Lack Quantitative Evaluation

Two of the paper's most practically significant claims — that Lens generalizes to resolutions up to 1440² and aspect ratios not seen during training, and that it supports multilingual input across several commonly used languages — are supported qualitatively through visualizations (Figures 9-16) but lack quantitative benchmark evaluation. The paper's main benchmark results (Tables 2-5) are almost certainly evaluated at standard resolutions (1024²) and on English prompts, meaning the generalization claims are not reflected in the headline numbers.

The assumption or constraint: The paper claims (Section 2.3) that the model "generalizes well to unseen resolutions and aspect ratios at inference time. Specifically, it can generate images with arbitrary aspect ratios ranging from 1:2 to 2:1 and image areas up to 1440², even though training does not include resolutions between 1024² and 1440², nor aspect ratios outside the predefined bucket set." Section 2.2 claims that "the model is trained only on English image-text pairs, a strong language encoder enables robust inference-time generalization to other languages." However, neither claim is evaluated quantitatively on standard benchmarks — there is no "GenEval at 1440²" table, no "CVTG in Chinese" or "CVTG in Japanese" score, and no systematic comparison of image quality metrics (FID, CLIP score, aesthetic score) at seen vs. unseen resolutions.

The consequence: The resolution generalization claim is qualitatively plausible — the visualizations in Figures 9-16 at 1440² show high-quality images with diverse aspect ratios — but a practitioner deploying Lens for high-resolution generation cannot assess the expected degradation (if any) relative to 1024² output. Resolution generalization is not binary; it may be that 90% of prompts generate well at 1440² while 10% exhibit artifacts, distortion, or repeated patterns that would be caught by quantitative evaluation. Similarly, the multilingual claim is supported by Figure 8 (GenEval scores for non-English prompts, but evaluated at presumably 1024² with the Lens-Toy model), but the main Lens model's multilingual performance is not benchmarked against other models' multilingual performance on standard metrics. The paper reports that Lens "supports prompts in several commonly used languages" (Section 1) and shows qualitative multilingual examples (Figures 15, 16), but does not provide scores that a practitioner could use to compare Lens's multilingual capability against, for example, a model explicitly trained on multilingual data.

What evidence exists in the paper: For resolution generalization, the evidence is exclusively qualitative: Figures 9-16 show 1440² outputs across diverse scenarios (general images, portraits, text rendering, multilingual prompts), and the images appear high-quality on visual inspection. No FID, CLIP score, aesthetic score, or human preference comparison is provided between 1024² and 1440² outputs. The paper mentions that RoPE positional encoding "may further facilitate such generalization" (Section 2.3) but provides no ablation showing that a model without RoPE fails to generalize, or that generalization degrades at resolutions beyond 1440². For multilingual generalization, the evidence is partially quantitative: Figure 8 shows GenEval scores for multilingual prompts with the Lens-Toy model, and Table 2 rows for Lens and Lens-Turbo are presumably English-prompt evaluations. There is no Lens-specific multilingual benchmark score comparable to the English CVTG or LongText results that would allow a practitioner to quantify the multilingual generation quality.

Mitigation status: Not addressed. The paper provides qualitative evidence that both generalization capabilities exist but does not quantify their reliability or quality relative to the training distribution. A practitioner can generate images at 1440² and inspect them visually, but cannot estimate the failure rate or quality gap from the paper's reported results. Adding a quantitative resolution generalization benchmark and a multilingual text-rendering benchmark (even on a subset of CVTG or LongText translated to Chinese, French, Japanese, Spanish) would convert these qualitative claims into actionable performance estimates.

The 14× Larger Model Baseline Comparison Is Incomplete — Training Compute for All Competitors Is Not Reported

The paper's efficiency thesis rests heavily on the comparison with Z-Image's reported training compute (314K H800 GPU hours), from which the 19.3% figure is derived. However, the paper does not report training compute for any other baseline model, making it impossible to assess whether Lens's efficiency advantage generalizes beyond the single Z-Image comparison.

The assumption or constraint: Section 1 states: "compared with Z-Image (6B), Lens (3.8B) attains competitive or superior results while using only approximately 19.3% of its training compute." The paper normalizes GPU types (A100 vs. H800) using peak BF16 TFLOPS but does not provide training compute figures for Qwen-Image (20B), FLUX.2-Klein (9B), LongCat-Image (6B), SD3.5 Large (8B), Hunyuan-Image-3.0 (80B MoE), or any of the other 15+ baselines in Table 2. Some of these models may have been trained with smaller compute budgets than Z-Image, potentially making Lens's efficiency advantage less distinctive.

The consequence: Without training compute data for the full baseline set, the efficiency claim is narrowly bounded to the Z-Image comparison. It is possible that Qwen-Image (20B), despite having 5.3× more parameters, was trained with comparable or only moderately higher compute due to more efficient training recipes, data curation, or infrastructure. The paper's Figure 2 plots benchmark score vs. inference time (not training time), which shows Lens in a favorable position but does not speak to training efficiency — a model could have slow inference but cheap training, or vice versa. The paper's argument that Lens represents a Pareto improvement in the performance-efficiency space would be stronger with training FLOPs on the x-axis (or both training and inference FLOPs) across all baselines, enabling a full cost-quality frontier comparison rather than a point comparison against a single model.

Additionally, Z-Image may not be the most training-efficient baseline. If Z-Image was trained with a relatively inefficient recipe (e.g., excessive training iterations, suboptimal batch size, or data repetition), the 19.3% figure may partly reflect Z-Image's inefficiency rather than Lens's efficiency. The paper's three-factor optimization (data information density, convergence speed, model size) could be partially matched by other models that made different but equally effective efficiency choices, and without reporting their training costs, the paper cannot demonstrate that Lens is uniquely efficient rather than simply more efficient than one specific model.

What evidence exists in the paper: The only training compute comparison is against Z-Image (192K A100 GPU hours for Lens vs. 314K H800 GPU hours for Z-Image, normalized to 19.3% via peak BF16 TFLOPS). The paper does not report training GPU hours, total FLOPs, wall-clock training time, or training data volume for any other model in Table 2. The inference time comparison (Figure 2) provides partial evidence of efficiency at deployment time but does not address training cost.

Mitigation status: Not addressed. The paper's efficiency claim is accurate for the Lens-vs-Z-Image comparison but is presented as a broader statement about Lens's training efficiency relative to "state-of-the-art models with more than 6B parameters" (Section 1). Without training cost data for the full comparison set, this broader claim is not supported. Collecting and reporting training compute estimates for major open-source baselines (or at minimum for the closest competitors like Qwen-Image 20B, FLUX.2-Klein 9B, and LongCat-Image 6B) would substantially strengthen the efficiency thesis and allow practitioners to position Lens on the full training-cost-quality frontier.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a systematic reframing of T2I training efficiency rather than a single architectural innovation. The field has largely operated under an implicit assumption that better generation quality requires scaling model parameters, with data curation and architectural choices treated as secondary concerns optimized only to the point of avoiding obvious failure. Lens demonstrates that this assumption leaves substantial efficiency gains on the table: when data information density, architectural convergence speed, and model size are treated as joint optimization targets rather than independent design decisions, a 3.8B model can match or exceed 6B–20B models on standard benchmarks at approximately 19.3% of the training compute of a representative 6B competitor (Z-Image).

The conceptual shift is from performance-maximization at any cost to Pareto-optimal performance-efficiency. This matters because it changes what counts as a contribution: architectural choices (VAE, language encoder) and data processing decisions (caption density, resolution diversity) become first-class efficiency levers whose value should be measured in training FLOPs saved, not just in final benchmark scores. The paper's three-factor decomposition — model size, data information density, convergence speed — provides a reusable diagnostic framework that any T2I training effort can apply to identify where they are leaving efficiency on the table.

This reframing has consequences for how competing research directions are prioritized. Scaling model size alone becomes less attractive as a path to quality improvement when a smaller model with optimized data and architecture can match the larger model at a fraction of the cost. The paper does not claim that scaling is obsolete — it explicitly acknowledges that on the hardest generation scenarios, larger models may still be necessary — but it shifts the burden of proof: a new model that achieves +2% on GenEval by doubling parameters but ignoring data information density has not demonstrated that the parameter increase was the most efficient way to achieve that gain.

The paper also resolves a latent tension in the T2I literature between two evaluation philosophies. The first evaluates VAEs by reconstruction fidelity (rFID, PSNR), and the second evaluates them by downstream generation quality. Lens's VAE ablation (Figure 5) shows that these metrics can point in opposite directions — the FLUX.2-VAE substantially outperforms reconstruction-optimized VAEs when measured by T2I convergence speed and final GenEval score, but this advantage would not be visible from reconstruction metrics alone. This finding provides concrete evidence that proxy metrics can mislead architectural decisions and that components should be evaluated in their deployment context.

A more subtle shift concerns the role of language encoders in T2I systems. Prior work typically treats the text encoder as a fixed embedding provider — CLIP or T5 at whatever scale is convenient. Lens demonstrates that the encoder is a capability multiplier: a stronger encoder (GPT-OSS, 20B-MoE with 3B activated) not only accelerates convergence on English prompts but also unlocks emergent multilingual generalization from English-only T2I training data (Figure 8). This finding suggests that investment in the encoder can substitute for investment in multilingual training data — a finding with direct implications for how organizations should allocate data collection budgets.

Follow-Up Research This Work Enables

Quantifying the dose-response curve for caption density. The paper demonstrates that dense captions (approximately 109 words average) outperform brief captions (Figure 4), but the continuous relationship between caption informativeness and training efficiency is unknown. A controlled experiment training Lens-Toy models on Lens-130M with captions systematically truncated to 20, 40, 60, 80, 100, 120, and 150 words average length would reveal whether the benefit saturates, whether there is an optimal point, and whether extremely long captions (200+ words) introduce noise that harms efficiency. This would convert the binary "dense vs. brief" finding into a prescriptive caption-length target for practitioners.

Isolating the mechanism of VAE-driven convergence acceleration. The paper attributes the FLUX.2-VAE's advantage to its semantic latent space organization (Section 2.2), but this mechanism is inferred rather than demonstrated. A follow-up study could measure latent space properties directly — linear separability of semantic categories, mutual information between latent dimensions and object class labels, reconstruction-generation tradeoff curves — across the four VAE variants (FLUX.2, VTP, SD3, FLUX.1) and correlate these properties with downstream T2I convergence speed. If semantic organization is the causal mechanism, then any VAE with equivalent semantic organization (regardless of architecture) should produce equivalent convergence benefits. If the FLUX.2-VAE benefits instead come from architectural details (compression ratio, latent dimension, training data scale), then the semantic organization hypothesis is insufficient.

Stress-testing resolution generalization beyond 1440². The paper claims generalization to 1440² and arbitrary aspect ratios from training up to 1024² (Section 2.3), but provides only qualitative evidence. A quantitative study evaluating Lens (and, for comparison, other models trained with mixed resolutions) on a standard benchmark (e.g., GenEval or a subset of OneIG) at 1024², 1280², 1440², 1600², and 1920² would characterize the generalization envelope: at what resolution does quality begin to degrade? Does the degradation manifest as repeated patterns, distorted anatomy, or blur? Does aspect ratio generalization hold equally for extreme ratios (1:3, 3:1) outside the training range? The RoPE-based mechanism predicts smooth degradation as relative positions exceed training distribution — measuring this would validate or refute the positional encoding hypothesis.

Systematic comparison of RL prompt set construction strategies. The paper's taxonomy-driven Lens-RL-8K construction is principled but expensive (requiring domain expertise to define the taxonomy and GPT-4.1 API calls to generate prompts and rubrics). A head-to-head comparison of three prompt collection strategies — taxonomy-driven (Lens-RL-8K), distribution-matching (sampling prompts from the pre-training caption distribution), and user-query-driven (collecting prompts from a deployed system's logs) — trained with identical RL configurations and evaluated on held-out benchmarks would reveal whether the taxonomy's structure matters beyond its coverage. If distribution-matching from pre-training captions achieves equivalent GenEval improvement, the manual taxonomy construction step can be eliminated.

Cross-architecture validation of the three-factor efficiency framework. All ablation studies in the paper use the MMDiT architecture family (Lens-Toy and full Lens). A controlled experiment applying the same three optimizations — dense GPT-4.1 captions, a semantic VAE (e.g., FLUX.2-VAE), and a strong language encoder (e.g., GPT-OSS or a comparable open-weight model) — to a non-MMDiT architecture (e.g., a UNet-based diffusion model like SDXL, or an autoregressive generator like VAR) on the same Lens-130M dataset would test whether the efficiency principles generalize or are architecture-specific. The outcome determines whether the paper's contributions are a set of general design principles or a recipe specific to MMDiT-style transformers.

Per-language multilingual text rendering benchmarks. The paper acknowledges that text rendering in non-English languages is a limitation (Appendix F) but provides no quantitative per-language breakdown. Translating a subset of CVTG or LongText into Chinese, Japanese, French, Spanish, Arabic, and Hindi, and evaluating Lens against models with explicit multilingual training data (e.g., Qwen-Image, which supports Chinese) would quantify the gap between emergent multilingual generalization and trained multilingual capability. This would identify which languages are within the "emergence zone" (acceptable quality from the encoder's cross-lingual transfer) and which require explicit training data investment — a finding with direct implications for the amortization argument in the captioning cost debate.

Practical Applications and Downstream Use Cases

Cost-efficient fine-tuning for domain-specific T2I models. Organizations developing specialized T2I models for domains like e-commerce product visualization, architectural rendering, or medical illustration can apply the paper's three-factor framework to their fine-tuning pipelines. Starting from a pre-trained Lens-scale model (or applying the same principles to an open-weight base), using dense domain-specific captions (generated once by a VLM and reused), and selecting a VAE and encoder appropriate to the domain, a team can achieve domain-competitive quality at substantially lower training cost than fine-tuning a 20B-parameter model. The 19.3% training compute figure relative to Z-Image provides a rough cost multiplier: if fine-tuning a 20B model on domain data costs $50,000 in cloud compute, applying Lens's efficiency strategies to a 3.8B model might reduce this to approximately$ 10,000, with the one-time captioning cost amortized across fine-tuning iterations.

On-device or edge-deployed T2I generation. Lens-Turbo's 0.84-second generation time for a 1024² image on a single H100 GPU makes real-time, local T2I generation feasible for consumer devices or edge servers with comparable GPU capability. For applications like real-time design tools, gaming asset generation, or privacy-sensitive generation where cloud API calls are undesirable, Lens's compact 3.8B size and 4-step distillation provide a concrete inference budget (under 1 second at standard resolution) that developers can use to determine hardware requirements. The resolution generalization capability (up to 1440²) means that users can generate higher-resolution outputs on-demand without the model having been trained at those resolutions, enabling a "generate fast at 1024², upscale on request" workflow.

Multilingual T2I deployment without multilingual training data. Organizations serving users across multiple languages can deploy Lens with the GPT-OSS encoder and achieve prompt understanding in Chinese, French, Japanese, and Spanish without collecting or training on multilingual image-text pairs. The GenEval multilingual gap relative to English (approximately 0.02 for GPT-OSS at 120K steps, Figure 8) provides a quantitative estimate of the quality tradeoff: multilingual prompt following is slightly below English quality but substantially above what weaker encoders provide. For applications where near-English quality in common non-English languages is acceptable, this eliminates the need for a parallel multilingual data pipeline. However, the acknowledged limitation in non-English visual text rendering (Appendix F) means that applications requiring accurate Japanese or French typography in generated images still require explicit training data investment.

When to Prefer This Method

The paper explicitly frames Lens against the dominant paradigm of scaling model size for quality, and the experimental comparisons provide specific conditions where Lens's efficiency-focused approach is preferable to training or deploying a larger model. The decision criteria are:

Prefer Lens's compact architecture and efficiency strategies when inference latency or deployment hardware constrains model size — for example, when generating at interactive speeds (under 1 second for 1024² via Lens-Turbo at 0.84 seconds) or when GPU memory is limited (3.8B vs. 20B parameters for Qwen-Image). The GenEval result (0.930, highest among all tested models) and CVTG text rendering (NED 0.951) show that the compact model does not sacrifice quality on these dimensions.
Prefer the dense captioning and mixed-resolution training pipeline when a one-time captioning investment can be amortized across multiple model training runs or fine-tuning iterations — the excluded captioning cost (Section 1) becomes negligible under amortization, and the resolution generalization benefit (1440² output from 1024² training) compounds the training cost savings.
Prefer scaling model size instead when the application domain requires text rendering in non-English scripts that are absent or sparse in the English-captioned training data — the paper acknowledges this as a specific failure mode (Appendix F) where the emergent multilingual generalization from GPT-OSS does not extend to visual text generation.
Prefer scaling model size instead when the target prompt distribution includes a high proportion of rare object compositions, complex layouts, or challenging visual concepts that the paper acknowledges as artifact-prone (Appendix F), and where even the RL post-training on Lens-RL-8K may not provide sufficient coverage — larger models may have more capacity to handle out-of-distribution prompts without fine-tuning.