Forge-and-Quench: Enhancing Image Generation for Higher Fidelity in Unified Multimodal Models

Paper: arXiv:2601.04706 Code: YanbingZeng/Forge-and-Quench Code reference: master @ 763a05b1 (2026-01-09)

1. Motivation (研究动机)

这篇论文关注 unified multimodal model 里一个很具体的问题：understanding 如何真正帮助 generation，而不只是把 MLLM 当成一次性的 prompt rewriter。现有两条路线各有瓶颈：一类是把文本、图像都 token 化后训练统一自回归模型，形式统一但训练成本高；另一类是冻结 MLLM 和 T2I backbone，用轻量 modal bridge 连接两端，例如 MetaQuery / BLIP3-o，把 MLLM 的 reasoning / world knowledge 转给生成模型，但通常是把 MLLM 输出映射成一个语义 embedding 后作为唯一 condition。

作者认为后一类方法虽然有效，但存在一个 “one-time handoff” 信息瓶颈：MLLM 能理解的 texture、lighting、composition、文化语境、细粒度视觉常识，最终被压缩进单一语义条件，细节容易丢失或纠缠。IP-Adapter 类 controllable generation 说明真实参考图的 image feature 可以显著提升 fidelity 和 detail richness；但普通 text-to-image 没有 reference image。论文的核心问题因此变成：能否让 MLLM 从文本/对话中 forge 一个虚拟视觉信号，让 T2I 像拿到参考图特征一样获得细节指导？

这值得研究，因为它把 “理解帮助生成” 从高层 prompt 改写推进到生成过程内部的 visual guidance：如果成功，unified model 不需要牺牲 MLLM 的理解能力，也不需要端到端重训大模型，就能增强图像真实性、降低 AI artifact，并在替换 MLLM 或 T2I backbone 时只重训相应轻量 adapter。

2. Idea (核心思想)

核心 insight 是：MLLM 的理解能力不只应该输出更好的 text prompt，还可以被蒸馏/映射成一个 virtual image feature，用类似参考图控制的方式注入 T2I denoising/flow process。 Forge-and-Quench 因此使用双路径 conditioning：MLLM 先生成 enhanced text prompt $t^{\ast }$，同时通过 Bridge Adapter 生成 Bridge Feature $e_b$；随后 Injection Adapter 把 $e_b$ 注入冻结的 T2I backbone，和标准 text embedding $e_t^{\ast }$ 共同控制生成。

与 MetaQuery / BLIP3-o 这类 “MLLM embedding 替代原 text condition” 的 modal bridge 不同，Forge-and-Quench 不把 bridge embedding 当作唯一语义条件，而是保留 T2I 原生 text encoder 处理 $t^{\ast }$，再额外加入 SigLIP-style visual prior。与 IP-Adapter 不同，它没有真实 reference image，而是由 MLLM + Bridge Adapter 从文本 forge 出虚拟视觉特征。

Figure 1 解读：图中对比了三种生成范式：(a) text + reference image 到 image，典型是 IP-Adapter 式控制生成；(b) text 经 MLLM 映射到 text/image semantic embedding 后单条件生成；(c) Forge-and-Quench 的目标是从 text 中 forge 出 virtual image feature，再与增强文本一起送入 T2I。这个图直接对应论文的核心定位：不是把理解模块输出压成一个语义 embedding，而是让理解模块产生可注入生成过程的视觉先验。

3. Method (方法)

3.1 Overall framework：Forge + Quench 双阶段

Forge-and-Quench 的整体范式可以写成： ${\hat{v}}_{s-1}=u_{\theta }(z_s,s\mid e_t^{\ast },e_b),$ 其中 $u_{\theta }$ 是冻结的 latent flow matching T2I backbone，$e_t^{\ast }={\mathcal{E}}_T(t^{\ast })$ 是 enhanced prompt 通过 T2I 原生 text encoder 得到的 embedding，$e_b$ 是 MLLM forge 出来的 Bridge Feature。相比普通 T2I： ${\hat{v}}_{s-1}=u_{\theta }(z_s,s\mid e_t),$ 以及 reference-image controllable generation： ${\hat{v}}_{s-1}=u_{\theta }(z_s,s\mid e_t,e_i),$ FaQ 试图在没有真实 $e_i$ 的情况下生成一个虚拟 $e_b$，逼近参考图特征对 fidelity 的提升作用。论文还把 MetaQuery / BLIP3-o 类 unified modal bridge 形式写为： ${\hat{v}}_{s-1}=u_{\theta }(z_s,s\mid e_b),$ 并指出这种把 $e_b$ 作为唯一 condition 的路线可能丢掉多源条件互补性。

Figure 2 解读：图中上半部分是 Forge：MLLM 读取原始 prompt / 对话上下文，一方面生成更细的 enhanced text，另一方面通过 learnable queries 抽取固定长度中间 embedding $e_m$，再经 Bridge Adapter 生成 Bridge Feature $e_b$。下半部分是 Quench：$t^{\ast }$ 进入 T2I 原生 text encoder，$e_b$ 经 Injection Adapter 转成 cross-attention 可用的 visual guidance，注入每个 DiT layer。MLLM 与 T2I backbone 都冻结，因此 understanding capability 不被训练破坏，新增训练集中在 Bridge Adapter 和 Injection Adapter。

直觉上，$t^{\ast }$ 负责高层语义：对象、关系、文化语境、构图意图；$e_b$ 负责提供更像 image prompt 的细粒度视觉 prior：皮肤纹理、头发、服饰材质、背景高频细节等。这样的好处是不会强迫 MLLM 把所有视觉细节都压进一句 prompt，也不会改动 T2I 的主干分布。

3.2 Forge：文本增强与 Bridge Feature 生成

Forge 包含两个输出。

Text instruction enhancement：MLLM 先根据用户原始 prompt 和对话上下文生成 $t^{\ast }$。论文例子中，用户表达想换 garden style 并提到 Chinese culture，MLLM 能把 “a formal European-style garden” 改成 “A tranquil painting of a classical Chinese garden. A wooden pavilion overlooks a calm pond, and a person is visible through a circular moon gate in a white wall.” 这不是简单 paraphrase，而是把文化知识和上下文意图展开成可生成细节。

Forging Bridge Feature：作者选择 SigLIP vision encoder ${\mathcal{E}}_{\text{Sig}}$ 定义目标视觉空间。给定 ground-truth image $I$，目标特征为： $e_s={\mathcal{E}}_{\text{Sig}}(I).$ 训练时，$t^{\ast }$ 输入冻结 MLLM，用 learnable query extractor ${\mathcal{F}}_M$ 得到固定长度中间表示： $e_m={\mathcal{F}}_M(t^{\ast }).$ Bridge Adapter ${\mathcal{B}}_{\varphi }$ 学习从 $e_m$ 到 SigLIP feature space 的 conditional flow / diffusion mapping。论文目标函数为： ${\mathcal{L}}_{\text{F}}={\mathbb{E}}_{e_s,e_m,ϵ\sim \mathcal{N}(0,I),k}\left[{\Vert v_b-{\mathcal{B}}_{\varphi }(e_{s,k},k,e_m)\Vert }_2^2\right],$ 其中 $v_b=ϵ-e_s$，$e_{s,k}$ 是 target feature $e_s$ 在 diffusion step $k$ 的 noisy version。推理时，Bridge Adapter 反向 denoise，得到可用的 $e_b$。

Released code 中这一部分主要对应 ForgeModel 和 ForgePipeline：ForgeModel 加载 Qwen2.5-VL 和一个 Flux-style DiT，维护 latent_queries，并用 gen_mlp_adapter 把 Qwen hidden states 投到 joint_attention_dim；ForgePipeline.__call__ 把 <|generate_image_pad|> token 替换为 learnable latent queries，取 Qwen 最后一层 hidden states 中 query 对应位置，再运行 FlowMatchEuler denoising，输出 adapter_feature。代码公开的是 inference path；论文中的 Forge training loss 没有在 repo 中给出训练脚本。

def forge_bridge_feature(prompt, forge_model, tokenizer, scheduler, num_steps=30, cfg=4.5):
    template = choose_cn_or_en_template(prompt)
    cond_ids = encode_with_generate_image_tokens(prompt, template, forge_model.num_querys)
    uncond_ids = encode_with_generate_image_tokens("", template, forge_model.num_querys)
    input_ids, attention_mask = left_pad([cond_ids, uncond_ids])
 
    embeds = forge_model.mllm.model.language_model.embed_tokens(input_ids)
    generate_mask = (input_ids == tokenizer("<|generate_image_pad|>").input_ids[0])
    embeds[generate_mask] = forge_model.latent_queries.repeat(2, 1, 1).flatten(0, 1)
 
    # Qwen hidden states at query positions -> conditioning tokens for the feature DiT
    prompt_embeds = forge_model.forward_prompt_embs(embeds, attention_mask)
    latents, img_ids = sample_siglip_feature_latents(batch=1, h=27, w=27)
    latents = torch.cat([latents, latents], dim=0)
 
    for t in scheduler.timesteps(num_steps):
        noise = forge_model.dit(
            hidden_states=latents,
            encoder_hidden_states=prompt_embeds,
            timestep=t / 1000,
            img_ids=img_ids,
            txt_ids=make_prompt_ids(prompt_embeds),
        )[0]
        cond, uncond = noise.chunk(2, dim=0)
        noise = uncond + cfg * (cond - uncond)
        latents = scheduler.step(torch.cat([noise, noise], dim=0), t, latents)[0]
 
    return latents.chunk(2, dim=0)[0]  # adapter_feature / Bridge Feature

3.3 Quench：把 Bridge Feature 注入冻结 T2I backbone

Quench 阶段冻结整个 T2I backbone $u_{\theta }$，只训练 lightweight Injection Adapter ${\mathcal{A}}_{\psi }$。增强文本先由 T2I 原生 text encoder 处理： $e_t^{\ast }={\mathcal{E}}_T(t^{\ast }).$ Bridge Feature $e_b$ 通过 ${\mathcal{A}}_{\psi }$ 转换后，以类似 IP-Adapter 的 cross-attention 机制注入每个 DiT layer。训练目标为： ${\mathcal{L}}_{\text{Q}}={\mathbb{E}}_{z_0,t^{\ast },e_b,ϵ\sim \mathcal{N}(0,I),s}\left[{\Vert v-u_{\theta }(z_s,s\mid e_t^{\ast },{\mathcal{A}}_{\psi }(e_b))\Vert }_2^2\right],$ 其中 $v=ϵ-z_0$，$z_0={\mathcal{E}}_{\text{VAE}}(I)$。由于 $u_{\theta }$ 冻结，梯度只更新 Injection Adapter。

Released code 中，prepare_for_quench 会递归找到 FLUX / LongCat transformer 的 attention processors，将 transformer_blocks.* 和 single_transformer_blocks.* 替换成 FaQAttnProcessor，然后初始化 Resampler(dim=joint_attention_dim, depth=4, heads=16, num_queries=16, embedding_dim=1152) 来把 SigLIP-style feature 映射成 T2I attention 可用的 token。推理时，adapter_feature 先经 faq_proj_model，再写入 joint_attention_kwargs['adapter_feature']，每个 attention processor 额外计算一条对 adapter feature 的 scaled-dot-product attention，并把结果以 faq_scale 加回 hidden states。

def prepare_for_quench(pipe, checkpoint_path):
    processors = collect_attention_processors(pipe.transformer)
    for name in processors:
        if name.startswith("transformer_blocks.") or name.startswith("single_transformer_blocks"):
            processors[name] = FaQAttnProcessor(
                hidden_size=pipe.transformer.num_attention_heads * pipe.transformer.attention_head_dim,
                cross_attention_dim=pipe.transformer.joint_attention_dim,
            ).to(pipe.transformer.device, dtype=pipe.transformer.dtype)
    set_attention_processors(pipe.transformer, processors)
 
    pipe.faq_proj_model = Resampler(
        dim=pipe.transformer.joint_attention_dim,
        depth=4,
        dim_head=64,
        heads=16,
        num_queries=16,
        embedding_dim=1152,
        output_dim=pipe.transformer.joint_attention_dim,
    ).to(pipe.transformer.device, dtype=pipe.transformer.dtype)
    state = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
    pipe.faq_proj_model.load_state_dict(state["faq_proj_model"])
    torch.nn.ModuleList(processors.values()).load_state_dict(state["faq_processors_layers"])
    return pipe

def quench_denoise(pipe, prompt, adapter_feature, faq_scale, num_steps):
    prompt_embeds, pooled_prompt_embeds, text_ids = pipe.encode_prompt(prompt)
    latents, latent_image_ids = pipe.prepare_latents(height=1024, width=1024)
    adapter_tokens = pipe.faq_proj_model(adapter_feature)
    pipe.joint_attention_kwargs["adapter_feature"] = adapter_tokens
    for proc in pipe.processors.values():
        if isinstance(proc, FaQAttnProcessor):
            proc.scale = faq_scale
 
    for t in pipe.scheduler.timesteps(num_steps):
        noise = pipe.transformer(
            hidden_states=latents,
            timestep=t / 1000,
            pooled_projections=pooled_prompt_embeds,
            encoder_hidden_states=prompt_embeds,
            txt_ids=text_ids,
            img_ids=latent_image_ids,
            joint_attention_kwargs=pipe.joint_attention_kwargs,
        )[0]
        latents = pipe.scheduler.step(noise, t, latents)[0]
    return pipe.vae.decode(latents)

class FaQAttnProcessor(torch.nn.Module):
    def __call__(self, attn, hidden_states, encoder_hidden_states=None,
                 image_rotary_emb=None, adapter_feature=None):
        q = project_query(hidden_states, attn)
        k, v = project_key_value(hidden_states, attn)
 
        if adapter_feature is not None:
            ak = self.faq_adapter_to_k(adapter_feature)
            av = self.faq_adapter_to_v(adapter_feature)
            ak = self.faq_adapter_norm_added_k(split_heads(ak))
            faq_hidden = F.scaled_dot_product_attention(q, ak, split_heads(av), dropout_p=0.0)
            faq_hidden = merge_heads(faq_hidden)
 
        hidden = normal_self_or_joint_attention(q, k, v, encoder_hidden_states, image_rotary_emb)
        if adapter_feature is not None:
            hidden = hidden + self.scale * faq_hidden
        return output_projection(hidden)

3.4 Bridge Adapter / Bridge Feature 设计原则

Bridge Adapter 的建模方式有三种候选：Diffusion、AutoRegressive、Projection。论文用 MeiGen-Image-FaQ 的 COCO-30K FID 与 latency 做权衡：Diffusion 的 FID 最好，Projection 最快但质量差，AR 质量居中但延迟极高，因此最终选择 diffusion Bridge Adapter。

Method	FID ↓	Latency (s) ↓
MeiGen-Image	23.97	-
w/ FaQ (Diffusion)	19.86	0.49
w/ FaQ (AutoRegressive)	20.81	7.31
w/ FaQ (Projection)	21.35	0.10

Adapter size 的结论是：2B / QSize=64 已经接近最佳 trade-off；6B 稍微提升 FID 但 latency 从 0.49s 增到 1.51s；query size 128 稍好于 64，256 反而略差。

Variant	FID ↓	Latency (s) ↓
MeiGen-Image (Base)	23.97	-
DiT-2B & QSize=64	19.86	0.49
DiT-6B & QSize=64	19.63	1.51
DiT-2B & QSize=128	19.76	0.55
DiT-2B & QSize=256	20.08	0.62

Figure 6 解读：图中绕过 Forge，直接从 reference image 用不同 visual encoder 提取 feature，再送入 Quench 做 image reconstruction / redux。SigLIP 系列最能保留 reference 的质感与细节；Qwen2.5-VL-ViT 几乎不能提供有效 fidelity cue，结果接近普通 T2I；OpenCLIP 居中。这说明 Bridge Feature 的目标空间不能只看语义理解能力，还要看它是否承载可被生成模型利用的视觉细节。

SigLIP2 在理想 reference feature 场景下表现好，但在真实 FaQ 中更容易产生 artifact。论文用噪声扰动解释：forged feature 和真实 SigLIP feature 不可能完全一致，这个误差可视为 feature noise。若 encoder feature space 对噪声敏感，就难以 forge。扰动公式为： ${\mathbf{e}}^{\prime }=\mathbf{e}+\lambda \cdot \mathcal{N}({\mu }_{\mathbf{e}},{\sigma }_{\mathbf{e}}^2).$

Noise scale $\lambda$	0.0	0.2	0.4	0.6	0.8	1.0
Cosine Sim. (SigLIP-ViT)	1.00	0.98	0.93	0.85	0.78	0.71
Cosine Sim. (SigLIP2-ViT)	1.00	0.88	0.68	0.53	0.42	0.35

Feature	shape	mean	std	norm	abs_max
SigLIP-ViT@384px	729×1152	0.1060	2.0938	1920	217
SigLIP2-ViT@384px	576×1152	0.0830	3.2188	2576	1680

Figure 7 解读：SigLIP2-ViT 在完整 Forge-and-Quench 中会带来明显失真，和表中的 robustness 分析一致：它的特征维度统计更尖锐、扰动后 cosine similarity 下降更快，所以当 Bridge Adapter 无法完美预测 feature 时，错误会被 Quench 放大为视觉 artifact。最终作者采用 SigLIP-ViT，而不是理论上更强的 SigLIP2。

3.5 Code-to-paper mapping

Code reference: master @ 763a05b1 (2026-01-09) — pseudocode and mapping based on this commit

Paper Concept	Source File	Key Class/Function
Forge Model：Qwen2.5-VL + latent queries + feature DiT	forge_and_quench/models/modeling_forge_and_quench.py	ForgeModel.__init__, ForgeModel.forward_prompt_embs
Forge inference：从 prompt 生成 adapter_feature	forge_and_quench/pipelines/forge_pipeline.py	ForgePipeline.prepare_and_encode_prompt, ForgePipeline.__call__
Bridge feature denoising backbone	forge_and_quench/models/mmdit.py	FluxTransformer2DModel.forward
Injection Adapter / FaQ attention	forge_and_quench/models/modeling_forge_and_quench.py	FaQAttnProcessor.__call__
Quench adapter projection	forge_and_quench/models/resampler.py	Resampler.forward, PerceiverAttention.forward
FLUX.1-dev Quench inference	forge_and_quench/pipelines/quench_pipeline_flux1_dev.py	FluxPipeline.prepare_for_quench, FluxPipeline.__call__
LongCat-Image Quench inference	forge_and_quench/pipelines/quench_pipeline_longcat_image.py	LongCatImagePipeline.prepare_for_quench, LongCatImagePipeline.__call__
End-to-end demo / inference args	infer.py	get_pipe, main inference branch

论文公式与 released code 实现差异：论文给出了 Forge / Quench 的训练目标和训练规模，但 released GitHub repo 主要提供 inference pipeline、attention processor、projection module 与模型加载逻辑；没有公开 Forge/Quench 训练脚本、训练数据 filtering 逻辑或 loss 计算实现。因此笔记中的 training loss 来自论文，pseudocode 中的 inference path 来自 released code，不能把 repo 当作完整训练复现。

4. Experimental Setup (实验设置)

Backbones / models

• MeiGen-Image：Meituan 内部 6B text-to-image model，single-stream + double-stream block 架构，论文称未来开源；增强版记为 MeiGen-Image-FaQ。
• FLUX.1-dev：Black Forest Labs 的 12B open-source T2I backbone，single-stream + double-stream block 架构；增强版记为 FLUX.1-dev-FaQ。
• Released code：README 实际支持 flux1-dev 与 longcat-image 两个 T2I model，使用 Qwen2.5-VL-7B-Instruct、FLUX.1-dev / LongCat-Image、Forge-and-Quench checkpoints。代码示例中 FLUX 的 faq_scale=0.50、num_inference_steps=28，LongCat 的 faq_scale=0.35、num_inference_steps=50、enable_cfg_renorm=True。

Training data / hyperparameters

Item	Forge	Quench
Module size	2B	1B
Training data	200M image-text pairs	13M filtered subset
LR	1e-4	1e-4
LR scheduler	Constant	Constant
Training steps	500k	80k = 50k@512px + 30k@1024px
Global batch size	512	256
Optimizer	AdamW(${\beta }_1=0.9,{\beta }_2=0.95$)	AdamW(${\beta }_1=0.9,{\beta }_2=0.95$)

论文未详细说明 GPU type/count；released repo 也没有训练 config / launch scripts 可核对硬件与训练吞吐。

Evaluation benchmarks / metrics

• GenEval：评估 prompt-image alignment，包括 single object、two object、counting、colors、position、color attribute。
• DPG-Bench：评估图文一致性 / compositional prompt following，包括 global、entity、attribute、relation、other。
• COCO-30K FID：在 COCO-30K 上衡量生成图像分布质量，越低越好。
• GPT-Fidelity：自定义 pairwise metric，用 GPT-4 在同一 prompt 下比较两张图的 image fidelity，报告 win rate。
• WISE：世界知识 reasoning benchmark，覆盖 cultural、time、space、biology、physics、chemistry。
• Human evaluation：约 2,000 prompts，annotator 对 baseline 与 FaQ side-by-side 比较 prompt alignment 和 visual quality。

Figure 3 解读：human evaluation 的重点不是证明 alignment 明显提升，而是证明 FaQ 在 prompt alignment 上与原模型基本持平，同时视觉质量获得明显偏好。这和论文主张一致：Bridge Feature 的主要收益是 fidelity / detail，不应以牺牲 instruction following 为代价。

5. Experimental Results (实验结果)

5.1 Main automatic results

Method	COCO-30K FID ↓	GPT-Fidelity ↑	GenEval ↑	DPG-Bench ↑	WISE ↑
MeiGen-Image	23.97	12% win	0.7845	85.94	0.55
MeiGen-Image-FaQ	19.86	88% win	0.7837	86.83	0.70
FLUX.1-dev	27.71	22% win	0.6518	83.66	0.56
FLUX.1-dev-FaQ	20.83	78% win	0.6436	83.01	0.66

主结果非常符合方法设计：FID 和 GPT-Fidelity 大幅提升，说明视觉真实感与细节明显变好；GenEval / DPG-Bench 基本持平或轻微下降，说明 fidelity gain 没有显著破坏 prompt following；WISE 提升明显，说明 enhanced text + MLLM knowledge 对世界知识相关生成有帮助。具体来看，MeiGen 的 FID 从 23.97 降到 19.86，GPT-Fidelity 从 12% win 变成 88% win，WISE 从 0.55 到 0.70；FLUX 的 FID 从 27.71 降到 20.83，GPT-Fidelity 从 22% 到 78%，WISE 从 0.56 到 0.66。

5.2 Detailed benchmark breakdown

GenEval：MeiGen-FaQ 的 two object / counting / position 有提升，但 color attr 从 0.6750 降到 0.6175；FLUX-FaQ 整体从 0.6518 到 0.6436 小幅下降。

Method	Single Object	Two Object	Counting	Colors	Position	Color Attr	Overall
MeiGen-Image	0.9906	0.9217	0.7375	0.9069	0.4750	0.6750	0.7845
MeiGen-Image-FaQ	0.9875	0.9520	0.7531	0.8989	0.4934	0.6175	0.7837
FLUX.1-dev	0.9844	0.7955	0.6531	0.7952	0.2375	0.4450	0.6518
FLUX.1-dev-FaQ	1.0000	0.7831	0.6366	0.7897	0.2145	0.4377	0.6436

DPG-Bench：MeiGen-FaQ overall 从 85.94 到 86.83，尤其 Other 从 83.60 到 87.60；FLUX-FaQ overall 从 83.66 到 83.01，relation / other 有小提升但 global / entity 略降。

Method	Global	Entity	Attribute	Relation	Other	Overall
MeiGen-Image	85.11	91.73	88.80	93.36	83.60	85.94
MeiGen-Image-FaQ	85.41	92.12	89.18	93.89	87.60	86.83
FLUX.1-dev	82.67	89.81	86.97	92.80	82.00	83.66
FLUX.1-dev-FaQ	81.46	89.67	87.05	93.04	83.20	83.01

WISE：MeiGen-FaQ overall 从 0.55 到 0.70，FLUX-FaQ 从 0.56 到 0.66，几乎所有 domain 都提升。这个结果支持作者关于 MLLM context/world knowledge 参与生成的主张，但它更像 “understanding helps generation”，不是 “generation helps understanding”。

Method	Cultural	Time	Space	Biology	Physics	Chemistry	Overall
MeiGen-Image	0.54	0.57	0.66	0.48	0.60	0.40	0.55
MeiGen-Image-FaQ	0.74	0.66	0.77	0.64	0.72	0.57	0.70
FLUX.1-dev	0.55	0.60	0.69	0.45	0.58	0.41	0.56
FLUX.1-dev-FaQ	0.70	0.65	0.70	0.62	0.70	0.51	0.66

5.3 Qualitative results

Figure 4 解读：MeiGen-Image-FaQ 在 portrait 场景中主要提升 skin texture、hair details、fabric weave；在非人像场景中减少 AI artifact，并让 foreground/background 高频细节更丰富。这个图展示的是 Quench 注入 visual prior 后对 fidelity 的直接影响，而不是单纯 prompt alignment 的提升。

Figure 5 解读：FLUX.1-dev-FaQ 的提升更集中在减少 waxy skin、过强 cartoon effect、背景虚焦等 FLUX baseline 常见问题。由于 FLUX 原本语义能力强，FaQ 的增益主要体现在真实感和材质细节，而不是对象数量/颜色属性等 alignment 指标。

Figure 10 解读：这是 MeiGen-Image 的更多 qualitative case，覆盖 portrait 与 general scenes。它补充说明 FaQ 的效果不是单个 cherry-picked 示例，而是在多类 prompt 中都改善真实感、纹理细节和整体审美。

Figure 11 解读：第二组 MeiGen 例子继续强调细节层面的提升，尤其是高频纹理与背景元素。结合 GenEval/DPG 结果，可以看出这些视觉改善并没有对应到大幅 alignment 改变，因此更适合作为 fidelity-focused unified generation 方法理解。

Figure 12 解读：FLUX.1-dev 更多例子显示 FaQ 可以迁移到不同 T2I backbone。由于 Quench 只需替换/训练对应 Injection Adapter，这支撑了论文关于 modularity 和低迁移成本的论点。

Figure 13 解读：最后一组 FLUX 例子继续展示 FaQ 对 artifact 的抑制与 texture 的增强。它也暴露出方法边界：论文强调视觉质量提升，但对于 GenEval/DPG 的细粒度指令项并非全面提升。

5.4 Demo / interaction design

Figure 8 解读：系统 prompt 说明 demo 中 MLLM 需要根据用户输入组织生成请求，体现 Forge 阶段不是普通 T2I prompt pass-through，而是带上下文理解的 prompt enhancement。这个部分更偏应用演示，但它连接了论文对 multi-turn interaction / cultural context 的动机。

Figure 9 解读：demo interface 让用户输入自定义 prompt，并 side-by-side 比较 baseline T2I 与 FaQ 输出。它的作用是把 GPT-Fidelity / human eval 的 pairwise comparison 变成可交互验证流程，强调 “same prompt 下 fidelity 更好” 这一核心 claim。

5.5 Conclusions and limitations

总体结论：Forge-and-Quench 给出了一个明确的 “understanding helps generation” 实验路径：冻结 MLLM 保留理解能力，用 MLLM 生成 enhanced text 与 virtual visual feature，再把后者注入冻结 T2I。实验上，FID/GPT-Fidelity/human visual quality 均支持 fidelity 提升，WISE 支持世界知识相关生成增强，GenEval/DPG 基本说明 prompt following 未被大幅破坏。

局限与复现 caveat：第一，MeiGen-Image 与部分训练数据是内部资源，论文未给 GPU type/count；第二，released repo 只有 inference pipeline 和 checkpoints 接口，没有训练脚本，因此 Forge / Quench loss 与数据过滤无法代码级复现；第三，FLUX-FaQ 在 GenEval 和 DPG-Bench overall 有小幅下降，说明 visual fidelity 与 compositional alignment 仍可能存在 trade-off；第四，Bridge Feature target space 很敏感，SigLIP2 的失败说明更强视觉 encoder 不一定更适合作为 forge target。